@obsfx/trekker 0.1.7 → 0.1.9

package/webapp-dist/vendor/next/dist/lib/metadata/types/manifest-types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=manifest-types.js.map

package/webapp-dist/vendor/next/dist/lib/metadata/types/metadata-interface.js

@@ -0,0 +1,18 @@
+/**
+ * Next.js Metadata API
+ *
+ * This file defines the types used by Next.js to configure metadata
+ * through static exports or dynamic `generateMetadata` functions in Server Components.
+ *
+ * @remarks
+ * - The static `metadata` object and `generateMetadata` function are only supported in Server Components.
+ * - Do not export both a `metadata` object and a `generateMetadata` function from the same route segment.
+ * - You can still render metadata in client components directly as part of the component's JSX.
+ *
+ * @see https://nextjs.org/docs/app/api-reference/metadata
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=metadata-interface.js.map

package/webapp-dist/vendor/next/dist/lib/metadata/types/metadata-types.js

@@ -0,0 +1,10 @@
+/**
+ *
+ * Metadata types
+ *
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=metadata-types.js.map

package/webapp-dist/vendor/next/dist/lib/metadata/types/opengraph-types.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=opengraph-types.js.map

package/webapp-dist/vendor/next/dist/lib/metadata/types/resolvers.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=resolvers.js.map

package/webapp-dist/vendor/next/dist/lib/metadata/types/twitter-types.js

@@ -0,0 +1,7 @@
+// Reference: https://developer.twitter.com/en/docs/twitter-for-websites/cards/overview/markup
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+
+//# sourceMappingURL=twitter-types.js.map

package/webapp-dist/vendor/next/dist/lib/mime-type.js

@@ -0,0 +1,20 @@
+/**
+ * Map of images extensions to MIME types
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "imageExtMimeTypeMap", {
+    enumerable: true,
+    get: function() {
+        return imageExtMimeTypeMap;
+    }
+});
+const imageExtMimeTypeMap = {
+    jpeg: 'image/jpeg',
+    png: 'image/png',
+    ico: 'image/x-icon',
+    svg: 'image/svg+xml'
+};
+
+//# sourceMappingURL=mime-type.js.map

package/webapp-dist/vendor/next/dist/lib/mkcert.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createSelfSignedCertificate", {
+    enumerable: true,
+    get: function() {
+        return createSelfSignedCertificate;
+    }
+});
+const _nodefs = /*#__PURE__*/ _interop_require_default(require("node:fs"));
+const _nodepath = /*#__PURE__*/ _interop_require_default(require("node:path"));
+const _nodecrypto = require("node:crypto");
+const _getcachedirectory = require("./helpers/get-cache-directory");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../build/output/log"));
+const _nodechild_process = require("node:child_process");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const { WritableStream } = require('node:stream/web');
+const MKCERT_VERSION = 'v1.4.4';
+function getBinaryName() {
+    const platform = process.platform;
+    const arch = process.arch === 'x64' ? 'amd64' : process.arch;
+    if (platform === 'win32') {
+        return `mkcert-${MKCERT_VERSION}-windows-${arch}.exe`;
+    }
+    if (platform === 'darwin') {
+        return `mkcert-${MKCERT_VERSION}-darwin-${arch}`;
+    }
+    if (platform === 'linux') {
+        return `mkcert-${MKCERT_VERSION}-linux-${arch}`;
+    }
+    throw Object.defineProperty(new Error(`Unsupported platform: ${platform}`), "__NEXT_ERROR_CODE", {
+        value: "E141",
+        enumerable: false,
+        configurable: true
+    });
+}
+async function downloadBinary() {
+    try {
+        const binaryName = getBinaryName();
+        const cacheDirectory = (0, _getcachedirectory.getCacheDirectory)('mkcert');
+        const binaryPath = _nodepath.default.join(cacheDirectory, binaryName);
+        if (_nodefs.default.existsSync(binaryPath)) {
+            return binaryPath;
+        }
+        const downloadUrl = `https://github.com/FiloSottile/mkcert/releases/download/${MKCERT_VERSION}/${binaryName}`;
+        await _nodefs.default.promises.mkdir(cacheDirectory, {
+            recursive: true
+        });
+        _log.info(`Downloading mkcert package...`);
+        const response = await fetch(downloadUrl);
+        if (!response.ok || !response.body) {
+            throw Object.defineProperty(new Error(`request failed with status ${response.status}`), "__NEXT_ERROR_CODE", {
+                value: "E109",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        _log.info(`Download response was successful, writing to disk`);
+        const binaryWriteStream = _nodefs.default.createWriteStream(binaryPath);
+        await response.body.pipeTo(new WritableStream({
+            write (chunk) {
+                return new Promise((resolve, reject)=>{
+                    binaryWriteStream.write(chunk, (error)=>{
+                        if (error) {
+                            reject(error);
+                            return;
+                        }
+                        resolve();
+                    });
+                });
+            },
+            close () {
+                return new Promise((resolve, reject)=>{
+                    binaryWriteStream.close((error)=>{
+                        if (error) {
+                            reject(error);
+                            return;
+                        }
+                        resolve();
+                    });
+                });
+            }
+        }));
+        await _nodefs.default.promises.chmod(binaryPath, 493);
+        return binaryPath;
+    } catch (err) {
+        _log.error('Error downloading mkcert:', err);
+    }
+}
+async function createSelfSignedCertificate(host, certDir = 'certificates') {
+    try {
+        const binaryPath = await downloadBinary();
+        if (!binaryPath) throw Object.defineProperty(new Error('missing mkcert binary'), "__NEXT_ERROR_CODE", {
+            value: "E198",
+            enumerable: false,
+            configurable: true
+        });
+        const resolvedCertDir = _nodepath.default.resolve(process.cwd(), `./${certDir}`);
+        await _nodefs.default.promises.mkdir(resolvedCertDir, {
+            recursive: true
+        });
+        const keyPath = _nodepath.default.resolve(resolvedCertDir, 'localhost-key.pem');
+        const certPath = _nodepath.default.resolve(resolvedCertDir, 'localhost.pem');
+        if (_nodefs.default.existsSync(keyPath) && _nodefs.default.existsSync(certPath)) {
+            const cert = new _nodecrypto.X509Certificate(_nodefs.default.readFileSync(certPath));
+            const key = _nodefs.default.readFileSync(keyPath);
+            if (cert.checkHost(host ?? 'localhost') && cert.checkPrivateKey((0, _nodecrypto.createPrivateKey)(key))) {
+                _log.info('Using already generated self signed certificate');
+                const caLocation = (0, _nodechild_process.execSync)(`"${binaryPath}" -CAROOT`).toString().trim();
+                return {
+                    key: keyPath,
+                    cert: certPath,
+                    rootCA: `${caLocation}/rootCA.pem`
+                };
+            }
+        }
+        _log.info('Attempting to generate self signed certificate. This may prompt for your password');
+        const defaultHosts = [
+            'localhost',
+            '127.0.0.1',
+            '::1'
+        ];
+        const hosts = host && !defaultHosts.includes(host) ? [
+            ...defaultHosts,
+            host
+        ] : defaultHosts;
+        (0, _nodechild_process.execSync)(`"${binaryPath}" -install -key-file "${keyPath}" -cert-file "${certPath}" ${hosts.join(' ')}`, {
+            stdio: 'ignore'
+        });
+        const caLocation = (0, _nodechild_process.execSync)(`"${binaryPath}" -CAROOT`).toString().trim();
+        if (!_nodefs.default.existsSync(keyPath) || !_nodefs.default.existsSync(certPath)) {
+            throw Object.defineProperty(new Error('Certificate files not found'), "__NEXT_ERROR_CODE", {
+                value: "E131",
+                enumerable: false,
+                configurable: true
+            });
+        }
+        _log.info(`CA Root certificate created in ${caLocation}`);
+        _log.info(`Certificates created in ${resolvedCertDir}`);
+        const gitignorePath = _nodepath.default.resolve(process.cwd(), './.gitignore');
+        if (_nodefs.default.existsSync(gitignorePath)) {
+            const gitignore = await _nodefs.default.promises.readFile(gitignorePath, 'utf8');
+            if (!gitignore.includes(certDir)) {
+                _log.info('Adding certificates to .gitignore');
+                await _nodefs.default.promises.appendFile(gitignorePath, `\n${certDir}`);
+            }
+        }
+        return {
+            key: keyPath,
+            cert: certPath,
+            rootCA: `${caLocation}/rootCA.pem`
+        };
+    } catch (err) {
+        _log.error('Failed to generate self-signed certificate. Falling back to http.', err);
+    }
+}
+
+//# sourceMappingURL=mkcert.js.map

package/webapp-dist/vendor/next/dist/lib/multi-file-writer.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "MultiFileWriter", {
+    enumerable: true,
+    get: function() {
+        return MultiFileWriter;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("../shared/lib/isomorphic/path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+class MultiFileWriter {
+    constructor(/**
+     * The file system methods to use.
+     */ fs){
+        this.fs = fs;
+        this.tasks = [];
+    }
+    /**
+   * Finds or creates a task for a directory.
+   *
+   * @param directory - The directory to find or create a task for.
+   * @returns The task for the directory.
+   */ findOrCreateTask(directory) {
+        // See if this directory already has a task to create it.
+        for (const task of this.tasks){
+            if (task[0] === directory) {
+                return task;
+            }
+        }
+        const promise = this.fs.mkdir(directory);
+        // Attach a catch handler so that it doesn't throw an unhandled promise
+        // rejection warning.
+        promise.catch(()=>{});
+        // Otherwise, create a new task for this directory.
+        const task = [
+            directory,
+            promise,
+            []
+        ];
+        this.tasks.push(task);
+        return task;
+    }
+    /**
+   * Appends a file to the writer to be written after its containing directory
+   * is created. The file writer should be awaited after all the files have been
+   * appended. Any async operation that occurs between appending and awaiting
+   * may cause an unhandled promise rejection warning and potentially crash the
+   * process.
+   *
+   * @param filePath - The path to the file to write.
+   * @param data - The data to write to the file.
+   */ append(filePath, data) {
+        // Find or create a task for the directory that contains the file.
+        const task = this.findOrCreateTask(_path.default.dirname(filePath));
+        const promise = task[1].then(()=>this.fs.writeFile(filePath, data));
+        // Attach a catch handler so that it doesn't throw an unhandled promise
+        // rejection warning.
+        promise.catch(()=>{});
+        // Add the file write to the task AFTER the directory promise has resolved.
+        task[2].push(promise);
+    }
+    /**
+   * Returns a promise that resolves when all the files have been written.
+   */ wait() {
+        return Promise.all(this.tasks.flatMap((task)=>task[2]));
+    }
+}
+
+//# sourceMappingURL=multi-file-writer.js.map

package/webapp-dist/vendor/next/dist/lib/needs-experimental-react.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "needsExperimentalReact", {
+    enumerable: true,
+    get: function() {
+        return needsExperimentalReact;
+    }
+});
+function needsExperimentalReact(config) {
+    const { taint, transitionIndicator } = config.experimental || {};
+    return Boolean(taint || transitionIndicator);
+}
+
+//# sourceMappingURL=needs-experimental-react.js.map

package/webapp-dist/vendor/next/dist/lib/non-nullable.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "nonNullable", {
+    enumerable: true,
+    get: function() {
+        return nonNullable;
+    }
+});
+function nonNullable(value) {
+    return value !== null && value !== undefined;
+}
+
+//# sourceMappingURL=non-nullable.js.map

package/webapp-dist/vendor/next/dist/lib/normalize-path.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "normalizePath", {
+    enumerable: true,
+    get: function() {
+        return normalizePath;
+    }
+});
+const _path = /*#__PURE__*/ _interop_require_default(require("path"));
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function normalizePath(file) {
+    return _path.default.sep === '\\' ? file.replace(/\\/g, '/') : file;
+}
+
+//# sourceMappingURL=normalize-path.js.map

package/webapp-dist/vendor/next/dist/lib/oxford-comma-list.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "getOxfordCommaList", {
+    enumerable: true,
+    get: function() {
+        return getOxfordCommaList;
+    }
+});
+function getOxfordCommaList(items) {
+    return items.map((v, index, { length })=>(index > 0 ? index === length - 1 ? length > 2 ? ', and ' : ' and ' : ', ' : '') + v).join('');
+}
+
+//# sourceMappingURL=oxford-comma-list.js.map

package/webapp-dist/vendor/next/dist/lib/page-types.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "PAGE_TYPES", {
+    enumerable: true,
+    get: function() {
+        return PAGE_TYPES;
+    }
+});
+var PAGE_TYPES = /*#__PURE__*/ function(PAGE_TYPES) {
+    PAGE_TYPES["PAGES"] = "pages";
+    PAGE_TYPES["ROOT"] = "root";
+    PAGE_TYPES["APP"] = "app";
+    return PAGE_TYPES;
+}({});
+
+//# sourceMappingURL=page-types.js.map

