@contrast/agent 4.16.2 → 4.18.0

package/node_modules/fecha/src/fecha.ts

@@ -0,0 +1,524 @@
+const token = /d{1,4}|M{1,4}|YY(?:YY)?|S{1,3}|Do|ZZ|Z|([HhMsDm])\1?|[aA]|"[^"]*"|'[^']*'/g;
+const twoDigitsOptional = "\\d\\d?";
+const twoDigits = "\\d\\d";
+const threeDigits = "\\d{3}";
+const fourDigits = "\\d{4}";
+const word = "[^\\s]+";
+const literal = /\[([^]*?)\]/gm;
+
+type DateInfo = {
+  year: number;
+  month: number;
+  day: number;
+  hour: number;
+  minute: number;
+  second: number;
+  millisecond: number;
+  isPm: number | null;
+  timezoneOffset: number | null;
+};
+
+export type I18nSettings = {
+  amPm: [string, string];
+  dayNames: Days;
+  dayNamesShort: Days;
+  monthNames: Months;
+  monthNamesShort: Months;
+  DoFn(dayOfMonth: number): string;
+};
+
+export type I18nSettingsOptional = Partial<I18nSettings>;
+
+export type Days = [string, string, string, string, string, string, string];
+export type Months = [
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string
+];
+
+function shorten<T extends string[]>(arr: T, sLen: number): string[] {
+  const newArr: string[] = [];
+  for (let i = 0, len = arr.length; i < len; i++) {
+    newArr.push(arr[i].substr(0, sLen));
+  }
+  return newArr;
+}
+
+const monthUpdate = (
+  arrName: "monthNames" | "monthNamesShort" | "dayNames" | "dayNamesShort"
+) => (v: string, i18n: I18nSettings): number | null => {
+  const lowerCaseArr = i18n[arrName].map(v => v.toLowerCase());
+  const index = lowerCaseArr.indexOf(v.toLowerCase());
+  if (index > -1) {
+    return index;
+  }
+  return null;
+};
+
+export function assign<A>(a: A): A;
+export function assign<A, B>(a: A, b: B): A & B;
+export function assign<A, B, C>(a: A, b: B, c: C): A & B & C;
+export function assign<A, B, C, D>(a: A, b: B, c: C, d: D): A & B & C & D;
+export function assign(origObj: any, ...args: any[]): any {
+  for (const obj of args) {
+    for (const key in obj) {
+      // @ts-ignore ex
+      origObj[key] = obj[key];
+    }
+  }
+  return origObj;
+}
+
+const dayNames: Days = [
+  "Sunday",
+  "Monday",
+  "Tuesday",
+  "Wednesday",
+  "Thursday",
+  "Friday",
+  "Saturday"
+];
+const monthNames: Months = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+
+const monthNamesShort: Months = shorten(monthNames, 3) as Months;
+const dayNamesShort: Days = shorten(dayNames, 3) as Days;
+
+const defaultI18n: I18nSettings = {
+  dayNamesShort,
+  dayNames,
+  monthNamesShort,
+  monthNames,
+  amPm: ["am", "pm"],
+  DoFn(dayOfMonth: number) {
+    return (
+      dayOfMonth +
+      ["th", "st", "nd", "rd"][
+        dayOfMonth % 10 > 3
+          ? 0
+          : ((dayOfMonth - (dayOfMonth % 10) !== 10 ? 1 : 0) * dayOfMonth) % 10
+      ]
+    );
+  }
+};
+let globalI18n = assign({}, defaultI18n);
+const setGlobalDateI18n = (i18n: I18nSettingsOptional): I18nSettings =>
+  (globalI18n = assign(globalI18n, i18n));
+
+const regexEscape = (str: string): string =>
+  str.replace(/[|\\{()[^$+*?.-]/g, "\\$&");
+
+const pad = (val: string | number, len = 2): string => {
+  val = String(val);
+  while (val.length < len) {
+    val = "0" + val;
+  }
+  return val;
+};
+
+const formatFlags: Record<
+  string,
+  (dateObj: Date, i18n: I18nSettings) => string
+> = {
+  D: (dateObj: Date): string => String(dateObj.getDate()),
+  DD: (dateObj: Date): string => pad(dateObj.getDate()),
+  Do: (dateObj: Date, i18n: I18nSettings): string =>
+    i18n.DoFn(dateObj.getDate()),
+  d: (dateObj: Date): string => String(dateObj.getDay()),
+  dd: (dateObj: Date): string => pad(dateObj.getDay()),
+  ddd: (dateObj: Date, i18n: I18nSettings): string =>
+    i18n.dayNamesShort[dateObj.getDay()],
+  dddd: (dateObj: Date, i18n: I18nSettings): string =>
+    i18n.dayNames[dateObj.getDay()],
+  M: (dateObj: Date): string => String(dateObj.getMonth() + 1),
+  MM: (dateObj: Date): string => pad(dateObj.getMonth() + 1),
+  MMM: (dateObj: Date, i18n: I18nSettings): string =>
+    i18n.monthNamesShort[dateObj.getMonth()],
+  MMMM: (dateObj: Date, i18n: I18nSettings): string =>
+    i18n.monthNames[dateObj.getMonth()],
+  YY: (dateObj: Date): string =>
+    pad(String(dateObj.getFullYear()), 4).substr(2),
+  YYYY: (dateObj: Date): string => pad(dateObj.getFullYear(), 4),
+  h: (dateObj: Date): string => String(dateObj.getHours() % 12 || 12),
+  hh: (dateObj: Date): string => pad(dateObj.getHours() % 12 || 12),
+  H: (dateObj: Date): string => String(dateObj.getHours()),
+  HH: (dateObj: Date): string => pad(dateObj.getHours()),
+  m: (dateObj: Date): string => String(dateObj.getMinutes()),
+  mm: (dateObj: Date): string => pad(dateObj.getMinutes()),
+  s: (dateObj: Date): string => String(dateObj.getSeconds()),
+  ss: (dateObj: Date): string => pad(dateObj.getSeconds()),
+  S: (dateObj: Date): string =>
+    String(Math.round(dateObj.getMilliseconds() / 100)),
+  SS: (dateObj: Date): string =>
+    pad(Math.round(dateObj.getMilliseconds() / 10), 2),
+  SSS: (dateObj: Date): string => pad(dateObj.getMilliseconds(), 3),
+  a: (dateObj: Date, i18n: I18nSettings): string =>
+    dateObj.getHours() < 12 ? i18n.amPm[0] : i18n.amPm[1],
+  A: (dateObj: Date, i18n: I18nSettings): string =>
+    dateObj.getHours() < 12
+      ? i18n.amPm[0].toUpperCase()
+      : i18n.amPm[1].toUpperCase(),
+  ZZ(dateObj: Date): string {
+    const offset = dateObj.getTimezoneOffset();
+    return (
+      (offset > 0 ? "-" : "+") +
+      pad(Math.floor(Math.abs(offset) / 60) * 100 + (Math.abs(offset) % 60), 4)
+    );
+  },
+  Z(dateObj: Date): string {
+    const offset = dateObj.getTimezoneOffset();
+    return (
+      (offset > 0 ? "-" : "+") +
+      pad(Math.floor(Math.abs(offset) / 60), 2) +
+      ":" +
+      pad(Math.abs(offset) % 60, 2)
+    );
+  }
+};
+
+type ParseInfo = [
+  keyof DateInfo,
+  string,
+  ((v: string, i18n: I18nSettings) => number | null)?,
+  string?
+];
+const monthParse = (v: string): number => +v - 1;
+const emptyDigits: ParseInfo = [null, twoDigitsOptional];
+const emptyWord: ParseInfo = [null, word];
+const amPm: ParseInfo = [
+  "isPm",
+  word,
+  (v: string, i18n: I18nSettings): number | null => {
+    const val = v.toLowerCase();
+    if (val === i18n.amPm[0]) {
+      return 0;
+    } else if (val === i18n.amPm[1]) {
+      return 1;
+    }
+    return null;
+  }
+];
+const timezoneOffset: ParseInfo = [
+  "timezoneOffset",
+  "[^\\s]*?[\\+\\-]\\d\\d:?\\d\\d|[^\\s]*?Z?",
+  (v: string): number | null => {
+    const parts = (v + "").match(/([+-]|\d\d)/gi);
+
+    if (parts) {
+      const minutes = +parts[1] * 60 + parseInt(parts[2], 10);
+      return parts[0] === "+" ? minutes : -minutes;
+    }
+
+    return 0;
+  }
+];
+const parseFlags: Record<string, ParseInfo> = {
+  D: ["day", twoDigitsOptional],
+  DD: ["day", twoDigits],
+  Do: ["day", twoDigitsOptional + word, (v: string): number => parseInt(v, 10)],
+  M: ["month", twoDigitsOptional, monthParse],
+  MM: ["month", twoDigits, monthParse],
+  YY: [
+    "year",
+    twoDigits,
+    (v: string): number => {
+      const now = new Date();
+      const cent = +("" + now.getFullYear()).substr(0, 2);
+      return +("" + (+v > 68 ? cent - 1 : cent) + v);
+    }
+  ],
+  h: ["hour", twoDigitsOptional, undefined, "isPm"],
+  hh: ["hour", twoDigits, undefined, "isPm"],
+  H: ["hour", twoDigitsOptional],
+  HH: ["hour", twoDigits],
+  m: ["minute", twoDigitsOptional],
+  mm: ["minute", twoDigits],
+  s: ["second", twoDigitsOptional],
+  ss: ["second", twoDigits],
+  YYYY: ["year", fourDigits],
+  S: ["millisecond", "\\d", (v: string): number => +v * 100],
+  SS: ["millisecond", twoDigits, (v: string): number => +v * 10],
+  SSS: ["millisecond", threeDigits],
+  d: emptyDigits,
+  dd: emptyDigits,
+  ddd: emptyWord,
+  dddd: emptyWord,
+  MMM: ["month", word, monthUpdate("monthNamesShort")],
+  MMMM: ["month", word, monthUpdate("monthNames")],
+  a: amPm,
+  A: amPm,
+  ZZ: timezoneOffset,
+  Z: timezoneOffset
+};
+
+// Some common format strings
+const globalMasks: { [key: string]: string } = {
+  default: "ddd MMM DD YYYY HH:mm:ss",
+  shortDate: "M/D/YY",
+  mediumDate: "MMM D, YYYY",
+  longDate: "MMMM D, YYYY",
+  fullDate: "dddd, MMMM D, YYYY",
+  isoDate: "YYYY-MM-DD",
+  isoDateTime: "YYYY-MM-DDTHH:mm:ssZ",
+  shortTime: "HH:mm",
+  mediumTime: "HH:mm:ss",
+  longTime: "HH:mm:ss.SSS"
+};
+const setGlobalDateMasks = (masks: {
+  [key: string]: string;
+}): { [key: string]: string } => assign(globalMasks, masks);
+
+/***
+ * Format a date
+ * @method format
+ * @param {Date|number} dateObj
+ * @param {string} mask Format of the date, i.e. 'mm-dd-yy' or 'shortDate'
+ * @returns {string} Formatted date string
+ */
+const format = (
+  dateObj: Date,
+  mask: string = globalMasks["default"],
+  i18n: I18nSettingsOptional = {}
+): string => {
+  if (typeof dateObj === "number") {
+    dateObj = new Date(dateObj);
+  }
+
+  if (
+    Object.prototype.toString.call(dateObj) !== "[object Date]" ||
+    isNaN(dateObj.getTime())
+  ) {
+    throw new Error("Invalid Date pass to format");
+  }
+
+  mask = globalMasks[mask] || mask;
+
+  const literals: string[] = [];
+
+  // Make literals inactive by replacing them with @@@
+  mask = mask.replace(literal, function($0, $1) {
+    literals.push($1);
+    return "@@@";
+  });
+
+  const combinedI18nSettings: I18nSettings = assign(
+    assign({}, globalI18n),
+    i18n
+  );
+  // Apply formatting rules
+  mask = mask.replace(token, $0 =>
+    formatFlags[$0](dateObj, combinedI18nSettings)
+  );
+  // Inline literal values back into the formatted value
+  return mask.replace(/@@@/g, () => literals.shift());
+};
+
+/**
+ * Parse a date string into a Javascript Date object /
+ * @method parse
+ * @param {string} dateStr Date string
+ * @param {string} format Date parse format
+ * @param {i18n} I18nSettingsOptional Full or subset of I18N settings
+ * @returns {Date|null} Returns Date object. Returns null what date string is invalid or doesn't match format
+ */
+function parse(
+  dateStr: string,
+  format: string,
+  i18n: I18nSettingsOptional = {}
+): Date | null {
+  if (typeof format !== "string") {
+    throw new Error("Invalid format in fecha parse");
+  }
+
+  // Check to see if the format is actually a mask
+  format = globalMasks[format] || format;
+
+  // Avoid regular expression denial of service, fail early for really long strings
+  // https://www.owasp.org/index.php/Regular_expression_Denial_of_Service_-_ReDoS
+  if (dateStr.length > 1000) {
+    return null;
+  }
+
+  // Default to the beginning of the year.
+  const today = new Date();
+  const dateInfo: DateInfo = {
+    year: today.getFullYear(),
+    month: 0,
+    day: 1,
+    hour: 0,
+    minute: 0,
+    second: 0,
+    millisecond: 0,
+    isPm: null,
+    timezoneOffset: null
+  };
+  const parseInfo: ParseInfo[] = [];
+  const literals: string[] = [];
+
+  // Replace all the literals with @@@. Hopefully a string that won't exist in the format
+  let newFormat = format.replace(literal, ($0, $1) => {
+    literals.push(regexEscape($1));
+    return "@@@";
+  });
+  const specifiedFields: { [field: string]: boolean } = {};
+  const requiredFields: { [field: string]: boolean } = {};
+
+  // Change every token that we find into the correct regex
+  newFormat = regexEscape(newFormat).replace(token, $0 => {
+    const info = parseFlags[$0];
+    const [field, regex, , requiredField] = info;
+
+    // Check if the person has specified the same field twice. This will lead to confusing results.
+    if (specifiedFields[field]) {
+      throw new Error(`Invalid format. ${field} specified twice in format`);
+    }
+
+    specifiedFields[field] = true;
+
+    // Check if there are any required fields. For instance, 12 hour time requires AM/PM specified
+    if (requiredField) {
+      requiredFields[requiredField] = true;
+    }
+
+    parseInfo.push(info);
+    return "(" + regex + ")";
+  });
+
+  // Check all the required fields are present
+  Object.keys(requiredFields).forEach(field => {
+    if (!specifiedFields[field]) {
+      throw new Error(
+        `Invalid format. ${field} is required in specified format`
+      );
+    }
+  });
+
+  // Add back all the literals after
+  newFormat = newFormat.replace(/@@@/g, () => literals.shift());
+
+  // Check if the date string matches the format. If it doesn't return null
+  const matches = dateStr.match(new RegExp(newFormat, "i"));
+  if (!matches) {
+    return null;
+  }
+
+  const combinedI18nSettings: I18nSettings = assign(
+    assign({}, globalI18n),
+    i18n
+  );
+
+  // For each match, call the parser function for that date part
+  for (let i = 1; i < matches.length; i++) {
+    const [field, , parser] = parseInfo[i - 1];
+    const value = parser
+      ? parser(matches[i], combinedI18nSettings)
+      : +matches[i];
+
+    // If the parser can't make sense of the value, return null
+    if (value == null) {
+      return null;
+    }
+
+    dateInfo[field] = value;
+  }
+
+  if (dateInfo.isPm === 1 && dateInfo.hour != null && +dateInfo.hour !== 12) {
+    dateInfo.hour = +dateInfo.hour + 12;
+  } else if (dateInfo.isPm === 0 && +dateInfo.hour === 12) {
+    dateInfo.hour = 0;
+  }
+
+  let dateTZ: Date;
+  if (dateInfo.timezoneOffset == null) {
+    dateTZ = new Date(
+      dateInfo.year,
+      dateInfo.month,
+      dateInfo.day,
+      dateInfo.hour,
+      dateInfo.minute,
+      dateInfo.second,
+      dateInfo.millisecond
+    );
+    const validateFields: [
+      "month" | "day" | "hour" | "minute" | "second",
+      "getMonth" | "getDate" | "getHours" | "getMinutes" | "getSeconds"
+    ][] = [
+      ["month", "getMonth"],
+      ["day", "getDate"],
+      ["hour", "getHours"],
+      ["minute", "getMinutes"],
+      ["second", "getSeconds"]
+    ];
+    for (let i = 0, len = validateFields.length; i < len; i++) {
+      // Check to make sure the date field is within the allowed range. Javascript dates allows values
+      // outside the allowed range. If the values don't match the value was invalid
+      if (
+        specifiedFields[validateFields[i][0]] &&
+        dateInfo[validateFields[i][0]] !== dateTZ[validateFields[i][1]]()
+      ) {
+        return null;
+      }
+    }
+  } else {
+    dateTZ = new Date(
+      Date.UTC(
+        dateInfo.year,
+        dateInfo.month,
+        dateInfo.day,
+        dateInfo.hour,
+        dateInfo.minute - dateInfo.timezoneOffset,
+        dateInfo.second,
+        dateInfo.millisecond
+      )
+    );
+
+    // We can't validate dates in another timezone unfortunately. Do a basic check instead
+    if (
+      dateInfo.month > 11 ||
+      dateInfo.month < 0 ||
+      dateInfo.day > 31 ||
+      dateInfo.day < 1 ||
+      dateInfo.hour > 23 ||
+      dateInfo.hour < 0 ||
+      dateInfo.minute > 59 ||
+      dateInfo.minute < 0 ||
+      dateInfo.second > 59 ||
+      dateInfo.second < 0
+    ) {
+      return null;
+    }
+  }
+
+  // Don't allow invalid dates
+
+  return dateTZ;
+}
+export default {
+  format,
+  parse,
+  defaultI18n,
+  setGlobalDateI18n,
+  setGlobalDateMasks
+};
+export { format, parse, defaultI18n, setGlobalDateI18n, setGlobalDateMasks };

package/node_modules/logform/.eslintrc

@@ -1,5 +1,5 @@
 {
-  "extends": "populist",
+  "extends": "@dabh/eslint-config-populist",
   "rules": {
     "no-undefined": 0,
     "strict": 0

package/node_modules/logform/CHANGELOG.md

@@ -1,5 +1,29 @@
 # CHANGELOG
 
+### 2.4.0
+**2022/02/12**
+
+- Updated all dependencies
+- [#135] Use CLI levels (not NPM levels) in `CliFormat` (this was likely a typo originally)
+- [#134] Expose `safe-stable-stringify` 2.x options as parameters in `JsonOptions`
+
+### 2.3.2
+**2022/01/09**
+
+This update, which also used up version number 2.3.1, pinned the version of the `colors` dependency
+due to vandalism by a developer of that package, as noted [here](https://www.bleepingcomputer.com/news/security/dev-corrupts-npm-libs-colors-and-faker-breaking-thousands-of-apps/).
+[As discussed in the `winston` package](https://github.com/winstonjs/winston/issues/2011), all users should update to this (or a later version, should one exist) ASAP.  
+
+### 2.3.0
+**2021/09/21**
+
+- Update dependencies
+- Removing some superfluous semicolons & commas lint
+- Avoid dynamic requires [#117]
+- Replace JSON stringify library "fast-safe-stringify" by "safe-stable-stringify" [#98]
+- More correctly format errors even if the “message” property is enumerable [#101] 
+- Fix errors and ms export for browsers [#106] 
+
 ### 2.2.0
 **2020/06/21**
 

package/node_modules/logform/README.md

@@ -43,7 +43,7 @@ message. The object itself is mutable. Every `info` must have at least the
 
 ``` js
 const info = {
-  level: 'info',                 // Level of the logging message  
+  level: 'info',                 // Level of the logging message
   message: 'Hey! Log something?' // Descriptive message being logged.
 }
 ```
@@ -57,10 +57,10 @@ const { level, message, ...meta } = info;
 Several of the formats in `logform` itself add additional properties:
 
 | Property    | Format added by | Description |
-| ----------- | --------------- | ----------- | 
+| ----------- | --------------- | ----------- |
 | `splat`     | `splat()`       | String interpolation splat for `%d %s`-style messages. |
 | `timestamp` | `timestamp()`   |  timestamp the message was received. |
-| `label`     | `label()`       | Custom label associated with each message. | 
+| `label`     | `label()`       | Custom label associated with each message. |
 | `ms`        | `ms()`          | Number of milliseconds since the previous log message. |
 
 As a consumer you may add whatever properties you wish – _internal state is
@@ -105,7 +105,7 @@ They are expected to return one of two things:
 - **An `info` Object** representing the modified `info` argument. Object references need not be preserved if immutability is preferred. All current built-in formats consider `info` mutable, but [immutablejs] is being considered for future releases.
 - **A falsey value** indicating that the `info` argument should be ignored by the caller. (See: [Filtering `info` Objects](#filtering-info-objects)) below.
 
-`logform.format`  is designed to be as simple as possible. To define a new format simple pass it a `transform(info, opts)` function to get a new `Format`. 
+`logform.format`  is designed to be as simple as possible. To define a new format simple pass it a `transform(info, opts)` function to get a new `Format`.
 
 The named `Format` returned can be used to create as many copies of the given `Format` as desired:
 
@@ -114,7 +114,7 @@ const { format } = require('logform');
 
 const volume = format((info, opts) => {
   if (opts.yell) {
-    info.message = info.message.toUpperCase(); 
+    info.message = info.message.toUpperCase();
   } else if (opts.whisper) {
     info.message = info.message.toLowerCase();
   }
@@ -135,9 +135,9 @@ console.dir(scream.transform({
 
 // `volume` can be used multiple times to create different formats.
 const whisper = volume({ whisper: true });
-console.dir(whisper.transform({ 
-  level: 'info', 
-  message: `WHY ARE THEY MAKING US YELL SO MUCH!` 
+console.dir(whisper.transform({
+  level: 'info',
+  message: `WHY ARE THEY MAKING US YELL SO MUCH!`
 }), whisper.options);
 // {
 //   level: 'info'
@@ -369,12 +369,11 @@ console.log(info);
 
 ### JSON
 
-The `json` format uses `fast-safe-stringify` to finalize the message.
+The `json` format uses `safe-stable-stringify` to finalize the message.
 It accepts the following options:
 
 * **replacer**: A function that influences how the `info` is stringified.
 * **space**: The number of white space used to format the json.
-* **stable**: If set to `true` the objects' attributes will always be stringified in alphabetical order.
 
 ```js
 const { format } = require('logform');
@@ -384,7 +383,6 @@ const jsonFormat = format.json();
 const info = jsonFormat.transform({
   level: 'info',
   message: 'my message',
-  stable: true,
 });
 console.log(info);
 // { level: 'info',
@@ -494,7 +492,7 @@ This was previously exposed as `{ padLevels: true }` to transports in `winston <
 The `prettyPrint` format finalizes the message using `util.inspect`.
 It accepts the following options:
 
-* **depth**: A `number` that specifies the maximum depth of the `info` object being stringified by `util.inspect`. Defaults to `2`.  
+* **depth**: A `number` that specifies the maximum depth of the `info` object being stringified by `util.inspect`. Defaults to `2`.
 * **colorize**: Colorizes the message if set to `true`. Defaults to `false`.
 
 The `prettyPrint` format should not be used in production because it may impact performance negatively and block the event loop.
@@ -607,11 +605,11 @@ This was previously exposed implicitly in `winston < 3.0.0`.
 
 ### Timestamp
 
-The `timestamp` format adds a timestamp to the info. 
+The `timestamp` format adds a timestamp to the info.
 It accepts the following options:
 
 * **format**: Either the format as a string accepted by the [fecha](https://github.com/taylorhakes/fecha) module or a function that returns a formatted date. If no format is provided `new Date().toISOString()` will be used.
-* **alias**: The name of an alias for the timestamp property, that will be added to the `info` object. 
+* **alias**: The name of an alias for the timestamp property, that will be added to the `info` object.
 
 ```js
 const { format } = require('logform');
@@ -637,9 +635,9 @@ It was previously available in `winston < 3.0.0` as `{ timestamp: true }` and `{
 The `uncolorize` format strips colors from `info` objects.
 It accepts the following options:
 
-* **level**: Disables the uncolorize format for `info.level` if set to `false`. 
-* **message**: Disables the uncolorize format for `info.message` if set to `false`. 
-* **raw**: Disables the uncolorize format for `info[MESSAGE]` if set to `false`. 
+* **level**: Disables the uncolorize format for `info.level` if set to `false`.
+* **message**: Disables the uncolorize format for `info.message` if set to `false`.
+* **raw**: Disables the uncolorize format for `info[MESSAGE]` if set to `false`.
 
 This was previously exposed as `{ stripColors: true }` to transports in `winston < 3.0.0`.
 

package/node_modules/logform/browser.js

@@ -21,12 +21,14 @@ exports.levels = require('././levels');
 //
 Object.defineProperty(format, 'align',       { value: require('./align') });
 Object.defineProperty(format, 'cli',         { value: require('./cli') });
-Object.defineProperty(format, 'combine',     { value: require('./combine') });
 Object.defineProperty(format, 'colorize',    { value: require('./colorize') });
+Object.defineProperty(format, 'combine',     { value: require('./combine') });
+Object.defineProperty(format, 'errors',      { value: require('./errors') });
 Object.defineProperty(format, 'json',        { value: require('./json') });
 Object.defineProperty(format, 'label',       { value: require('./label') });
 Object.defineProperty(format, 'logstash',    { value: require('./logstash') });
 Object.defineProperty(format, 'metadata',    { value: require('./metadata') });
+Object.defineProperty(format, 'ms',          { value: require('./ms') });
 Object.defineProperty(format, 'padLevels',   { value: require('./pad-levels') });
 Object.defineProperty(format, 'prettyPrint', { value: require('./pretty-print') });
 Object.defineProperty(format, 'printf',      { value: require('./printf') });

package/node_modules/logform/cli.js

@@ -12,7 +12,7 @@ const { configs, MESSAGE } = require('triple-beam');
 class CliFormat {
   constructor(opts = {}) {
     if (!opts.levels) {
-      opts.levels = configs.npm.levels;
+      opts.levels = configs.cli.levels;
     }
 
     this.colorizer = new Colorizer(opts);