vibebusiness 1.2.73 → 1.2.75

package/.next/standalone/node_modules/chrome-trace-event/dist/trace-event.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * trace-event - A library to create a trace of your node app per
+ * Google's Trace Event format:
+ * // JSSTYLED
+ *      https://docs.google.com/document/d/1CvAClvFfyA5R-PhYUmn5OOQtYMH4h6I0nSsKchNAySU
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tracer = void 0;
+const stream_1 = require("stream");
+function evCommon() {
+    var hrtime = process.hrtime(); // [seconds, nanoseconds]
+    var ts = hrtime[0] * 1000000 + Math.round(hrtime[1] / 1000); // microseconds
+    return {
+        ts,
+        pid: process.pid,
+        tid: process.pid // no meaningful tid for node.js
+    };
+}
+class Tracer extends stream_1.Readable {
+    constructor(opts = {}) {
+        super();
+        this.noStream = false;
+        this.events = [];
+        if (typeof opts !== "object") {
+            throw new Error("Invalid options passed (must be an object)");
+        }
+        if (opts.parent != null && typeof opts.parent !== "object") {
+            throw new Error("Invalid option (parent) passed (must be an object)");
+        }
+        if (opts.fields != null && typeof opts.fields !== "object") {
+            throw new Error("Invalid option (fields) passed (must be an object)");
+        }
+        if (opts.objectMode != null &&
+            (opts.objectMode !== true && opts.objectMode !== false)) {
+            throw new Error("Invalid option (objectsMode) passed (must be a boolean)");
+        }
+        this.noStream = opts.noStream || false;
+        this.parent = opts.parent;
+        if (this.parent) {
+            this.fields = Object.assign({}, opts.parent && opts.parent.fields);
+        }
+        else {
+            this.fields = {};
+        }
+        if (opts.fields) {
+            Object.assign(this.fields, opts.fields);
+        }
+        if (!this.fields.cat) {
+            // trace-viewer *requires* `cat`, so let's have a fallback.
+            this.fields.cat = "default";
+        }
+        else if (Array.isArray(this.fields.cat)) {
+            this.fields.cat = this.fields.cat.join(",");
+        }
+        if (!this.fields.args) {
+            // trace-viewer *requires* `args`, so let's have a fallback.
+            this.fields.args = {};
+        }
+        if (this.parent) {
+            // TODO: Not calling Readable ctor here. Does that cause probs?
+            //      Probably if trying to pipe from the child.
+            //      Might want a serpate TracerChild class for these guys.
+            this._push = this.parent._push.bind(this.parent);
+        }
+        else {
+            this._objectMode = Boolean(opts.objectMode);
+            var streamOpts = { objectMode: this._objectMode };
+            if (this._objectMode) {
+                this._push = this.push;
+            }
+            else {
+                this._push = this._pushString;
+                streamOpts.encoding = "utf8";
+            }
+            stream_1.Readable.call(this, streamOpts);
+        }
+    }
+    /**
+     * If in no streamMode in order to flush out the trace
+     * you need to call flush.
+     */
+    flush() {
+        if (this.noStream === true) {
+            for (const evt of this.events) {
+                this._push(evt);
+            }
+            this._flush();
+        }
+    }
+    _read(_) { }
+    _pushString(ev) {
+        var separator = "";
+        if (!this.firstPush) {
+            this.push("[");
+            this.firstPush = true;
+        }
+        else {
+            separator = ",\n";
+        }
+        this.push(separator + JSON.stringify(ev), "utf8");
+    }
+    _flush() {
+        if (!this._objectMode) {
+            this.push("]");
+        }
+    }
+    child(fields) {
+        return new Tracer({
+            parent: this,
+            fields: fields
+        });
+    }
+    begin(fields) {
+        return this.mkEventFunc("B")(fields);
+    }
+    end(fields) {
+        return this.mkEventFunc("E")(fields);
+    }
+    completeEvent(fields) {
+        return this.mkEventFunc("X")(fields);
+    }
+    instantEvent(fields) {
+        return this.mkEventFunc("I")(fields);
+    }
+    mkEventFunc(ph) {
+        return (fields) => {
+            var ev = evCommon();
+            // Assign the event phase.
+            ev.ph = ph;
+            if (fields) {
+                if (typeof fields === "string") {
+                    ev.name = fields;
+                }
+                else {
+                    for (const k of Object.keys(fields)) {
+                        if (k === "cat") {
+                            ev.cat = fields.cat.join(",");
+                        }
+                        else {
+                            ev[k] = fields[k];
+                        }
+                    }
+                }
+            }
+            if (!this.noStream) {
+                this._push(ev);
+            }
+            else {
+                this.events.push(ev);
+            }
+        };
+    }
+}
+exports.Tracer = Tracer;
+/*
+ * These correspond to the "Async events" in the Trace Events doc.
+ *
+ * Required fields:
+ * - name
+ * - id
+ *
+ * Optional fields:
+ * - cat (array)
+ * - args (object)
+ * - TODO: stack fields, other optional fields?
+ *
+ * Dev Note: We don't explicitly assert that correct fields are
+ * used for speed (premature optimization alert!).
+ */