package/webapp-dist/vendor/next/dist/lib/patch-incorrect-lockfile.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "patchIncorrectLockfile", {
+    enumerable: true,
+    get: function() {
+        return patchIncorrectLockfile;
+    }
+});
+const _fs = require("fs");
+const _log = /*#__PURE__*/ _interop_require_wildcard(require("../build/output/log"));
+const _findup = /*#__PURE__*/ _interop_require_default(require("next/dist/compiled/find-up"));
+const _packagejson = /*#__PURE__*/ _interop_require_default(require("next/package.json"));
+const _ciinfo = require("../server/ci-info");
+const _getregistry = require("./helpers/get-registry");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+let registry;
+async function fetchPkgInfo(pkg) {
+    if (!registry) registry = (0, _getregistry.getRegistry)();
+    const res = await fetch(`${registry}${pkg}`);
+    if (!res.ok) {
+        throw Object.defineProperty(new Error(`Failed to fetch registry info for ${pkg}, got status ${res.status}`), "__NEXT_ERROR_CODE", {
+            value: "E172",
+            enumerable: false,
+            configurable: true
+        });
+    }
+    const data = await res.json();
+    const versionData = data.versions[_packagejson.default.version];
+    return {
+        os: versionData.os,
+        cpu: versionData.cpu,
+        engines: versionData.engines,
+        tarball: versionData.dist.tarball,
+        integrity: versionData.dist.integrity
+    };
+}
+async function patchIncorrectLockfile(dir) {
+    if (process.env.NEXT_IGNORE_INCORRECT_LOCKFILE) {
+        return;
+    }
+    const lockfilePath = await (0, _findup.default)('package-lock.json', {
+        cwd: dir
+    });
+    if (!lockfilePath) {
+        // if no lockfile present there is no action to take
+        return;
+    }
+    const content = await _fs.promises.readFile(lockfilePath, 'utf8');
+    // maintain current line ending
+    const endingNewline = content.endsWith('\r\n') ? '\r\n' : content.endsWith('\n') ? '\n' : '';
+    const lockfileParsed = JSON.parse(content);
+    const lockfileVersion = parseInt(lockfileParsed == null ? void 0 : lockfileParsed.lockfileVersion, 10);
+    const expectedSwcPkgs = Object.keys(_packagejson.default['optionalDependencies'] || {}).filter((pkg)=>pkg.startsWith('@next/swc-'));
+    const patchDependency = (pkg, pkgData)=>{
+        lockfileParsed.dependencies[pkg] = {
+            version: _packagejson.default.version,
+            resolved: pkgData.tarball,
+            integrity: pkgData.integrity,
+            optional: true
+        };
+    };
+    const patchPackage = (pkg, pkgData)=>{
+        lockfileParsed.packages[pkg] = {
+            version: _packagejson.default.version,
+            resolved: pkgData.tarball,
+            integrity: pkgData.integrity,
+            cpu: pkgData.cpu,
+            optional: true,
+            os: pkgData.os,
+            engines: pkgData.engines
+        };
+    };
+    try {
+        const supportedVersions = [
+            1,
+            2,
+            3
+        ];
+        if (!supportedVersions.includes(lockfileVersion)) {
+            // bail on unsupported version
+            return;
+        }
+        // v1 only uses dependencies
+        // v2 uses dependencies and packages
+        // v3 only uses packages
+        const shouldPatchDependencies = lockfileVersion === 1 || lockfileVersion === 2;
+        const shouldPatchPackages = lockfileVersion === 2 || lockfileVersion === 3;
+        if (shouldPatchDependencies && !lockfileParsed.dependencies || shouldPatchPackages && !lockfileParsed.packages) {
+            // invalid lockfile so bail
+            return;
+        }
+        const missingSwcPkgs = [];
+        let pkgPrefix;
+        if (shouldPatchPackages) {
+            pkgPrefix = '';
+            for (const pkg of Object.keys(lockfileParsed.packages)){
+                if (pkg.endsWith('node_modules/next')) {
+                    pkgPrefix = pkg.substring(0, pkg.length - 4);
+                }
+            }
+            if (!pkgPrefix) {
+                // unable to locate the next package so bail
+                return;
+            }
+        }
+        for (const pkg of expectedSwcPkgs){
+            if (shouldPatchDependencies && !lockfileParsed.dependencies[pkg] || shouldPatchPackages && !lockfileParsed.packages[`${pkgPrefix}${pkg}`]) {
+                missingSwcPkgs.push(pkg);
+            }
+        }
+        if (missingSwcPkgs.length === 0) {
+            return;
+        }
+        _log.warn(`Found lockfile missing swc dependencies,`, _ciinfo.isCI ? 'run next locally to automatically patch' : 'patching...');
+        if (_ciinfo.isCI) {
+            // no point in updating in CI as the user can't save the patch
+            return;
+        }
+        const pkgsData = await Promise.all(missingSwcPkgs.map((pkg)=>fetchPkgInfo(pkg)));
+        for(let i = 0; i < pkgsData.length; i++){
+            const pkg = missingSwcPkgs[i];
+            const pkgData = pkgsData[i];
+            if (shouldPatchDependencies) {
+                patchDependency(pkg, pkgData);
+            }
+            if (shouldPatchPackages) {
+                patchPackage(`${pkgPrefix}${pkg}`, pkgData);
+            }
+        }
+        await _fs.promises.writeFile(lockfilePath, JSON.stringify(lockfileParsed, null, 2) + endingNewline);
+        _log.warn('Lockfile was successfully patched, please run "npm install" to ensure @next/swc dependencies are downloaded');
+    } catch (err) {
+        _log.error(`Failed to patch lockfile, please try uninstalling and reinstalling next in this workspace`);
+        console.error(err);
+    }
+}
+
+//# sourceMappingURL=patch-incorrect-lockfile.js.map

package/webapp-dist/vendor/next/dist/lib/pick.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "pick", {
+    enumerable: true,
+    get: function() {
+        return pick;
+    }
+});
+function pick(obj, keys) {
+    const newObj = {};
+    for (const key of keys){
+        newObj[key] = obj[key];
+    }
+    return newObj;
+}
+
+//# sourceMappingURL=pick.js.map