@socketsecurity/cli 0.11.1 → 0.13.0

package/dist/vendor.js

@@ -24,11 +24,10 @@ var require$$0$b = require('node:stream/promises');
 var require$$0$d = require('node:stream');
 var require$$0$c = require('node:buffer');
 var require$$1$1 = require('signal-exit');
-var require$$1$2 = require('onetime');
-var require$$0$e = require('node:assert');
 var require$$3 = require('cli-spinners');
-var require$$1$3 = require('supports-hyperlinks');
-var require$$1$4 = require('node:fs/promises');
+var require$$0$e = require('supports-color');
+var require$$1$2 = require('has-flag');
+var require$$1$3 = require('node:fs/promises');
 var require$$4$1 = require('fast-glob');
 var require$$5 = require('ignore');
 
@@ -314,19 +313,19 @@ function assembleStyles$1() {
 const ansiStyles$2 = assembleStyles$1();
 ansiStyles$3.default = ansiStyles$2;
 
-var supportsColor$1 = {};
+var supportsColor$2 = {};
 
-Object.defineProperty(supportsColor$1, "__esModule", {
+Object.defineProperty(supportsColor$2, "__esModule", {
   value: true
 });
-supportsColor$1.createSupportsColor = createSupportsColor;
-supportsColor$1.default = void 0;
+supportsColor$2.createSupportsColor = createSupportsColor;
+supportsColor$2.default = void 0;
 var _nodeProcess$w = require$$0;
 var _nodeOs$7 = require$$0$1;
 var _nodeTty$2 = require$$2;
 // From: https://github.com/sindresorhus/has-flag/blob/main/index.js
 /// function hasFlag(flag, argv = globalThis.Deno?.args ?? process.argv) {
-function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : _nodeProcess$w.argv) {
+function hasFlag$1(flag, argv = globalThis.Deno ? globalThis.Deno.args : _nodeProcess$w.argv) {
   const prefix = flag.startsWith('-') ? '' : flag.length === 1 ? '-' : '--';
   const position = argv.indexOf(prefix + flag);
   const terminatorPosition = argv.indexOf('--');
@@ -336,9 +335,9 @@ const {
   env: env$1
 } = _nodeProcess$w;
 let flagForceColor;
-if (hasFlag('no-color') || hasFlag('no-colors') || hasFlag('color=false') || hasFlag('color=never')) {
+if (hasFlag$1('no-color') || hasFlag$1('no-colors') || hasFlag$1('color=false') || hasFlag$1('color=never')) {
   flagForceColor = 0;
-} else if (hasFlag('color') || hasFlag('colors') || hasFlag('color=true') || hasFlag('color=always')) {
+} else if (hasFlag$1('color') || hasFlag$1('colors') || hasFlag$1('color=true') || hasFlag$1('color=always')) {
   flagForceColor = 1;
 }
 function envForceColor() {
@@ -376,10 +375,10 @@ function _supportsColor(haveStream, {
     return 0;
   }
   if (sniffFlags) {
-    if (hasFlag('color=16m') || hasFlag('color=full') || hasFlag('color=truecolor')) {
+    if (hasFlag$1('color=16m') || hasFlag$1('color=full') || hasFlag$1('color=truecolor')) {
       return 3;
     }
-    if (hasFlag('color=256')) {
+    if (hasFlag$1('color=256')) {
       return 2;
     }
   }
@@ -455,7 +454,7 @@ function createSupportsColor(stream, options = {}) {
   });
   return translateLevel(level);
 }
-const supportsColor = {
+const supportsColor$1 = {
   stdout: createSupportsColor({
     isTTY: _nodeTty$2.isatty(1)
   }),
@@ -463,7 +462,7 @@ const supportsColor = {
     isTTY: _nodeTty$2.isatty(2)
   })
 };
-supportsColor$1.default = supportsColor;
+supportsColor$2.default = supportsColor$1;
 
 var utilities$1 = {};
 
@@ -560,7 +559,7 @@ function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
 	});
 	exports.supportsColorStderr = exports.supportsColor = void 0;
 	var _ansiStyles = ansiStyles$3;
-	var _supportsColor = supportsColor$1;
+	var _supportsColor = supportsColor$2;
 	var _utilities = utilities$1;
 	var _index = ansiStyles$3;
 	const {
@@ -1148,12 +1147,12 @@ var _nodeProcess$t = require$$0;
 constants$1.IS_LINUX = _nodeProcess$t.platform === 'linux';
 constants$1.IS_WINDOWS = _nodeProcess$t.platform === 'win32';
 
-var signals$3 = {};
+var signals$1 = {};
 
-Object.defineProperty(signals$3, "__esModule", {
+Object.defineProperty(signals$1, "__esModule", {
   value: true
 });
-signals$3.default = void 0;
+signals$1.default = void 0;
 var _constants$6 = constants$1;
 /* IMPORT */
 
@@ -1167,7 +1166,7 @@ if (_constants$6.IS_LINUX) {
   Signals.push('SIGIO', 'SIGPOLL', 'SIGPWR', 'SIGSTKFLT', 'SIGUNUSED');
 }
 /* EXPORT */
-signals$3.default = Signals;
+signals$1.default = Signals;
 
 Object.defineProperty(interceptor, "__esModule", {
   value: true
@@ -1175,7 +1174,7 @@ Object.defineProperty(interceptor, "__esModule", {
 interceptor.default = void 0;
 var _nodeProcess$s = require$$0;
 var _constants$5 = constants$1;
-var _signals$1 = signals$3;
+var _signals$1 = signals$1;
 /* IMPORT */
 
 /* MAIN */
@@ -5719,7 +5718,7 @@ const getRealtimeSignal = (value, index) => ({
 const SIGRTMIN = 34;
 const SIGRTMAX = realtime.SIGRTMAX = 64;
 
-var signals$2 = {};
+var signals = {};
 
 var core = {};
 
@@ -5960,10 +5959,10 @@ core.SIGNALS = [{
   standard: "other"
 }];
 
-Object.defineProperty(signals$2, "__esModule", {
+Object.defineProperty(signals, "__esModule", {
   value: true
 });
-signals$2.getSignals = void 0;
+signals.getSignals = void 0;
 var _nodeOs$3 = require$$0$1;
 var _core = core;
 var _realtime$1 = realtime;
@@ -5972,7 +5971,7 @@ const getSignals = () => {
   const signals = [..._core.SIGNALS, ...realtimeSignals].map(normalizeSignal$1);
   return signals;
 };
-signals$2.getSignals = getSignals;
+signals.getSignals = getSignals;
 const normalizeSignal$1 = ({
   name,
   number: defaultNumber,
@@ -6005,7 +6004,7 @@ Object.defineProperty(main$1, "__esModule", {
 main$1.signalsByNumber = main$1.signalsByName = void 0;
 var _nodeOs$2 = require$$0$1;
 var _realtime = realtime;
-var _signals = signals$2;
+var _signals = signals;
 const getSignalsByName = () => {
   const signals = (0, _signals.getSignals)();
   return Object.fromEntries(signals.map(getSignalByName));
@@ -23104,244 +23103,134 @@ var cliCursor$1 = {};
 
 var restoreCursor$1 = {};
 
-var signalExit = {exports: {}};
+var onetime$1 = {};
 
-var signals$1 = {exports: {}};
+var mimicFunction$1 = {};
 
-var hasRequiredSignals;
-
-function requireSignals () {
-	if (hasRequiredSignals) return signals$1.exports;
-	hasRequiredSignals = 1;
-	(function (module) {
-
-		// This is not the set of all possible signals.
-		//
-		// It IS, however, the set of all signals that trigger
-		// an exit on either Linux or BSD systems.  Linux is a
-		// superset of the signal names supported on BSD, and
-		// the unknown signals just fail to register, so we can
-		// catch that easily enough.
-		//
-		// Don't bother with SIGKILL.  It's uncatchable, which
-		// means that we can't fire any callbacks anyway.
-		//
-		// If a user does happen to register a handler on a non-
-		// fatal signal like SIGWINCH or something, and then
-		// exit, it'll end up firing `process.emit('exit')`, so
-		// the handler will be fired anyway.
-		//
-		// SIGBUS, SIGFPE, SIGSEGV and SIGILL, when not raised
-		// artificially, inherently leave the process in a
-		// state from which it is not safe to try and enter JS
-		// listeners.
-		module.exports = ['SIGABRT', 'SIGALRM', 'SIGHUP', 'SIGINT', 'SIGTERM'];
-		if (process.platform !== 'win32') {
-		  module.exports.push('SIGVTALRM', 'SIGXCPU', 'SIGXFSZ', 'SIGUSR2', 'SIGTRAP', 'SIGSYS', 'SIGQUIT', 'SIGIOT'
-		  // should detect profiler and enable/disable accordingly.
-		  // see #21
-		  // 'SIGPROF'
-		  );
-		}
-		if (process.platform === 'linux') {
-		  module.exports.push('SIGIO', 'SIGPOLL', 'SIGPWR', 'SIGSTKFLT', 'SIGUNUSED');
-		} 
-	} (signals$1));
-	return signals$1.exports;
-}
+Object.defineProperty(mimicFunction$1, "__esModule", {
+  value: true
+});
+mimicFunction$1.default = mimicFunction;
+const copyProperty = (to, from, property, ignoreNonConfigurable) => {
+  // `Function#length` should reflect the parameters of `to` not `from` since we keep its body.
+  // `Function#prototype` is non-writable and non-configurable so can never be modified.
+  if (property === 'length' || property === 'prototype') {
+    return;
+  }
 
-// Note: since nyc uses this module to output coverage, any lines
-// that are in the direct sync flow of nyc's outputCoverage are
-// ignored, since we can never get coverage for them.
-// grab a reference to node's real process object right away
-var process$1 = global.process;
-const processOk = function (process) {
-  return process && typeof process === 'object' && typeof process.removeListener === 'function' && typeof process.emit === 'function' && typeof process.reallyExit === 'function' && typeof process.listeners === 'function' && typeof process.kill === 'function' && typeof process.pid === 'number' && typeof process.on === 'function';
+  // `Function#arguments` and `Function#caller` should not be copied. They were reported to be present in `Reflect.ownKeys` for some devices in React Native (#41), so we explicitly ignore them here.
+  if (property === 'arguments' || property === 'caller') {
+    return;
+  }
+  const toDescriptor = Object.getOwnPropertyDescriptor(to, property);
+  const fromDescriptor = Object.getOwnPropertyDescriptor(from, property);
+  if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) {
+    return;
+  }
+  Object.defineProperty(to, property, fromDescriptor);
 };
 
-// some kind of non-node environment, just no-op
-/* istanbul ignore if */
-if (!processOk(process$1)) {
-  signalExit.exports = function () {
-    return function () {};
-  };
-} else {
-  var assert = require$$0$e;
-  var signals = requireSignals();
-  var isWin = /^win/i.test(process$1.platform);
-  var EE = require$$0$9;
-  /* istanbul ignore if */
-  if (typeof EE !== 'function') {
-    EE = EE.EventEmitter;
-  }
-  var emitter;
-  if (process$1.__signal_exit_emitter__) {
-    emitter = process$1.__signal_exit_emitter__;
-  } else {
-    emitter = process$1.__signal_exit_emitter__ = new EE();
-    emitter.count = 0;
-    emitter.emitted = {};
-  }
-
-  // Because this emitter is a global, we have to check to see if a
-  // previous version of this library failed to enable infinite listeners.
-  // I know what you're about to say.  But literally everything about
-  // signal-exit is a compromise with evil.  Get used to it.
-  if (!emitter.infinite) {
-    emitter.setMaxListeners(Infinity);
-    emitter.infinite = true;
-  }
-  signalExit.exports = function (cb, opts) {
-    /* istanbul ignore if */
-    if (!processOk(global.process)) {
-      return function () {};
-    }
-    assert.equal(typeof cb, 'function', 'a callback must be provided for exit handler');
-    if (loaded === false) {
-      load();
-    }
-    var ev = 'exit';
-    if (opts && opts.alwaysLast) {
-      ev = 'afterexit';
-    }
-    var remove = function () {
-      emitter.removeListener(ev, cb);
-      if (emitter.listeners('exit').length === 0 && emitter.listeners('afterexit').length === 0) {
-        unload();
-      }
-    };
-    emitter.on(ev, cb);
-    return remove;
-  };
-  var unload = function unload() {
-    if (!loaded || !processOk(global.process)) {
-      return;
-    }
-    loaded = false;
-    signals.forEach(function (sig) {
-      try {
-        process$1.removeListener(sig, sigListeners[sig]);
-      } catch (er) {}
-    });
-    process$1.emit = originalProcessEmit;
-    process$1.reallyExit = originalProcessReallyExit;
-    emitter.count -= 1;
-  };
-  signalExit.exports.unload = unload;
-  var emit = function emit(event, code, signal) {
-    /* istanbul ignore if */
-    if (emitter.emitted[event]) {
-      return;
-    }
-    emitter.emitted[event] = true;
-    emitter.emit(event, code, signal);
-  };
+// `Object.defineProperty()` throws if the property exists, is not configurable and either:
+// - one its descriptors is changed
+// - it is non-writable and its value is changed
+const canCopyProperty = function (toDescriptor, fromDescriptor) {
+  return toDescriptor === undefined || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value);
+};
+const changePrototype = (to, from) => {
+  const fromPrototype = Object.getPrototypeOf(from);
+  if (fromPrototype === Object.getPrototypeOf(to)) {
+    return;
+  }
+  Object.setPrototypeOf(to, fromPrototype);
+};
+const wrappedToString = (withName, fromBody) => `/* Wrapped ${withName}*/\n${fromBody}`;
+const toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, 'toString');
+const toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, 'name');
 
-  // { <signal>: <listener fn>, ... }
-  var sigListeners = {};
-  signals.forEach(function (sig) {
-    sigListeners[sig] = function listener() {
-      /* istanbul ignore if */
-      if (!processOk(global.process)) {
-        return;
-      }
-      // If there are no other listeners, an exit is coming!
-      // Simplest way: remove us and then re-send the signal.
-      // We know that this will kill the process, so we can
-      // safely emit now.
-      var listeners = process$1.listeners(sig);
-      if (listeners.length === emitter.count) {
-        unload();
-        emit('exit', null, sig);
-        /* istanbul ignore next */
-        emit('afterexit', null, sig);
-        /* istanbul ignore next */
-        if (isWin && sig === 'SIGHUP') {
-          // "SIGHUP" throws an `ENOSYS` error on Windows,
-          // so use a supported signal instead
-          sig = 'SIGINT';
-        }
-        /* istanbul ignore next */
-        process$1.kill(process$1.pid, sig);
-      }
-    };
+// We call `from.toString()` early (not lazily) to ensure `from` can be garbage collected.
+// We use `bind()` instead of a closure for the same reason.
+// Calling `from.toString()` early also allows caching it in case `to.toString()` is called several times.
+const changeToString = (to, from, name) => {
+  const withName = name === '' ? '' : `with ${name.trim()}() `;
+  const newToString = wrappedToString.bind(null, withName, from.toString());
+  // Ensure `to.toString.toString` is non-enumerable and has the same `same`
+  Object.defineProperty(newToString, 'name', toStringName);
+  const {
+    writable,
+    enumerable,
+    configurable
+  } = toStringDescriptor; // We destructue to avoid a potential `get` descriptor.
+  Object.defineProperty(to, 'toString', {
+    value: newToString,
+    writable,
+    enumerable,
+    configurable
   });
-  signalExit.exports.signals = function () {
-    return signals;
-  };
-  var loaded = false;
-  var load = function load() {
-    if (loaded || !processOk(global.process)) {
-      return;
-    }
-    loaded = true;
-
-    // This is the number of onSignalExit's that are in play.
-    // It's important so that we can count the correct number of
-    // listeners on signals, and don't wait for the other one to
-    // handle it instead of us.
-    emitter.count += 1;
-    signals = signals.filter(function (sig) {
-      try {
-        process$1.on(sig, sigListeners[sig]);
-        return true;
-      } catch (er) {
-        return false;
-      }
-    });
-    process$1.emit = processEmit;
-    process$1.reallyExit = processReallyExit;
-  };
-  signalExit.exports.load = load;
-  var originalProcessReallyExit = process$1.reallyExit;
-  var processReallyExit = function processReallyExit(code) {
-    /* istanbul ignore if */
-    if (!processOk(global.process)) {
-      return;
-    }
-    process$1.exitCode = code || /* istanbul ignore next */0;
-    emit('exit', process$1.exitCode, null);
-    /* istanbul ignore next */
-    emit('afterexit', process$1.exitCode, null);
-    /* istanbul ignore next */
-    originalProcessReallyExit.call(process$1, process$1.exitCode);
-  };
-  var originalProcessEmit = process$1.emit;
-  var processEmit = function processEmit(ev, arg) {
-    if (ev === 'exit' && processOk(global.process)) {
-      /* istanbul ignore else */
-      if (arg !== undefined) {
-        process$1.exitCode = arg;
-      }
-      var ret = originalProcessEmit.apply(this, arguments);
-      /* istanbul ignore next */
-      emit('exit', process$1.exitCode, null);
-      /* istanbul ignore next */
-      emit('afterexit', process$1.exitCode, null);
-      /* istanbul ignore next */
-      return ret;
-    } else {
-      return originalProcessEmit.apply(this, arguments);
-    }
-  };
+};
+function mimicFunction(to, from, {
+  ignoreNonConfigurable = false
+} = {}) {
+  const {
+    name
+  } = to;
+  for (const property of Reflect.ownKeys(from)) {
+    copyProperty(to, from, property, ignoreNonConfigurable);
+  }
+  changePrototype(to, from);
+  changeToString(to, from, name);
+  return to;
 }
 
-var signalExitExports = signalExit.exports;
+Object.defineProperty(onetime$1, "__esModule", {
+  value: true
+});
+onetime$1.default = void 0;
+var _mimicFunction = mimicFunction$1;
+const calledFunctions = new WeakMap();
+const onetime = (function_, options = {}) => {
+  if (typeof function_ !== 'function') {
+    throw new TypeError('Expected a function');
+  }
+  let returnValue;
+  let callCount = 0;
+  const functionName = function_.displayName || function_.name || '<anonymous>';
+  const onetime = function (...arguments_) {
+    calledFunctions.set(onetime, ++callCount);
+    if (callCount === 1) {
+      returnValue = function_.apply(this, arguments_);
+      function_ = undefined;
+    } else if (options.throw === true) {
+      throw new Error(`Function \`${functionName}\` can only be called once`);
+    }
+    return returnValue;
+  };
+  (0, _mimicFunction.default)(onetime, function_);
+  calledFunctions.set(onetime, callCount);
+  return onetime;
+};
+onetime.callCount = function_ => {
+  if (!calledFunctions.has(function_)) {
+    throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+  }
+  return calledFunctions.get(function_);
+};
+onetime$1.default = onetime;
 
 Object.defineProperty(restoreCursor$1, "__esModule", {
   value: true
 });
 restoreCursor$1.default = void 0;
 var _nodeProcess$a = require$$0;
-var _onetime = require$$1$2;
-var _signalExit = signalExitExports;
-const restoreCursor = _onetime(() => {
-  _signalExit(() => {
-    _nodeProcess$a.stderr.write('\u001B[?25h');
+var _onetime = onetime$1;
+var _signalExit = require$$1$1;
+const terminal = _nodeProcess$a.stderr.isTTY ? _nodeProcess$a.stderr : _nodeProcess$a.stdout.isTTY ? _nodeProcess$a.stdout : undefined;
+const restoreCursor = terminal ? (0, _onetime.default)(() => {
+  (0, _signalExit.onExit)(() => {
+    terminal.write('\u001B[?25h');
   }, {
     alwaysLast: true
   });
-});
+}) : () => {};
 restoreCursor$1.default = restoreCursor;
 
 Object.defineProperty(cliCursor$1, "__esModule", {
@@ -24061,12 +23950,97 @@ ansiEscapes.iTerm = {
 };
 ansiEscapes$1.default = ansiEscapes;
 
+const supportsColor = require$$0$e;
+const hasFlag = require$$1$2;
+function parseVersion(versionString) {
+  if (/^\d{3,4}$/.test(versionString)) {
+    // Env var doesn't always use dots. example: 4601 => 46.1.0
+    const m = /(\d{1,2})(\d{2})/.exec(versionString);
+    return {
+      major: 0,
+      minor: parseInt(m[1], 10),
+      patch: parseInt(m[2], 10)
+    };
+  }
+  const versions = (versionString || '').split('.').map(n => parseInt(n, 10));
+  return {
+    major: versions[0],
+    minor: versions[1],
+    patch: versions[2]
+  };
+}
+function supportsHyperlink(stream) {
+  const {
+    env
+  } = process;
+  if ('FORCE_HYPERLINK' in env) {
+    return !(env.FORCE_HYPERLINK.length > 0 && parseInt(env.FORCE_HYPERLINK, 10) === 0);
+  }
+  if (hasFlag('no-hyperlink') || hasFlag('no-hyperlinks') || hasFlag('hyperlink=false') || hasFlag('hyperlink=never')) {
+    return false;
+  }
+  if (hasFlag('hyperlink=true') || hasFlag('hyperlink=always')) {
+    return true;
+  }
+
+  // Netlify does not run a TTY, it does not need `supportsColor` check
+  if ('NETLIFY' in env) {
+    return true;
+  }
+
+  // If they specify no colors, they probably don't want hyperlinks.
+  if (!supportsColor.supportsColor(stream)) {
+    return false;
+  }
+  if (stream && !stream.isTTY) {
+    return false;
+  }
+  if (process.platform === 'win32') {
+    return false;
+  }
+  if ('CI' in env) {
+    return false;
+  }
+  if ('TEAMCITY_VERSION' in env) {
+    return false;
+  }
+  if ('TERM_PROGRAM' in env) {
+    const version = parseVersion(env.TERM_PROGRAM_VERSION);
+    switch (env.TERM_PROGRAM) {
+      case 'iTerm.app':
+        if (version.major === 3) {
+          return version.minor >= 1;
+        }
+        return version.major > 3;
+      case 'WezTerm':
+        return version.major >= 20200620;
+      case 'vscode':
+        return version.major > 1 || version.major === 1 && version.minor >= 72;
+      // No default
+    }
+  }
+  if ('VTE_VERSION' in env) {
+    // 0.50.0 was supposed to support hyperlinks, but throws a segfault
+    if (env.VTE_VERSION === '0.50.0') {
+      return false;
+    }
+    const version = parseVersion(env.VTE_VERSION);
+    return version.major > 0 || version.minor >= 50;
+  }
+  return false;
+}
+var supportsHyperlinks = {
+  supportsHyperlink,
+  stdout: supportsHyperlink(process.stdout),
+  stderr: supportsHyperlink(process.stderr)
+};
+
 Object.defineProperty(terminalLink$1, "__esModule", {
   value: true
 });
 terminalLink$1.default = terminalLink;
 var _ansiEscapes = ansiEscapes$1;
-var _supportsHyperlinks = require$$1$3;
+var _supportsHyperlinks = supportsHyperlinks;
 function terminalLink(text, url, {
   target = 'stdout',
   ...options
@@ -24462,7 +24436,7 @@ Object.defineProperty(ignore, "__esModule", {
 ignore.isIgnoredByIgnoreFilesSync = ignore.isIgnoredByIgnoreFiles = ignore.isGitIgnoredSync = ignore.isGitIgnored = ignore.GITIGNORE_FILES_PATTERN = void 0;
 var _nodeProcess$5 = require$$0;
 var _nodeFs$3 = require$$0$2;
-var _promises$1 = require$$1$4;
+var _promises$1 = require$$1$3;
 var _nodePath$1 = require$$1;
 var _fastGlob = require$$4$1;
 var _ignore = require$$5;
@@ -25107,7 +25081,7 @@ var _nodeBuffer = require$$0$c;
 var _nodePath = require$$1;
 var _nodeUrl = require$$2$3;
 var _nodeChild_process = require$$0$6;
-var _promises = _interopRequireWildcard(require$$1$4, true);
+var _promises = _interopRequireWildcard(require$$1$3, true);
 var _isWsl = isWsl$1;
 var _defineLazyProp = defineLazyProp;
 var _defaultBrowser = defaultBrowser$2;