package/.next/standalone/node_modules/chrome-trace-event/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "chrome-trace-event",
+  "description": "A library to create a trace of your node app per Google's Trace Event format.",
+  "license": "MIT",
+  "version": "1.0.4",
+  "author": "Trent Mick, Sam Saccone",
+  "keywords": [
+    "trace-event",
+    "trace",
+    "event",
+    "trace-viewer",
+    "google"
+  ],
+  "repository": {
+    "url": "github:samccone/chrome-trace-event"
+  },
+  "main": "./dist/trace-event.js",
+  "typings": "./dist/trace-event.d.ts",
+  "dependencies": {},
+  "devDependencies": {
+    "@types/node": "*",
+    "prettier": "^1.12.1",
+    "tape": "4.8.0",
+    "typescript": "^4.2.4"
+  },
+  "engines": {
+    "node": ">=6.0"
+  },
+  "files": [
+    "dist",
+    "CHANGES.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "check_format": "prettier -l lib/** test/** examples/**",
+    "test": "tape test/*.test.js"
+  }
+}

package/.next/standalone/node_modules/electron-to-chromium/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "electron-to-chromium",
+  "version": "1.5.282",
+  "description": "Provides a list of electron-to-chromium version mappings",
+  "main": "index.js",
+  "files": [
+    "versions.js",
+    "full-versions.js",
+    "chromium-versions.js",
+    "full-chromium-versions.js",
+    "versions.json",
+    "full-versions.json",
+    "chromium-versions.json",
+    "full-chromium-versions.json",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "node build.mjs",
+    "update": "node automated-update.js",
+    "test": "nyc ava --verbose",
+    "report": "nyc report --reporter=text-lcov > coverage.lcov && codecov"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kilian/electron-to-chromium/"
+  },
+  "keywords": [
+    "electron",
+    "chrome",
+    "chromium",
+    "browserslist",
+    "browserlist"
+  ],
+  "author": "Kilian Valkhof",
+  "license": "ISC",
+  "devDependencies": {
+    "ava": "^5.1.1",
+    "codecov": "^3.8.2",
+    "compare-versions": "^6.0.0-rc.1",
+    "node-fetch": "^3.3.0",
+    "nyc": "^15.1.0",
+    "shelljs": "^0.8.5"
+  }
+}

package/.next/standalone/node_modules/electron-to-chromium/versions.js

@@ -0,0 +1,229 @@
+module.exports = {
+	"0.20": "39",
+	"0.21": "41",
+	"0.22": "41",
+	"0.23": "41",
+	"0.24": "41",
+	"0.25": "42",
+	"0.26": "42",
+	"0.27": "43",
+	"0.28": "43",
+	"0.29": "43",
+	"0.30": "44",
+	"0.31": "45",
+	"0.32": "45",
+	"0.33": "45",
+	"0.34": "45",
+	"0.35": "45",
+	"0.36": "47",
+	"0.37": "49",
+	"1.0": "49",
+	"1.1": "50",
+	"1.2": "51",
+	"1.3": "52",
+	"1.4": "53",
+	"1.5": "54",
+	"1.6": "56",
+	"1.7": "58",
+	"1.8": "59",
+	"2.0": "61",
+	"2.1": "61",
+	"3.0": "66",
+	"3.1": "66",
+	"4.0": "69",
+	"4.1": "69",
+	"4.2": "69",
+	"5.0": "73",
+	"6.0": "76",
+	"6.1": "76",
+	"7.0": "78",
+	"7.1": "78",
+	"7.2": "78",
+	"7.3": "78",
+	"8.0": "80",
+	"8.1": "80",
+	"8.2": "80",
+	"8.3": "80",
+	"8.4": "80",
+	"8.5": "80",
+	"9.0": "83",
+	"9.1": "83",
+	"9.2": "83",
+	"9.3": "83",
+	"9.4": "83",
+	"10.0": "85",
+	"10.1": "85",
+	"10.2": "85",
+	"10.3": "85",
+	"10.4": "85",
+	"11.0": "87",
+	"11.1": "87",
+	"11.2": "87",
+	"11.3": "87",
+	"11.4": "87",
+	"11.5": "87",
+	"12.0": "89",
+	"12.1": "89",
+	"12.2": "89",
+	"13.0": "91",
+	"13.1": "91",
+	"13.2": "91",
+	"13.3": "91",
+	"13.4": "91",
+	"13.5": "91",
+	"13.6": "91",
+	"14.0": "93",
+	"14.1": "93",
+	"14.2": "93",
+	"15.0": "94",
+	"15.1": "94",
+	"15.2": "94",
+	"15.3": "94",
+	"15.4": "94",
+	"15.5": "94",
+	"16.0": "96",
+	"16.1": "96",
+	"16.2": "96",
+	"17.0": "98",
+	"17.1": "98",
+	"17.2": "98",
+	"17.3": "98",
+	"17.4": "98",
+	"18.0": "100",
+	"18.1": "100",
+	"18.2": "100",
+	"18.3": "100",
+	"19.0": "102",
+	"19.1": "102",
+	"20.0": "104",
+	"20.1": "104",
+	"20.2": "104",
+	"20.3": "104",
+	"21.0": "106",
+	"21.1": "106",
+	"21.2": "106",
+	"21.3": "106",
+	"21.4": "106",
+	"22.0": "108",
+	"22.1": "108",
+	"22.2": "108",
+	"22.3": "108",
+	"23.0": "110",
+	"23.1": "110",
+	"23.2": "110",
+	"23.3": "110",
+	"24.0": "112",
+	"24.1": "112",
+	"24.2": "112",
+	"24.3": "112",
+	"24.4": "112",
+	"24.5": "112",
+	"24.6": "112",
+	"24.7": "112",
+	"24.8": "112",
+	"25.0": "114",
+	"25.1": "114",
+	"25.2": "114",
+	"25.3": "114",
+	"25.4": "114",
+	"25.5": "114",
+	"25.6": "114",
+	"25.7": "114",
+	"25.8": "114",
+	"25.9": "114",
+	"26.0": "116",
+	"26.1": "116",
+	"26.2": "116",
+	"26.3": "116",
+	"26.4": "116",
+	"26.5": "116",
+	"26.6": "116",
+	"27.0": "118",
+	"27.1": "118",
+	"27.2": "118",
+	"27.3": "118",
+	"28.0": "120",
+	"28.1": "120",
+	"28.2": "120",
+	"28.3": "120",
+	"29.0": "122",
+	"29.1": "122",
+	"29.2": "122",
+	"29.3": "122",
+	"29.4": "122",
+	"30.0": "124",
+	"30.1": "124",
+	"30.2": "124",
+	"30.3": "124",
+	"30.4": "124",
+	"30.5": "124",
+	"31.0": "126",
+	"31.1": "126",
+	"31.2": "126",
+	"31.3": "126",
+	"31.4": "126",
+	"31.5": "126",
+	"31.6": "126",
+	"31.7": "126",
+	"32.0": "128",
+	"32.1": "128",
+	"32.2": "128",
+	"32.3": "128",
+	"33.0": "130",
+	"33.1": "130",
+	"33.2": "130",
+	"33.3": "130",
+	"33.4": "130",
+	"34.0": "132",
+	"34.1": "132",
+	"34.2": "132",
+	"34.3": "132",
+	"34.4": "132",
+	"34.5": "132",
+	"35.0": "134",
+	"35.1": "134",
+	"35.2": "134",
+	"35.3": "134",
+	"35.4": "134",
+	"35.5": "134",
+	"35.6": "134",
+	"35.7": "134",
+	"36.0": "136",
+	"36.1": "136",
+	"36.2": "136",
+	"36.3": "136",
+	"36.4": "136",
+	"36.5": "136",
+	"36.6": "136",
+	"36.7": "136",
+	"36.8": "136",
+	"36.9": "136",
+	"37.0": "138",
+	"37.1": "138",
+	"37.2": "138",
+	"37.3": "138",
+	"37.4": "138",
+	"37.5": "138",
+	"37.6": "138",
+	"37.7": "138",
+	"37.8": "138",
+	"37.9": "138",
+	"37.10": "138",
+	"38.0": "140",
+	"38.1": "140",
+	"38.2": "140",
+	"38.3": "140",
+	"38.4": "140",
+	"38.5": "140",
+	"38.6": "140",
+	"38.7": "140",
+	"38.8": "140",
+	"39.0": "142",
+	"39.1": "142",
+	"39.2": "142",
+	"39.3": "142",
+	"39.4": "142",
+	"40.0": "144",
+	"40.1": "144",
+	"41.0": "146"
+};

package/.next/standalone/node_modules/enhanced-resolve/lib/AliasFieldPlugin.js

@@ -0,0 +1,103 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+const DescriptionFileUtils = require("./DescriptionFileUtils");
+const getInnerRequest = require("./getInnerRequest");
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").JsonPrimitive} JsonPrimitive */
+/** @typedef {import("./Resolver").ResolveRequest} ResolveRequest */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+
+module.exports = class AliasFieldPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {string | string[]} field field
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, field, target) {
+		this.source = source;
+		this.field = field;
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+		resolver
+			.getHook(this.source)
+			.tapAsync("AliasFieldPlugin", (request, resolveContext, callback) => {
+				if (!request.descriptionFileData) return callback();
+				const innerRequest = getInnerRequest(resolver, request);
+				if (!innerRequest) return callback();
+				const fieldData = DescriptionFileUtils.getField(
+					request.descriptionFileData,
+					this.field,
+				);
+				if (fieldData === null || typeof fieldData !== "object") {
+					if (resolveContext.log) {
+						resolveContext.log(
+							`Field '${this.field}' doesn't contain a valid alias configuration`,
+						);
+					}
+					return callback();
+				}
+				/** @type {JsonPrimitive | undefined} */
+				const data = Object.prototype.hasOwnProperty.call(
+					fieldData,
+					innerRequest,
+				)
+					? /** @type {{ [Key in string]: JsonPrimitive }} */ (fieldData)[
+							innerRequest
+						]
+					: innerRequest.startsWith("./")
+						? /** @type {{ [Key in string]: JsonPrimitive }} */ (fieldData)[
+								innerRequest.slice(2)
+							]
+						: undefined;
+				if (data === innerRequest) return callback();
+				if (data === undefined) return callback();
+				if (data === false) {
+					/** @type {ResolveRequest} */
+					const ignoreObj = {
+						...request,
+						path: false,
+					};
+					if (typeof resolveContext.yield === "function") {
+						resolveContext.yield(ignoreObj);
+						return callback(null, null);
+					}
+					return callback(null, ignoreObj);
+				}
+				/** @type {ResolveRequest} */
+				const obj = {
+					...request,
+					path: /** @type {string} */ (request.descriptionFileRoot),
+					request: /** @type {string} */ (data),
+					fullySpecified: false,
+				};
+				resolver.doResolve(
+					target,
+					obj,
+					`aliased from description file ${
+						request.descriptionFilePath
+					} with mapping '${innerRequest}' to '${/** @type {string} */ data}'`,
+					resolveContext,
+					(err, result) => {
+						if (err) return callback(err);
+
+						// Don't allow other aliasing or raw request
+						if (result === undefined) return callback(null, null);
+						callback(null, result);
+					},
+				);
+			});
+	}
+};

