js-build-tools 2.3.1 → 3.0.0

package/vendor/imagemin-mozjpeg/index.js

@@ -0,0 +1,104 @@
+async function exportImageminMozjpeg () {
+  "use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _nodeBuffer = require("node:buffer");
+var _index = require("./node_modules/execa/index.js");
+var _index2 = _interopRequireDefault(require("../is-jpg/index.js"));
+var _index3 = _interopRequireDefault(require("../mozjpeg/index.js"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const imageminMozjpeg = options => async buffer => {
+  options = {
+    trellis: true,
+    trellisDC: true,
+    overshoot: true,
+    ...options
+  };
+  if (!_nodeBuffer.Buffer.isBuffer(buffer)) {
+    return Promise.reject(new TypeError('Expected a buffer'));
+  }
+  if (!(0, _index2.default)(buffer)) {
+    return Promise.resolve(buffer);
+  }
+
+  // TODO: Remove these sometime far in the future
+  if (options.fastcrush) {
+    return Promise.reject(new Error('Option `fastcrush` was renamed to `fastCrush`'));
+  }
+  if (options.maxmemory) {
+    return Promise.reject(new Error('Option `maxmemory` was renamed to `maxMemory`'));
+  }
+  if (options.notrellis) {
+    return Promise.reject(new Error('Option `notrellis` was renamed to `trellis` and inverted'));
+  }
+  if (options.noovershoot) {
+    return Promise.reject(new Error('Option `noovershoot` was renamed to `overshoot` and inverted'));
+  }
+  const args = [];
+  if (typeof options.quality !== 'undefined') {
+    args.push('-quality', options.quality);
+  }
+  if (options.progressive === false) {
+    args.push('-baseline');
+  }
+  if (options.targa) {
+    args.push('-targa');
+  }
+  if (options.revert) {
+    args.push('-revert');
+  }
+  if (options.fastCrush) {
+    args.push('-fastcrush');
+  }
+  if (typeof options.dcScanOpt !== 'undefined') {
+    args.push('-dc-scan-opt', options.dcScanOpt);
+  }
+  if (!options.trellis) {
+    args.push('-notrellis');
+  }
+  if (!options.trellisDC) {
+    args.push('-notrellis-dc');
+  }
+  if (options.tune) {
+    args.push("-tune-".concat(options.tune));
+  }
+  if (!options.overshoot) {
+    args.push('-noovershoot');
+  }
+  if (options.arithmetic) {
+    args.push('-arithmetic');
+  }
+  if (options.dct) {
+    args.push('-dct', options.dct);
+  }
+  if (options.quantBaseline) {
+    args.push('-quant-baseline', options.quantBaseline);
+  }
+  if (typeof options.quantTable !== 'undefined') {
+    args.push('-quant-table', options.quantTable);
+  }
+  if (options.smooth) {
+    args.push('-smooth', options.smooth);
+  }
+  if (options.maxMemory) {
+    args.push('-maxmemory', options.maxMemory);
+  }
+  if (options.sample) {
+    args.push('-sample', options.sample.join(','));
+  }
+  const {
+    stdout
+  } = await (0, _index.execa)(_index3.default, args, {
+    encoding: null,
+    input: buffer,
+    maxBuffer: Number.POSITIVE_INFINITY
+  });
+  return stdout;
+};
+var _default = exports.default = imageminMozjpeg;
+}
+
+exportImageminMozjpeg()

package/vendor/imagemin-mozjpeg/node_modules/execa/index.js

@@ -0,0 +1,264 @@
+async function exportExeca () {
+  "use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.execa = execa;
+exports.execaCommand = execaCommand;
+exports.execaCommandSync = execaCommandSync;
+exports.execaNode = execaNode;
+exports.execaSync = execaSync;
+require("core-js/modules/esnext.async-iterator.filter.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _nodeBuffer = require("node:buffer");
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _nodeChild_process = _interopRequireDefault(require("node:child_process"));
+var _nodeProcess = _interopRequireDefault(require("node:process"));
+var _crossSpawn = _interopRequireDefault(require("cross-spawn"));
+var _index = _interopRequireDefault(require("../strip-final-newline/index.js"));
+var _index2 = require("../npm-run-path/index.js");
+var _index3 = _interopRequireDefault(require("../onetime/index.js"));
+var _error = require("./lib/error.js");
+var _stdio = require("./lib/stdio.js");
+var _kill = require("./lib/kill.js");
+var _stream = require("./lib/stream.js");
+var _promise = require("./lib/promise.js");
+var _command = require("./lib/command.js");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const DEFAULT_MAX_BUFFER = 1000 * 1000 * 100;
+const getEnv = _ref => {
+  let {
+    env: envOption,
+    extendEnv,
+    preferLocal,
+    localDir,
+    execPath
+  } = _ref;
+  const env = extendEnv ? {
+    ..._nodeProcess.default.env,
+    ...envOption
+  } : envOption;
+  if (preferLocal) {
+    return (0, _index2.npmRunPathEnv)({
+      env,
+      cwd: localDir,
+      execPath
+    });
+  }
+  return env;
+};
+const handleArguments = function (file, args) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const parsed = _crossSpawn.default._parse(file, args, options);
+  file = parsed.command;
+  args = parsed.args;
+  options = parsed.options;
+  options = {
+    maxBuffer: DEFAULT_MAX_BUFFER,
+    buffer: true,
+    stripFinalNewline: true,
+    extendEnv: true,
+    preferLocal: false,
+    localDir: options.cwd || _nodeProcess.default.cwd(),
+    execPath: _nodeProcess.default.execPath,
+    encoding: 'utf8',
+    reject: true,
+    cleanup: true,
+    all: false,
+    windowsHide: true,
+    ...options
+  };
+  options.env = getEnv(options);
+  options.stdio = (0, _stdio.normalizeStdio)(options);
+  if (_nodeProcess.default.platform === 'win32' && _nodePath.default.basename(file, '.exe') === 'cmd') {
+    // #116
+    args.unshift('/q');
+  }
+  return {
+    file,
+    args,
+    options,
+    parsed
+  };
+};
+const handleOutput = (options, value, error) => {
+  if (typeof value !== 'string' && !_nodeBuffer.Buffer.isBuffer(value)) {
+    // When `execaSync()` errors, we normalize it to '' to mimic `execa()`
+    return error === undefined ? undefined : '';
+  }
+  if (options.stripFinalNewline) {
+    return (0, _index.default)(value);
+  }
+  return value;
+};
+function execa(file, args, options) {
+  const parsed = handleArguments(file, args, options);
+  const command = (0, _command.joinCommand)(file, args);
+  const escapedCommand = (0, _command.getEscapedCommand)(file, args);
+  (0, _kill.validateTimeout)(parsed.options);
+  let spawned;
+  try {
+    spawned = _nodeChild_process.default.spawn(parsed.file, parsed.args, parsed.options);
+  } catch (error) {
+    // Ensure the returned error is always both a promise and a child process
+    const dummySpawned = new _nodeChild_process.default.ChildProcess();
+    const errorPromise = Promise.reject((0, _error.makeError)({
+      error,
+      stdout: '',
+      stderr: '',
+      all: '',
+      command,
+      escapedCommand,
+      parsed,
+      timedOut: false,
+      isCanceled: false,
+      killed: false
+    }));
+    return (0, _promise.mergePromise)(dummySpawned, errorPromise);
+  }
+  const spawnedPromise = (0, _promise.getSpawnedPromise)(spawned);
+  const timedPromise = (0, _kill.setupTimeout)(spawned, parsed.options, spawnedPromise);
+  const processDone = (0, _kill.setExitHandler)(spawned, parsed.options, timedPromise);
+  const context = {
+    isCanceled: false
+  };
+  spawned.kill = _kill.spawnedKill.bind(null, spawned.kill.bind(spawned));
+  spawned.cancel = _kill.spawnedCancel.bind(null, spawned, context);
+  const handlePromise = async () => {
+    const [{
+      error,
+      exitCode,
+      signal,
+      timedOut
+    }, stdoutResult, stderrResult, allResult] = await (0, _stream.getSpawnedResult)(spawned, parsed.options, processDone);
+    const stdout = handleOutput(parsed.options, stdoutResult);
+    const stderr = handleOutput(parsed.options, stderrResult);
+    const all = handleOutput(parsed.options, allResult);
+    if (error || exitCode !== 0 || signal !== null) {
+      const returnedError = (0, _error.makeError)({
+        error,
+        exitCode,
+        signal,
+        stdout,
+        stderr,
+        all,
+        command,
+        escapedCommand,
+        parsed,
+        timedOut,
+        isCanceled: context.isCanceled || (parsed.options.signal ? parsed.options.signal.aborted : false),
+        killed: spawned.killed
+      });
+      if (!parsed.options.reject) {
+        return returnedError;
+      }
+      throw returnedError;
+    }
+    return {
+      command,
+      escapedCommand,
+      exitCode: 0,
+      stdout,
+      stderr,
+      all,
+      failed: false,
+      timedOut: false,
+      isCanceled: false,
+      killed: false
+    };
+  };
+  const handlePromiseOnce = (0, _index3.default)(handlePromise);
+  (0, _stream.handleInput)(spawned, parsed.options.input);
+  spawned.all = (0, _stream.makeAllStream)(spawned, parsed.options);
+  return (0, _promise.mergePromise)(spawned, handlePromiseOnce);
+}
+function execaSync(file, args, options) {
+  const parsed = handleArguments(file, args, options);
+  const command = (0, _command.joinCommand)(file, args);
+  const escapedCommand = (0, _command.getEscapedCommand)(file, args);
+  (0, _stream.validateInputSync)(parsed.options);
+  let result;
+  try {
+    result = _nodeChild_process.default.spawnSync(parsed.file, parsed.args, parsed.options);
+  } catch (error) {
+    throw (0, _error.makeError)({
+      error,
+      stdout: '',
+      stderr: '',
+      all: '',
+      command,
+      escapedCommand,
+      parsed,
+      timedOut: false,
+      isCanceled: false,
+      killed: false
+    });
+  }
+  const stdout = handleOutput(parsed.options, result.stdout, result.error);
+  const stderr = handleOutput(parsed.options, result.stderr, result.error);
+  if (result.error || result.status !== 0 || result.signal !== null) {
+    const error = (0, _error.makeError)({
+      stdout,
+      stderr,
+      error: result.error,
+      signal: result.signal,
+      exitCode: result.status,
+      command,
+      escapedCommand,
+      parsed,
+      timedOut: result.error && result.error.code === 'ETIMEDOUT',
+      isCanceled: false,
+      killed: result.signal !== null
+    });
+    if (!parsed.options.reject) {
+      return error;
+    }
+    throw error;
+  }
+  return {
+    command,
+    escapedCommand,
+    exitCode: 0,
+    stdout,
+    stderr,
+    failed: false,
+    timedOut: false,
+    isCanceled: false,
+    killed: false
+  };
+}
+function execaCommand(command, options) {
+  const [file, ...args] = (0, _command.parseCommand)(command);
+  return execa(file, args, options);
+}
+function execaCommandSync(command, options) {
+  const [file, ...args] = (0, _command.parseCommand)(command);
+  return execaSync(file, args, options);
+}
+function execaNode(scriptPath, args) {
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (args && !Array.isArray(args) && typeof args === 'object') {
+    options = args;
+    args = [];
+  }
+  const stdio = (0, _stdio.normalizeStdioNode)(options);
+  const defaultExecArgv = _nodeProcess.default.execArgv.filter(arg => !arg.startsWith('--inspect'));
+  const {
+    nodePath = _nodeProcess.default.execPath,
+    nodeOptions = defaultExecArgv
+  } = options;
+  return execa(nodePath, [...nodeOptions, scriptPath, ...(Array.isArray(args) ? args : [])], {
+    ...options,
+    stdin: undefined,
+    stdout: undefined,
+    stderr: undefined,
+    stdio,
+    shell: false
+  });
+}
+}
+
+exportExeca()

package/vendor/imagemin-mozjpeg/node_modules/execa/lib/command.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.parseCommand = exports.joinCommand = exports.getEscapedCommand = void 0;
+require("core-js/modules/es.string.replace.js");
+require("core-js/modules/esnext.async-iterator.map.js");
+require("core-js/modules/esnext.iterator.map.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+const normalizeArgs = function (file) {
+  let args = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  if (!Array.isArray(args)) {
+    return [file];
+  }
+  return [file, ...args];
+};
+const NO_ESCAPE_REGEXP = /^[\w.-]+$/;
+const DOUBLE_QUOTES_REGEXP = /"/g;
+const escapeArg = arg => {
+  if (typeof arg !== 'string' || NO_ESCAPE_REGEXP.test(arg)) {
+    return arg;
+  }
+  return "\"".concat(arg.replace(DOUBLE_QUOTES_REGEXP, '\\"'), "\"");
+};
+const joinCommand = (file, args) => normalizeArgs(file, args).join(' ');
+exports.joinCommand = joinCommand;
+const getEscapedCommand = (file, args) => normalizeArgs(file, args).map(arg => escapeArg(arg)).join(' ');
+exports.getEscapedCommand = getEscapedCommand;
+const SPACES_REGEXP = / +/g;
+
+// Handle `execaCommand()`
+const parseCommand = command => {
+  const tokens = [];
+  for (const token of command.trim().split(SPACES_REGEXP)) {
+    // Allow spaces to be escaped by a backslash if not meant as a delimiter
+    const previousToken = tokens[tokens.length - 1];
+    if (previousToken && previousToken.endsWith('\\')) {
+      // Merge previous token with current one
+      tokens[tokens.length - 1] = "".concat(previousToken.slice(0, -1), " ").concat(token);
+    } else {
+      tokens.push(token);
+    }
+  }
+  return tokens;
+};
+exports.parseCommand = parseCommand;

package/vendor/imagemin-mozjpeg/node_modules/execa/lib/error.js

@@ -0,0 +1,102 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.makeError = void 0;
+require("core-js/modules/esnext.async-iterator.filter.js");
+require("core-js/modules/esnext.iterator.constructor.js");
+require("core-js/modules/esnext.iterator.filter.js");
+var _main = require("../../human-signals/build/src/main.js");
+const getErrorPrefix = _ref => {
+  let {
+    timedOut,
+    timeout,
+    errorCode,
+    signal,
+    signalDescription,
+    exitCode,
+    isCanceled
+  } = _ref;
+  if (timedOut) {
+    return "timed out after ".concat(timeout, " milliseconds");
+  }
+  if (isCanceled) {
+    return 'was canceled';
+  }
+  if (errorCode !== undefined) {
+    return "failed with ".concat(errorCode);
+  }
+  if (signal !== undefined) {
+    return "was killed with ".concat(signal, " (").concat(signalDescription, ")");
+  }
+  if (exitCode !== undefined) {
+    return "failed with exit code ".concat(exitCode);
+  }
+  return 'failed';
+};
+const makeError = _ref2 => {
+  let {
+    stdout,
+    stderr,
+    all,
+    error,
+    signal,
+    exitCode,
+    command,
+    escapedCommand,
+    timedOut,
+    isCanceled,
+    killed,
+    parsed: {
+      options: {
+        timeout
+      }
+    }
+  } = _ref2;
+  // `signal` and `exitCode` emitted on `spawned.on('exit')` event can be `null`.
+  // We normalize them to `undefined`
+  exitCode = exitCode === null ? undefined : exitCode;
+  signal = signal === null ? undefined : signal;
+  const signalDescription = signal === undefined ? undefined : _main.signalsByName[signal].description;
+  const errorCode = error && error.code;
+  const prefix = getErrorPrefix({
+    timedOut,
+    timeout,
+    errorCode,
+    signal,
+    signalDescription,
+    exitCode,
+    isCanceled
+  });
+  const execaMessage = "Command ".concat(prefix, ": ").concat(command);
+  const isError = Object.prototype.toString.call(error) === '[object Error]';
+  const shortMessage = isError ? "".concat(execaMessage, "\n").concat(error.message) : execaMessage;
+  const message = [shortMessage, stderr, stdout].filter(Boolean).join('\n');
+  if (isError) {
+    error.originalMessage = error.message;
+    error.message = message;
+  } else {
+    error = new Error(message);
+  }
+  error.shortMessage = shortMessage;
+  error.command = command;
+  error.escapedCommand = escapedCommand;
+  error.exitCode = exitCode;
+  error.signal = signal;
+  error.signalDescription = signalDescription;
+  error.stdout = stdout;
+  error.stderr = stderr;
+  if (all !== undefined) {
+    error.all = all;
+  }
+  if ('bufferedData' in error) {
+    delete error.bufferedData;
+  }
+  error.failed = true;
+  error.timedOut = Boolean(timedOut);
+  error.isCanceled = isCanceled;
+  error.killed = killed && !timedOut;
+  return error;
+};
+exports.makeError = makeError;

package/vendor/imagemin-mozjpeg/node_modules/execa/lib/kill.js

@@ -0,0 +1,123 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.validateTimeout = exports.spawnedKill = exports.spawnedCancel = exports.setupTimeout = exports.setExitHandler = void 0;
+require("core-js/modules/es.promise.finally.js");
+require("core-js/modules/web.dom-collections.iterator.js");
+var _nodeOs = _interopRequireDefault(require("node:os"));
+var _signalExit = _interopRequireDefault(require("signal-exit"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const DEFAULT_FORCE_KILL_TIMEOUT = 1000 * 5;
+
+// Monkey-patches `childProcess.kill()` to add `forceKillAfterTimeout` behavior
+const spawnedKill = function (kill) {
+  let signal = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'SIGTERM';
+  let options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  const killResult = kill(signal);
+  setKillTimeout(kill, signal, options, killResult);
+  return killResult;
+};
+exports.spawnedKill = spawnedKill;
+const setKillTimeout = (kill, signal, options, killResult) => {
+  if (!shouldForceKill(signal, options, killResult)) {
+    return;
+  }
+  const timeout = getForceKillAfterTimeout(options);
+  const t = setTimeout(() => {
+    kill('SIGKILL');
+  }, timeout);
+
+  // Guarded because there's no `.unref()` when `execa` is used in the renderer
+  // process in Electron. This cannot be tested since we don't run tests in
+  // Electron.
+  // istanbul ignore else
+  if (t.unref) {
+    t.unref();
+  }
+};
+const shouldForceKill = (signal, _ref, killResult) => {
+  let {
+    forceKillAfterTimeout
+  } = _ref;
+  return isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
+};
+const isSigterm = signal => signal === _nodeOs.default.constants.signals.SIGTERM || typeof signal === 'string' && signal.toUpperCase() === 'SIGTERM';
+const getForceKillAfterTimeout = _ref2 => {
+  let {
+    forceKillAfterTimeout = true
+  } = _ref2;
+  if (forceKillAfterTimeout === true) {
+    return DEFAULT_FORCE_KILL_TIMEOUT;
+  }
+  if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
+    throw new TypeError("Expected the `forceKillAfterTimeout` option to be a non-negative integer, got `".concat(forceKillAfterTimeout, "` (").concat(typeof forceKillAfterTimeout, ")"));
+  }
+  return forceKillAfterTimeout;
+};
+
+// `childProcess.cancel()`
+const spawnedCancel = (spawned, context) => {
+  const killResult = spawned.kill();
+  if (killResult) {
+    context.isCanceled = true;
+  }
+};
+exports.spawnedCancel = spawnedCancel;
+const timeoutKill = (spawned, signal, reject) => {
+  spawned.kill(signal);
+  reject(Object.assign(new Error('Timed out'), {
+    timedOut: true,
+    signal
+  }));
+};
+
+// `timeout` option handling
+const setupTimeout = (spawned, _ref3, spawnedPromise) => {
+  let {
+    timeout,
+    killSignal = 'SIGTERM'
+  } = _ref3;
+  if (timeout === 0 || timeout === undefined) {
+    return spawnedPromise;
+  }
+  let timeoutId;
+  const timeoutPromise = new Promise((resolve, reject) => {
+    timeoutId = setTimeout(() => {
+      timeoutKill(spawned, killSignal, reject);
+    }, timeout);
+  });
+  const safeSpawnedPromise = spawnedPromise.finally(() => {
+    clearTimeout(timeoutId);
+  });
+  return Promise.race([timeoutPromise, safeSpawnedPromise]);
+};
+exports.setupTimeout = setupTimeout;
+const validateTimeout = _ref4 => {
+  let {
+    timeout
+  } = _ref4;
+  if (timeout !== undefined && (!Number.isFinite(timeout) || timeout < 0)) {
+    throw new TypeError("Expected the `timeout` option to be a non-negative integer, got `".concat(timeout, "` (").concat(typeof timeout, ")"));
+  }
+};
+
+// `cleanup` option handling
+exports.validateTimeout = validateTimeout;
+const setExitHandler = async (spawned, _ref5, timedPromise) => {
+  let {
+    cleanup,
+    detached
+  } = _ref5;
+  if (!cleanup || detached) {
+    return timedPromise;
+  }
+  const removeExitHandler = (0, _signalExit.default)(() => {
+    spawned.kill();
+  });
+  return timedPromise.finally(() => {
+    removeExitHandler();
+  });
+};
+exports.setExitHandler = setExitHandler;

package/vendor/imagemin-mozjpeg/node_modules/execa/lib/promise.js

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergePromise = exports.getSpawnedPromise = void 0;
+require("core-js/modules/web.dom-collections.iterator.js");
+const nativePromisePrototype = (async () => {})().constructor.prototype;
+const descriptors = ['then', 'catch', 'finally'].map(property => [property, Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property)]);
+
+// The return value is a mixin of `childProcess` and `Promise`
+const mergePromise = (spawned, promise) => {
+  for (const [property, descriptor] of descriptors) {
+    // Starting the main `promise` is deferred to avoid consuming streams
+    const value = typeof promise === 'function' ? function () {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      return Reflect.apply(descriptor.value, promise(), args);
+    } : descriptor.value.bind(promise);
+    Reflect.defineProperty(spawned, property, {
+      ...descriptor,
+      value
+    });
+  }
+  return spawned;
+};
+
+// Use promises instead of `child_process` events
+exports.mergePromise = mergePromise;
+const getSpawnedPromise = spawned => new Promise((resolve, reject) => {
+  spawned.on('exit', (exitCode, signal) => {
+    resolve({
+      exitCode,
+      signal
+    });
+  });
+  spawned.on('error', error => {
+    reject(error);
+  });
+  if (spawned.stdin) {
+    spawned.stdin.on('error', error => {
+      reject(error);
+    });
+  }
+});
+exports.getSpawnedPromise = getSpawnedPromise;