js-build-tools 2.4.0 → 3.0.1

package/vendor/gulp-plugin-extras/index.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.gulpPlugin = gulpPlugin;
+require("core-js/modules/web.dom-collections.iterator.js");
+var _index = _interopRequireDefault(require("../easy-transform-stream/index.js"));
+var _pluginError = _interopRequireDefault(require("./plugin-error.js"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function gulpPlugin(name, onFile) {
+  let {
+    onFinish,
+    supportsDirectories
+  } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  return (0, _index.default)({
+    objectMode: true
+  }, async file => {
+    if (file.isNull() && !(supportsDirectories && file.isDirectory())) {
+      return file;
+    }
+    if (file.isStream()) {
+      throw new _pluginError.default(name, 'Streaming not supported');
+    }
+    try {
+      return await onFile(file);
+    } catch (error) {
+      throw new _pluginError.default(name, error, {
+        fileName: file.path,
+        showStack: true
+      });
+    }
+  }, onFinish && async function* (stream) {
+    try {
+      yield* onFinish(stream);
+    } catch (error) {
+      throw new _pluginError.default(name, error, {
+        showStack: true
+      });
+    }
+  });
+}

package/vendor/gulp-plugin-extras/node_modules/chalk/source/index.js

@@ -0,0 +1,265 @@
+"use strict";
+
+require("core-js/modules/esnext.weak-map.delete-all.js");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Chalk = void 0;
+Object.defineProperty(exports, "backgroundColorNames", {
+  enumerable: true,
+  get: function () {
+    return _index.backgroundColorNames;
+  }
+});
+Object.defineProperty(exports, "backgroundColors", {
+  enumerable: true,
+  get: function () {
+    return _index.backgroundColorNames;
+  }
+});
+exports.chalkStderr = void 0;
+Object.defineProperty(exports, "colorNames", {
+  enumerable: true,
+  get: function () {
+    return _index.colorNames;
+  }
+});
+Object.defineProperty(exports, "colors", {
+  enumerable: true,
+  get: function () {
+    return _index.colorNames;
+  }
+});
+exports.default = void 0;
+Object.defineProperty(exports, "foregroundColorNames", {
+  enumerable: true,
+  get: function () {
+    return _index.foregroundColorNames;
+  }
+});
+Object.defineProperty(exports, "foregroundColors", {
+  enumerable: true,
+  get: function () {
+    return _index.foregroundColorNames;
+  }
+});
+Object.defineProperty(exports, "modifierNames", {
+  enumerable: true,
+  get: function () {
+    return _index.modifierNames;
+  }
+});
+Object.defineProperty(exports, "modifiers", {
+  enumerable: true,
+  get: function () {
+    return _index.modifierNames;
+  }
+});
+exports.supportsColorStderr = exports.supportsColor = void 0;
+require("core-js/modules/web.dom-collections.iterator.js");
+var _index = _interopRequireWildcard(require("./vendor/ansi-styles/index.js"));
+var _index2 = _interopRequireDefault(require("./vendor/supports-color/index.js"));
+var _utilities = require("./utilities.js");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+const {
+  stdout: stdoutColor,
+  stderr: stderrColor
+} = _index2.default;
+exports.supportsColorStderr = stderrColor;
+exports.supportsColor = stdoutColor;
+const GENERATOR = Symbol('GENERATOR');
+const STYLER = Symbol('STYLER');
+const IS_EMPTY = Symbol('IS_EMPTY');
+
+// `supportsColor.level` → `ansiStyles.color[name]` mapping
+const levelMapping = ['ansi', 'ansi', 'ansi256', 'ansi16m'];
+const styles = Object.create(null);
+const applyOptions = function (object) {
+  let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
+    throw new Error('The `level` option should be an integer from 0 to 3');
+  }
+
+  // Detect level if not set manually
+  const colorLevel = stdoutColor ? stdoutColor.level : 0;
+  object.level = options.level === undefined ? colorLevel : options.level;
+};
+class Chalk {
+  constructor(options) {
+    // eslint-disable-next-line no-constructor-return
+    return chalkFactory(options);
+  }
+}
+exports.Chalk = Chalk;
+const chalkFactory = options => {
+  const chalk = function () {
+    for (var _len = arguments.length, strings = new Array(_len), _key = 0; _key < _len; _key++) {
+      strings[_key] = arguments[_key];
+    }
+    return strings.join(' ');
+  };
+  applyOptions(chalk, options);
+  Object.setPrototypeOf(chalk, createChalk.prototype);
+  return chalk;
+};
+function createChalk(options) {
+  return chalkFactory(options);
+}
+Object.setPrototypeOf(createChalk.prototype, Function.prototype);
+for (const [styleName, style] of Object.entries(_index.default)) {
+  styles[styleName] = {
+    get() {
+      const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
+      Object.defineProperty(this, styleName, {
+        value: builder
+      });
+      return builder;
+    }
+  };
+}
+styles.visible = {
+  get() {
+    const builder = createBuilder(this, this[STYLER], true);
+    Object.defineProperty(this, 'visible', {
+      value: builder
+    });
+    return builder;
+  }
+};
+const getModelAnsi = function (model, level, type) {
+  for (var _len2 = arguments.length, arguments_ = new Array(_len2 > 3 ? _len2 - 3 : 0), _key2 = 3; _key2 < _len2; _key2++) {
+    arguments_[_key2 - 3] = arguments[_key2];
+  }
+  if (model === 'rgb') {
+    if (level === 'ansi16m') {
+      return _index.default[type].ansi16m(...arguments_);
+    }
+    if (level === 'ansi256') {
+      return _index.default[type].ansi256(_index.default.rgbToAnsi256(...arguments_));
+    }
+    return _index.default[type].ansi(_index.default.rgbToAnsi(...arguments_));
+  }
+  if (model === 'hex') {
+    return getModelAnsi('rgb', level, type, ..._index.default.hexToRgb(...arguments_));
+  }
+  return _index.default[type][model](...arguments_);
+};
+const usedModels = ['rgb', 'hex', 'ansi256'];
+for (const model of usedModels) {
+  styles[model] = {
+    get() {
+      const {
+        level
+      } = this;
+      return function () {
+        for (var _len3 = arguments.length, arguments_ = new Array(_len3), _key3 = 0; _key3 < _len3; _key3++) {
+          arguments_[_key3] = arguments[_key3];
+        }
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], 'color', ...arguments_), _index.default.color.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+  const bgModel = 'bg' + model[0].toUpperCase() + model.slice(1);
+  styles[bgModel] = {
+    get() {
+      const {
+        level
+      } = this;
+      return function () {
+        for (var _len4 = arguments.length, arguments_ = new Array(_len4), _key4 = 0; _key4 < _len4; _key4++) {
+          arguments_[_key4] = arguments[_key4];
+        }
+        const styler = createStyler(getModelAnsi(model, levelMapping[level], 'bgColor', ...arguments_), _index.default.bgColor.close, this[STYLER]);
+        return createBuilder(this, styler, this[IS_EMPTY]);
+      };
+    }
+  };
+}
+const proto = Object.defineProperties(() => {}, {
+  ...styles,
+  level: {
+    enumerable: true,
+    get() {
+      return this[GENERATOR].level;
+    },
+    set(level) {
+      this[GENERATOR].level = level;
+    }
+  }
+});
+const createStyler = (open, close, parent) => {
+  let openAll;
+  let closeAll;
+  if (parent === undefined) {
+    openAll = open;
+    closeAll = close;
+  } else {
+    openAll = parent.openAll + open;
+    closeAll = close + parent.closeAll;
+  }
+  return {
+    open,
+    close,
+    openAll,
+    closeAll,
+    parent
+  };
+};
+const createBuilder = (self, _styler, _isEmpty) => {
+  // Single argument is hot path, implicit coercion is faster than anything
+  // eslint-disable-next-line no-implicit-coercion
+  const builder = function () {
+    for (var _len5 = arguments.length, arguments_ = new Array(_len5), _key5 = 0; _key5 < _len5; _key5++) {
+      arguments_[_key5] = arguments[_key5];
+    }
+    return applyStyle(builder, arguments_.length === 1 ? '' + arguments_[0] : arguments_.join(' '));
+  };
+
+  // We alter the prototype because we must return a function, but there is
+  // no way to create a function with a different prototype
+  Object.setPrototypeOf(builder, proto);
+  builder[GENERATOR] = self;
+  builder[STYLER] = _styler;
+  builder[IS_EMPTY] = _isEmpty;
+  return builder;
+};
+const applyStyle = (self, string) => {
+  if (self.level <= 0 || !string) {
+    return self[IS_EMPTY] ? '' : string;
+  }
+  let styler = self[STYLER];
+  if (styler === undefined) {
+    return string;
+  }
+  const {
+    openAll,
+    closeAll
+  } = styler;
+  if (string.includes('\u001B')) {
+    while (styler !== undefined) {
+      // Replace any instances already present with a re-opening code
+      // otherwise only the part of the string until said closing code
+      // will be colored, and the rest will simply be 'plain'.
+      string = (0, _utilities.stringReplaceAll)(string, styler.close, styler.open);
+      styler = styler.parent;
+    }
+  }
+
+  // We can move both next actions out of loop, because remaining actions in loop won't have
+  // any/visible effect on parts we add here. Close the styling before a linebreak and reopen
+  // after next line to fix a bleed issue on macOS: https://github.com/chalk/chalk/pull/92
+  const lfIndex = string.indexOf('\n');
+  if (lfIndex !== -1) {
+    string = (0, _utilities.stringEncaseCRLFWithFirstIndex)(string, closeAll, openAll, lfIndex);
+  }
+  return openAll + string + closeAll;
+};
+Object.defineProperties(createChalk.prototype, styles);
+const chalk = createChalk();
+const chalkStderr = exports.chalkStderr = createChalk({
+  level: stderrColor ? stderrColor.level : 0
+});
+var _default = exports.default = chalk;

package/vendor/gulp-plugin-extras/node_modules/chalk/source/utilities.js

@@ -0,0 +1,36 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.stringEncaseCRLFWithFirstIndex = stringEncaseCRLFWithFirstIndex;
+exports.stringReplaceAll = stringReplaceAll;
+// TODO: When targeting Node.js 16, use `String.prototype.replaceAll`.
+function stringReplaceAll(string, substring, replacer) {
+  let index = string.indexOf(substring);
+  if (index === -1) {
+    return string;
+  }
+  const substringLength = substring.length;
+  let endIndex = 0;
+  let returnValue = '';
+  do {
+    returnValue += string.slice(endIndex, index) + substring + replacer;
+    endIndex = index + substringLength;
+    index = string.indexOf(substring, endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}
+function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
+  let endIndex = 0;
+  let returnValue = '';
+  do {
+    const gotCR = string[index - 1] === '\r';
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? '\r\n' : '\n') + postfix;
+    endIndex = index + 1;
+    index = string.indexOf('\n', endIndex);
+  } while (index !== -1);
+  returnValue += string.slice(endIndex);
+  return returnValue;
+}

package/vendor/gulp-plugin-extras/node_modules/chalk/source/vendor/ansi-styles/index.js

@@ -0,0 +1,217 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.modifierNames = exports.foregroundColorNames = exports.default = exports.colorNames = exports.backgroundColorNames = void 0;
+require("core-js/modules/esnext.async-iterator.map.js");
+require("core-js/modules/esnext.iterator.map.js");
+require("core-js/modules/esnext.map.delete-all.js");
+require("core-js/modules/esnext.map.every.js");
+require("core-js/modules/esnext.map.filter.js");
+require("core-js/modules/esnext.map.find.js");
+require("core-js/modules/esnext.map.find-key.js");
+require("core-js/modules/esnext.map.includes.js");
+require("core-js/modules/esnext.map.key-of.js");
+require("core-js/modules/esnext.map.map-keys.js");
+require("core-js/modules/esnext.map.map-values.js");
+require("core-js/modules/esnext.map.merge.js");
+require("core-js/modules/esnext.map.reduce.js");
+require("core-js/modules/esnext.map.some.js");
+require("core-js/modules/esnext.map.update.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+const ANSI_BACKGROUND_OFFSET = 10;
+const wrapAnsi16 = function () {
+  let offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  return code => "\x1B[".concat(code + offset, "m");
+};
+const wrapAnsi256 = function () {
+  let offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  return code => "\x1B[".concat(38 + offset, ";5;").concat(code, "m");
+};
+const wrapAnsi16m = function () {
+  let offset = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;
+  return (red, green, blue) => "\x1B[".concat(38 + offset, ";2;").concat(red, ";").concat(green, ";").concat(blue, "m");
+};
+const styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+const modifierNames = exports.modifierNames = Object.keys(styles.modifier);
+const foregroundColorNames = exports.foregroundColorNames = Object.keys(styles.color);
+const backgroundColorNames = exports.backgroundColorNames = Object.keys(styles.bgColor);
+const colorNames = exports.colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: "\x1B[".concat(style[0], "m"),
+        close: "\x1B[".concat(style[1], "m")
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, 'codes', {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = '\u001B[39m';
+  styles.bgColor.close = '\u001B[49m';
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+
+  // From https://github.com/Qix-/color-convert/blob/3f0e0d4e92e235796ccb17f6e85c72094a651f49/conversions.js
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        // We use the extended greyscale palette here, with the exception of
+        // black and white. normal palette only has 4 greyscale shades.
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map(character => character + character).join('');
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [/* eslint-disable no-bitwise */
+        integer >> 16 & 0xFF, integer >> 8 & 0xFF, integer & 0xFF
+        /* eslint-enable no-bitwise */];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: hex => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+
+        // eslint-disable-next-line no-bitwise
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: hex => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+const ansiStyles = assembleStyles();
+var _default = exports.default = ansiStyles;