package/.next/standalone/node_modules/enhanced-resolve/lib/AliasPlugin.js

@@ -0,0 +1,47 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Tobias Koppers @sokra
+*/
+
+"use strict";
+
+/** @typedef {import("./Resolver")} Resolver */
+/** @typedef {import("./Resolver").ResolveStepHook} ResolveStepHook */
+/** @typedef {string | string[] | false} Alias */
+/** @typedef {{ alias: Alias, name: string, onlyModule?: boolean }} AliasOption */
+
+const { aliasResolveHandler } = require("./AliasUtils");
+
+module.exports = class AliasPlugin {
+	/**
+	 * @param {string | ResolveStepHook} source source
+	 * @param {AliasOption | AliasOption[]} options options
+	 * @param {string | ResolveStepHook} target target
+	 */
+	constructor(source, options, target) {
+		this.source = source;
+		this.options = Array.isArray(options) ? options : [options];
+		this.target = target;
+	}
+
+	/**
+	 * @param {Resolver} resolver the resolver
+	 * @returns {void}
+	 */
+	apply(resolver) {
+		const target = resolver.ensureHook(this.target);
+
+		resolver
+			.getHook(this.source)
+			.tapAsync("AliasPlugin", (request, resolveContext, callback) => {
+				aliasResolveHandler(
+					resolver,
+					this.options,
+					target,
+					request,
+					resolveContext,
+					callback,
+				);
+			});
+	}
+};