@canopycanopycanopy/b-ber-logger 3.0.8-nav.0 → 3.0.8-next.96

package/dist/index.js

@@ -1,132 +1,621 @@
-"use strict";
-
-var _bindInstanceProperty2 = require("@babel/runtime-corejs3/core-js-stable/instance/bind");
-var _Object$defineProperty = require("@babel/runtime-corejs3/core-js-stable/object/define-property");
-var _interopRequireDefault = require("@babel/runtime-corejs3/helpers/interopRequireDefault");
-_Object$defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _bind = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/bind"));
-var _reduce = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/reduce"));
-var _forEach = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/instance/for-each"));
-var _keys = _interopRequireDefault(require("@babel/runtime-corejs3/core-js-stable/object/keys"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime-corejs3/helpers/defineProperty"));
-var _lodash = _interopRequireDefault(require("lodash.has"));
-var _lodash2 = _interopRequireDefault(require("lodash.isundefined"));
-var _Timer = _interopRequireDefault(require("./Timer"));
-var _printer = require("./printer");
-var _indenter = require("./indenter");
-var _listeners = require("./listeners");
-var _events = require("./events");
-var _warn = require("./warn");
-var _info = require("./info");
-var _error = require("./error");
-var _debug = require("./debug");
-var _trace = require("./trace");
-var _notice = require("./notice");
-var _inspect = require("./inspect");
-var _summary = require("./summary");
-var _configure = require("./configure");
-var _printVersion = require("./print-version");
-var _register = require("./register");
-var _format = require("./format");
-var _context4 = require("./context");
-var _compose = require("./compose");
-var _reset = require("./reset");
-class Logger extends _Timer.default {
-  constructor() {
-    var _context, _context2, _context3;
-    super();
-    this.logLevel = Logger.defaults.logLevel;
-    this.boringOutput = Logger.defaults.boringOutput;
-    this.command = Logger.defaults.command;
-    this.consoleWidth = Logger.defaults.consoleWidth;
-    this.errors = Logger.defaults.errors;
-    this.warnings = Logger.defaults.warnings;
-    this.taskWarnings = Logger.defaults.taskWarnings;
-    this.taskErrors = Logger.defaults.taskErrors;
-    this.whitespace = Logger.defaults.whitespace;
-    this.increment = Logger.defaults.increment;
-    this.indentLevel = Logger.defaults.indentLevel;
-    this.taskCounter = Logger.defaults.taskCounter;
-    this.context = Logger.defaults.context;
-
-    // options
-    this.settings = {
-      quiet: false,
-      verbose: false,
-      debug: false,
-      summary: Logger.defaults.summary,
-      'no-color': Logger.defaults.boringOutput,
-      'log-level': Logger.defaults.logLevel
-    };
-
-    // bindings
-    this.printWarnings = (0, _bind.default)(_printer.printWarnings).call(_printer.printWarnings, this);
-    this.printErrors = (0, _bind.default)(_printer.printErrors).call(_printer.printErrors, this);
-    this.indent = (0, _bind.default)(_indenter.indent).call(_indenter.indent, this);
-    this.incrementIndent = (0, _bind.default)(_indenter.incrementIndent).call(_indenter.incrementIndent, this);
-    this.decrementIndent = (0, _bind.default)(_indenter.decrementIndent).call(_indenter.decrementIndent, this);
-    this.incrementCounter = (0, _bind.default)(_indenter.incrementCounter).call(_indenter.incrementCounter, this);
-    this.decrementCounter = (0, _bind.default)(_indenter.decrementCounter).call(_indenter.decrementCounter, this);
-    this.bind = (0, _bind.default)(_bindInstanceProperty2(_listeners)).call(_bindInstanceProperty2(_listeners), this);
-    this.notify = (0, _bind.default)(_events.notify).call(_events.notify, this);
-    this.warn = (0, _bind.default)(_warn.warn).call(_warn.warn, this);
-    this.info = (0, _bind.default)(_info.info).call(_info.info, this);
-    this.error = (0, _bind.default)(_error.error).call(_error.error, this);
-    this.debug = (0, _bind.default)(_debug.debug).call(_debug.debug, this);
-    this.trace = (0, _bind.default)(_trace.trace).call(_trace.trace, this);
-    this.notice = (0, _bind.default)(_notice.notice).call(_notice.notice, this);
-    this.inspect = (0, _bind.default)(_inspect.inspect).call(_inspect.inspect, this);
-    this.printSummary = (0, _bind.default)(_summary.printSummary).call(_summary.printSummary, this);
-    this.configure = (0, _bind.default)(_configure.configure).call(_configure.configure, this);
-    this.printVersion = (0, _bind.default)(_printVersion.printVersion).call(_printVersion.printVersion, this);
-    this.registerSequence = (0, _bind.default)(_register.registerSequence).call(_register.registerSequence, this);
-    this.wrap = (0, _bind.default)(_format.wrap).call(_format.wrap, this);
-    this.decorate = (0, _bind.default)(_format.decorate).call(_format.decorate, this);
-    this.floatFormat = (0, _bind.default)(_format.floatFormat).call(_format.floatFormat, this);
-    this.counter = (0, _bind.default)(_context4.counter).call(_context4.counter, this);
-    this.getContext = (0, _bind.default)(_context4.getContext).call(_context4.getContext, this);
-    this.composeMessage = (0, _bind.default)(_compose.composeMessage).call(_compose.composeMessage, this);
-    this.reset = (0, _bind.default)(_reset.reset).call(_reset.reset, this);
-
-    // parse args
-    const argv = (0, _reduce.default)(_context = process.argv).call(_context, (acc, curr) => {
-      const [k, v] = curr.split('=');
-      // eslint-disable-next-line no-restricted-globals
-      acc[k] = (0, _lodash2.default)(v) ? true : !isNaN(v) ? Number(v) : v;
-      return acc;
-    }, {});
-    (0, _forEach.default)(_context2 = (0, _keys.default)(this.settings)).call(_context2, a => {
-      const opt = `--${a}`;
-      if ((0, _lodash.default)(argv, opt)) this.settings[a] = argv[opt];
-    });
-    this.configure();
-    (0, _bind.default)(_context3 = this).call(_context3);
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  newLine() {
-    process.stdout.write('\n');
-  }
-}
-(0, _defineProperty2.default)(Logger, "defaults", {
-  logLevel: 2,
-  boringOutput: false,
-  summary: false,
-  command: null,
-  consoleWidth: 70,
-  errors: [],
-  warnings: [],
-  taskWarnings: 0,
-  taskErrors: 0,
-  whitespace: ' ',
-  increment: 0,
-  indentLevel: 0,
-  taskCounter: -1,
-  context: null
-});
-const log = new Logger();
-var _default = log;
-exports.default = _default;
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let util = require("util");
+util = __toESM(util);
+let events = require("events");
+let chalk = require("chalk");
+chalk = __toESM(chalk);
+//#region src/compose.ts
+function composeMessage(args) {
+	return util.default.format.call(util.default, ...args).split("\n").map((a) => a.trim()).join(`\n${" ".repeat(6)}`).replace(/\{(\d+)\}/g, (_, d) => this.decorate(String(this.floatFormat(d)), "blueBright")).replace(/\[([^\]]+)\]/g, (_, s) => this.decorate(s, "blueBright"));
+}
+//#endregion
+//#region src/configure.ts
+function configure() {
+	let logLevel;
+	logLevel = this.settings["log-level"];
+	logLevel = this.settings.quiet ? 0 : logLevel;
+	logLevel = this.settings.verbose ? 4 : logLevel;
+	logLevel = this.settings.debug ? 5 : logLevel;
+	this.logLevel = logLevel;
+	this.boringOutput = this.settings["no-color"] || this.boringOutput;
+	this.summary = this.settings.summary || this.summary;
+}
+//#endregion
+//#region src/Timer.ts
+var Timer = class Timer extends events.EventEmitter {
+	static dateFormattingOptions = {
+		day: "numeric",
+		month: "short",
+		year: "numeric",
+		hour: "numeric",
+		minute: "numeric",
+		second: "numeric"
+	};
+	static timeFormat(t) {
+		const s = t[0] * 1e3 + t[1] / 1e6;
+		return `${String(s).slice(0, -3)}ms`;
+	}
+	static dateFormat() {
+		return new Date(Date.now()).toLocaleString();
+	}
+	taskBegin = null;
+	taskEnd = null;
+	sequenceBegin;
+	formattedStartDate;
+	taskTimes;
+	constructor() {
+		super();
+		this.prepare();
+	}
+	prepare() {
+		this.sequenceBegin = process.hrtime();
+		this.formattedStartDate = (/* @__PURE__ */ new Date()).toLocaleDateString("en-CA", Timer.dateFormattingOptions);
+		this.taskTimes = [];
+	}
+	start(task) {
+		this.taskBegin = process.hrtime(this.sequenceBegin);
+		this.emit("begin", {
+			task,
+			begin: this.taskBegin
+		});
+	}
+	stop(task) {
+		this.taskEnd = process.hrtime(this.sequenceBegin);
+		const beginMs = Timer.timeFormat(this.taskBegin);
+		const endMs = Timer.timeFormat(this.taskEnd);
+		const totalMs = `${(parseFloat(endMs) - parseFloat(beginMs)).toFixed(3)}ms`;
+		const taskTime = {
+			taskName: task,
+			beginHrtime: this.taskBegin,
+			endHrtime: this.taskEnd,
+			beginMs,
+			endMs,
+			totalMs
+		};
+		this.taskTimes.push(taskTime);
+		this.emit("end", {
+			task,
+			taskTime
+		});
+	}
+	done({ state }) {
+		const { taskTimes, formattedStartDate } = this;
+		const formattedEndDate = (/* @__PURE__ */ new Date()).toLocaleDateString("en-CA", Timer.dateFormattingOptions);
+		const sequenceEnd = Timer.timeFormat(process.hrtime(this.sequenceBegin));
+		this.emit("done", {
+			state,
+			taskTimes,
+			formattedStartDate,
+			formattedEndDate,
+			sequenceEnd
+		});
+	}
+};
+//#endregion
+//#region src/context.ts
+function ctx(fileName) {
+	return fileName;
+}
+function counter() {
+	this.incrementCounter();
+	return this.decorate(`[${Timer.dateFormat()}]`);
+}
+function getContext() {
+	const { stack } = /* @__PURE__ */ new Error();
+	const context = stack.split("\n")[3].replace(/^\s+at[^/]+(\/[^:]+):.+$/, (_, m) => ctx(m));
+	if (context !== this.context) this.context = context;
+	else return "";
+	return context;
+}
+//#endregion
+//#region src/debug.ts
+function debug() {}
+//#endregion
+//#region src/error.ts
+function error(_args) {
+	const args = Array.isArray(_args) ? _args : [_args];
+	if (this.logLevel < 1) return;
+	const errCode = 1;
+	let message;
+	let stack;
+	let err;
+	let formatted;
+	while (err = args.shift()) {
+		if (err instanceof Error) {
+			message = this.composeMessage([err.message]);
+			stack = err.stack;
+		} else {
+			message = this.composeMessage([err]);
+			stack = (/* @__PURE__ */ new Error()).stack;
+		}
+		let prefix = "";
+		prefix += this.decorate("b-ber", "whiteBright", "bgBlack");
+		prefix += " ";
+		prefix += this.decorate("ERR!", "whiteBright", "bgRed");
+		formatted = util.default.format.apply(util.default, [
+			"%s %s",
+			prefix,
+			message
+		]);
+		this.taskErrors += 1;
+		this.errors.push({
+			stack,
+			message,
+			formatted
+		});
+	}
+	this.errors.forEach((processedErr) => {
+		process.stdout.write(processedErr.formatted);
+		this.newLine();
+		if (this.logLevel > 3) {
+			process.stdout.write(util.default.format.call(util.default, processedErr.stack));
+			this.newLine();
+		}
+	});
+	process.stdout.write(this.decorate(`b-ber exited with code ${errCode}`, "whiteBright", "bgRed"));
+	this.newLine();
+	process.exit(errCode);
+}
+//#endregion
+//#region src/events.ts
+function notify(event, data) {
+	this[event].call(this, data);
+}
+//#endregion
+//#region src/format.ts
+function wrap(arr, space) {
+	return arr.reduce((acc, curr) => {
+		const a = acc.split("\n");
+		const l = a[a.length - 1].length;
+		return acc.concat(l > this.consoleWidth ? `\n${space}${curr}, ` : `${curr}, `);
+	}, "").slice(0, -2);
+}
+function floatFormat(_n) {
+	const n = Number(_n);
+	const pows = {
+		1: {
+			text: "B",
+			pow: 0
+		},
+		2: {
+			text: "B",
+			pow: 0
+		},
+		3: {
+			text: "B",
+			pow: 0
+		},
+		4: {
+			text: "Kb",
+			pow: 3
+		},
+		5: {
+			text: "Kb",
+			pow: 3
+		},
+		6: {
+			text: "Kb",
+			pow: 3
+		},
+		7: {
+			text: "Mb",
+			pow: 6
+		},
+		8: {
+			text: "Mb",
+			pow: 6
+		},
+		9: {
+			text: "Mb",
+			pow: 6
+		},
+		10: {
+			text: "Gb",
+			pow: 9
+		},
+		11: {
+			text: "Gb",
+			pow: 9
+		}
+	};
+	const len = String(n).length;
+	return `${(n / Number(`1e${pows[len].pow}`)).toFixed(2)} ${pows[len].text}`;
+}
+function decorate(_args, ...props) {
+	const args = _args && Array.isArray(_args) ? _args : [_args];
+	let message = util.default.format.call(util.default, ...args);
+	if (this.boringOutput === false) for (let i = props.length - 1; i >= 0; i--) {
+		const chalkFn = chalk.default[props[i]];
+		if (chalkFn) message = chalkFn(message);
+		else message = chalk.default`${message}`;
+	}
+	return message;
+}
+//#endregion
+//#region src/indenter.ts
+function indent() {
+	return this.whitespace.repeat(this.indentLevel);
+}
+function incrementIndent() {
+	this.indentLevel += this.increment;
+}
+function decrementIndent() {
+	this.indentLevel -= this.increment;
+}
+function incrementCounter() {
+	this.taskCounter += 1;
+}
+function decrementCounter() {
+	this.taskCounter -= 1;
+}
+//#endregion
+//#region src/info.ts
+function info(...args) {
+	if (this.logLevel < 4) return;
+	const message = this.decorate(this.composeMessage(args));
+	let prefix = "";
+	if (this.logLevel > 2) {
+		prefix += this.decorate(`[${(/* @__PURE__ */ new Date()).toISOString()}]`, "gray");
+		prefix += " ";
+	}
+	prefix += this.decorate("b-ber", "whiteBright", "bgBlack");
+	prefix += " ";
+	prefix += this.decorate("info", "green");
+	prefix += " ";
+	process.stdout.write(`${prefix}${message}`);
+	this.newLine();
+	if (this.logLevel > 4) {
+		const { stack } = /* @__PURE__ */ new Error();
+		process.stdout.write(util.default.format.call(util.default, stack.replace(/^Error\s+/, "Info ")));
+		this.newLine();
+		this.newLine();
+	}
+}
+//#endregion
+//#region src/inspect.ts
+function inspect(_args) {
+	console.log(util.default.inspect(_args, true, null, true));
+}
+//#endregion
+//#region src/listeners.ts
+function bind() {
+	this.on("begin", ({ task }) => {
+		this.task = task;
+		this.taskWarnings = 0;
+		this.taskErrors = 0;
+		if (this.logLevel < 3) {
+			this.incrementIndent();
+			return;
+		}
+		this.incrementIndent();
+	});
+	this.on("end", ({ task, taskTime }) => {
+		this.decrementIndent();
+		if (this.logLevel < 3) return;
+		const { totalMs } = taskTime;
+		process.stdout.clearLine(0);
+		process.stdout.cursorTo(0);
+		const message = util.default.format.call(util.default, "%s%s %s %s %s done (%s)", this.indent(), this.decorate(`[${(/* @__PURE__ */ new Date()).toISOString()}]`, "gray"), this.decorate("b-ber", "whiteBright", "bgBlack"), this.decorate("info", "green"), this.decorate(task), totalMs);
+		process.stdout.write(message);
+		this.newLine();
+		if (this.logLevel > 4) {
+			const { stack } = /* @__PURE__ */ new Error();
+			process.stdout.write(util.default.format.call(util.default, stack.replace(/^Error\s+/, "Info ")));
+			this.newLine();
+		}
+	});
+	this.on("done", (data) => {
+		if (this.logLevel < 1) return;
+		const message = util.default.format.call(util.default, "%s%s %s %s", this.indent(), this.decorate("b-ber", "whiteBright", "bgBlack"), this.decorate("info", "green"), this.decorate("Build succeeded", "green"));
+		process.stdout.write(message);
+		this.newLine();
+		if (this.summary) this.printSummary(data);
+	});
+}
+//#endregion
+//#region src/notice.ts
+function notice(...args) {
+	const message = this.decorate(this.composeMessage(args));
+	let prefix = "";
+	if (this.logLevel > 2) {
+		prefix += this.decorate(`[${(/* @__PURE__ */ new Date()).toISOString()}]`, "gray");
+		prefix += " ";
+	}
+	prefix += this.decorate("b-ber", "whiteBright", "bgBlack");
+	prefix += " ";
+	prefix += this.decorate("info", "green");
+	prefix += " ";
+	process.stdout.write(`${prefix}${message}`);
+	this.newLine();
+}
+//#endregion
+//#region src/print-version.ts
+function printVersion(version) {
+	const message = util.default.format.call(util.default, "%s%s %s %s", this.indent(), this.decorate("b-ber", "whiteBright", "bgBlack"), this.decorate("version"), this.decorate(version, "blueBright"));
+	process.stdout.write(message);
+	this.newLine();
+}
+//#endregion
+//#region src/printer.ts
+function printNotices(type, task = "b-ber") {
+	const notices = this[type];
+	const leader = type === "warnings" ? "WARN" : "ERR!";
+	const color = type === "warnings" ? "bgYellowBright" : "bgRed";
+	const message = util.default.format.call(util.default, "%s%s %s task %s - %s %s", this.indent(), this.decorate("b-ber", "whiteBright", "bgBlack"), this.decorate(leader, color), this.decorate(task), this.decorate(notices.length), this.decorate(type));
+	if (this.logLevel > 2) process.stdout.write(message);
+}
+function printWarnings(task) {
+	printNotices.call(this, "warnings", task);
+}
+function printErrors(task) {
+	printNotices.call(this, "errors", task);
+}
+//#endregion
+//#region src/register.ts
+function registerSequence(_state, _command, sequence) {
+	if (this.logLevel < 1) return;
+	const message = this.decorate(this.composeMessage([
+		"Preparing to run",
+		sequence.length,
+		`task${sequence.length > 1 ? "s" : ""}`
+	]));
+	let prefix = "";
+	if (this.logLevel > 2) {
+		prefix += this.decorate(`[${(/* @__PURE__ */ new Date()).toISOString()}]`, "gray");
+		prefix += " ";
+	}
+	prefix += this.decorate("b-ber", "whiteBright", "bgBlack");
+	prefix += " ";
+	prefix += this.decorate("info", "green");
+	prefix += " ";
+	process.stdout.write(`${prefix}${message}`);
+	this.newLine();
+}
+//#endregion
+//#region src/reset.ts
+function reset() {
+	this.errors = [];
+	this.warnings = [];
+}
+//#endregion
+//#region src/summary.ts
+const INDENTATION = "  ";
+function isPlainObject(v) {
+	return typeof v === "object" && v !== null && Object.getPrototypeOf(v) === Object.prototype;
+}
+function write(msgs, context) {
+	const len = msgs.length - 1;
+	const esses = " %s".repeat(len);
+	const msgs_ = msgs.map(([text, color]) => color ? context.decorate(text, color) : context.decorate(text));
+	const message = util.default.format.call(util.default, `%s%s %s${esses}`, context.indent(), context.decorate("b-ber", "whiteBright", "bgBlack"), ...msgs_);
+	process.stdout.write(message);
+	context.newLine();
+}
+function printNavigation(data, context, indent = 0) {
+	const indent_ = INDENTATION.repeat(indent);
+	function render(_data, _context) {
+		_data.forEach((item) => {
+			write.call(_context, [[`${indent_}${item.title || "[no title]"}: ${item.name}`]], _context);
+			if (item.nodes && item.nodes.length) render(item.nodes, _context);
+		});
+	}
+	render(data, context);
+}
+function writeMetadata(data, context) {
+	Object.entries(data).forEach(([, v]) => {
+		if (isPlainObject(v)) write.call(context, [[`${v.term}: ${v.value}`]], context);
+	});
+}
+function writeConfig(data, context, indent = 0) {
+	const indent_ = INDENTATION.repeat(indent);
+	Object.entries(data).forEach(([k, v]) => {
+		if (typeof v === "string") write.call(context, [[`${indent_}${k}: ${v}`]], context);
+		if (isPlainObject(v)) {
+			write.call(context, [[`${indent_}${k}`]], context);
+			writeConfig(v, context, indent + 1);
+		}
+	});
+}
+function printSummary({ state, formattedStartDate, formattedEndDate, sequenceEnd }) {
+	this.newLine();
+	write.call(this, [["Stats", "blueBright"]], this);
+	write.call(this, [["Build Start:"], [formattedStartDate]], this);
+	write.call(this, [["Build End:"], [formattedEndDate]], this);
+	write.call(this, [["Elapsed:"], [sequenceEnd]], this);
+	this.newLine();
+	write.call(this, [["Configuration", "blueBright"]], this);
+	writeConfig(state.config, this);
+	this.newLine();
+	write.call(this, [["Metadata", "blueBright"]], this);
+	writeMetadata(state.metadata.json(), this);
+	this.newLine();
+	write.call(this, [["Navigation", "blueBright"]], this);
+	printNavigation(state.toc, this);
+}
+//#endregion
+//#region src/trace.ts
+function trace() {}
+//#endregion
+//#region src/warn.ts
+function warn(...args) {
+	if (this.logLevel < 2) return;
+	let message;
+	message = this.composeMessage(args);
+	message = args[0] instanceof Error ? this.composeMessage([args[0].message]) : this.composeMessage(args);
+	const { stack } = /* @__PURE__ */ new Error();
+	let prefix = "";
+	if (this.logLevel > 2) {
+		prefix += this.decorate(`[${(/* @__PURE__ */ new Date()).toISOString()}]`, "gray");
+		prefix += " ";
+	}
+	prefix += this.decorate("b-ber", "whiteBright", "bgBlack");
+	prefix += " ";
+	prefix += this.decorate("WARN", "black", "bgYellowBright");
+	const formatted = util.default.format.apply(util.default, [
+		"%s %s",
+		prefix,
+		message
+	]);
+	this.taskWarnings += 1;
+	this.warnings.push({
+		stack,
+		message,
+		formatted
+	});
+	process.stdout.write(formatted);
+	this.newLine();
+	if (this.logLevel > 3) {
+		process.stdout.write(util.default.format.call(util.default, stack.replace(/^Error\s+/, "Warning ")));
+		this.newLine();
+		if (this.logLevel > 4) this.newLine();
+	}
+}
+const log = new class Logger extends Timer {
+	static defaults = {
+		logLevel: 2,
+		boringOutput: false,
+		summary: false,
+		command: null,
+		consoleWidth: 70,
+		errors: [],
+		warnings: [],
+		taskWarnings: 0,
+		taskErrors: 0,
+		whitespace: " ",
+		increment: 0,
+		indentLevel: 0,
+		taskCounter: -1,
+		context: null
+	};
+	logLevel;
+	boringOutput;
+	command;
+	consoleWidth;
+	errors;
+	warnings;
+	taskWarnings;
+	taskErrors;
+	whitespace;
+	increment;
+	indentLevel;
+	taskCounter;
+	context;
+	summary;
+	task;
+	settings;
+	printWarnings;
+	printErrors;
+	indent;
+	incrementIndent;
+	decrementIndent;
+	incrementCounter;
+	decrementCounter;
+	bind;
+	notify;
+	warn;
+	info;
+	error;
+	debug;
+	trace;
+	notice;
+	inspect;
+	printSummary;
+	configure;
+	printVersion;
+	registerSequence;
+	wrap;
+	decorate;
+	floatFormat;
+	counter;
+	getContext;
+	composeMessage;
+	reset;
+	constructor() {
+		super();
+		this.logLevel = Logger.defaults.logLevel;
+		this.boringOutput = Logger.defaults.boringOutput;
+		this.command = Logger.defaults.command;
+		this.consoleWidth = Logger.defaults.consoleWidth;
+		this.errors = [];
+		this.warnings = [];
+		this.taskWarnings = Logger.defaults.taskWarnings;
+		this.taskErrors = Logger.defaults.taskErrors;
+		this.whitespace = Logger.defaults.whitespace;
+		this.increment = Logger.defaults.increment;
+		this.indentLevel = Logger.defaults.indentLevel;
+		this.taskCounter = Logger.defaults.taskCounter;
+		this.context = Logger.defaults.context;
+		this.settings = {
+			quiet: false,
+			verbose: false,
+			debug: false,
+			summary: Logger.defaults.summary,
+			"no-color": Logger.defaults.boringOutput,
+			"log-level": Logger.defaults.logLevel
+		};
+		this.printWarnings = printWarnings.bind(this);
+		this.printErrors = printErrors.bind(this);
+		this.indent = indent.bind(this);
+		this.incrementIndent = incrementIndent.bind(this);
+		this.decrementIndent = decrementIndent.bind(this);
+		this.incrementCounter = incrementCounter.bind(this);
+		this.decrementCounter = decrementCounter.bind(this);
+		this.bind = bind.bind(this);
+		this.notify = notify.bind(this);
+		this.warn = warn.bind(this);
+		this.info = info.bind(this);
+		this.error = error.bind(this);
+		this.debug = debug.bind(this);
+		this.trace = trace.bind(this);
+		this.notice = notice.bind(this);
+		this.inspect = inspect.bind(this);
+		this.printSummary = printSummary.bind(this);
+		this.configure = configure.bind(this);
+		this.printVersion = printVersion.bind(this);
+		this.registerSequence = registerSequence.bind(this);
+		this.wrap = wrap.bind(this);
+		this.decorate = decorate.bind(this);
+		this.floatFormat = floatFormat.bind(this);
+		this.counter = counter.bind(this);
+		this.getContext = getContext.bind(this);
+		this.composeMessage = composeMessage.bind(this);
+		this.reset = reset.bind(this);
+		const argv = process.argv.reduce((acc, curr) => {
+			const [k, v] = curr.split("=");
+			acc[k] = v === void 0 ? true : !Number.isNaN(Number(v)) ? Number(v) : v;
+			return acc;
+		}, {});
+		Object.keys(this.settings).forEach((a) => {
+			const opt = `--${a}`;
+			if (Object.hasOwn(argv, opt)) this.settings[a] = argv[opt];
+		});
+		this.configure();
+		this.bind();
+	}
+	newLine() {
+		process.stdout.write("\n");
+	}
+}();
+//#endregion
+module.exports = log;