Throw something.

    Syntax: {command} <object> [at <target>]
428017
def cmd(send, msg, args):
    
    users = get_users(args)
    if " into " in msg and msg != "into":
        match = re.match('(.*) into (.*)', msg)
        if match:
            msg = 'throws %s into %s' % (match.group(1), match.group(2))
            send(msg, 'action')
        else:
            return
    elif " at " in msg and msg != "at":
        match = re.match('(.*) at (.*)', msg)
        if match:
            msg = 'throws %s at %s' % (match.group(1), match.group(2))
            send(msg, 'action')
        else:
            return
    elif msg:
        msg = 'throws %s at %s' % (msg, choice(users))
        send(msg, 'action')
    else:
        send("Throw what?")
        return
1318519
def handle_one_command(self):
        """"""

        while True:
            yield from self.write_prompt()
            codeobj = yield from self.read_command()

            if codeobj is not None:
                yield from self.run_command(codeobj)
987673
function process(parent, index, commands) {
    var cmd = commands[index],
        ret;

    switch (cmd.value[0].type) {
        case ConkittyTypes.TEMPLATE_NAME:
            ret = processCall(parent, false, cmd);
            break;

        case ConkittyTypes.COMMAND_NAME:
            switch (cmd.value[0].value) {
                case 'ATTR':
                    ret = processAttr(parent, true, cmd);
                    break;

                case 'CALL':
                    ret = processCall(parent, true, cmd, commands[index + 1]);
                    break;

                case 'CHOOSE':
                    ret = processChoose(parent, cmd);
                    break;

                case 'EACH':
                    ret = processEach(parent, cmd, commands[index + 1]);
                    break;

                case 'EXPOSE':
                    ret = processExpose(parent, cmd);
                    break;

                case 'JS':
                    ret = processJS(parent, cmd);
                    break;

                case 'MEM':
                    ret = processMem(parent, cmd);
                    break;

                case 'PAYLOAD':
                    ret = processPayload(parent, cmd);
                    break;

                case 'SET':
                    ret = processSet(parent, cmd);
                    break;

                case 'TEST':
                    ret = processTest(parent, cmd);
                    break;

                case 'TRIGGER':
                    ret = processTrigger(parent, cmd);
                    break;

                case 'WITH':
                    ret = processWith(parent, cmd, commands[index + 1]);
                    break;

                default:
                    throw new ConkittyErrors.InconsistentCommand(cmd.value[0]);
            }

            break;

        case ConkittyTypes.VARIABLE:
            ret = processVariable(parent, cmd);
            break;

        case ConkittyTypes.JAVASCRIPT:
            ret = processJavascript(parent, cmd);
            break;

        case ConkittyTypes.STRING:
            ret = processString(parent, cmd);
            break;

        case ConkittyTypes.CSS:
            ret = processElement(parent, cmd);
            break;

        case ConkittyTypes.ATTR:
            ret = processAttr(parent, false, cmd);
            break;

        case ConkittyTypes.INCLUDE:
            ret = processInclude(parent, cmd);
            break;

        case ConkittyTypes.NODE_APPENDER:
            ret = processAppender(parent, cmd);
            break;

        default:
            throw new ConkittyErrors.InconsistentCommand(cmd.value[0]);
    }

    return index + ret;
}
314210
private Object invokeTarget(Object target, Method method, Object[] args) throws Throwable {
        Object returnValue;
        try {
            returnValue = method.invoke(target, args);
        } catch(InvocationTargetException ite) {
            throw ite.getTargetException();
        }
        return returnValue;
    }
242293
public void throwIfNotEmpty() {
        synchronized (nested) {
            if (nested.isEmpty()) {
                // Do nothing
            } else if (nested.size() == 1) {
                Throwable t = nested.get(0);
                TigerThrower.sneakyThrow(t);
            } else {
                throw this;
            }
        }
    }
950011
function(message, index) {
			var error = new Error(message + ' at character ' + index);
			error.index = index;
			error.description = message;
			throw error;
		}
994854
function onCommand(cmd, args) {

  if(cmd === Constants.MAP.multi.name) {
    return this._abort(new Error('multi transaction cannot be nested'));
  }

  if(cmd === Constants.MAP.watch.name) {
    return this._abort(
      new Error('watch should be executed before a multi transaction'));
  }

  if(!this._client || !Array.isArray(this._queue)) {
    throw new Error('multi transaction already aborted');
  }

  function doExec(cmd, args, cb) {
    this._client.execute(cmd, args, cb);
  }

  doExec = doExec.bind(this);

  function onComplete(cmd, args, err, reply) {

    if(typeof args[0] === 'function') {
      args[0](err, reply);
    }else{
      this._client.emit('exec', err, reply);
    }

    // reset, this multi can be re-used
    this._reset();
  }

  function onQueue(cmd, args, err, reply) {
    this._queue.push(err || reply);

    var next = this._commands.shift();
    /* istanbul ignore else */
    if(next) {
      // executing a command
      if(next.cmd !== Constants.MAP.exec.name) {
        doExec(next.cmd, next.args, onQueue.bind(this, next.cmd, next.args));
      // running the exec command to get the result
      }else{
        doExec(next.cmd, [], onComplete.bind(this, cmd, next.args));
      }
    }
  }

  // send first multi packet
  if(!this._multi) {
    doExec(
      this._commands[0].cmd,
      this._commands[0].args,
      onQueue.bind(
        this,
        this._commands[0].cmd, []));

    // clear multi packet
    this._commands = [];
    this._multi = true;
  }

  // stash the command in a queue
  this._commands.push({cmd: cmd, args: args});
}
1015561
function parse(cmd, params)
{
  return Object.keys(params).reduce(iterator.bind(this, params), cmd);
}
696908
function(){
    var args = Array.prototype.slice.apply(arguments);
    this.commands.execute.apply(this.commands, args);
  }
552681
function exec() {

  var actions = {
    commands: {
      'delete': { action: _delete },
      screenshot: { action: _screenshot }
    }
  };

  bag.command(__dirname, actions);
}
1245430
def process_command(command: CommandInput, matrix: VarMatrix) -> List[Command]:
    
    assert command is not None
    if isinstance(command, str):
        command_list = [Command(command, variables=variables) for variables in matrix]
    elif isinstance(command, list):
        command_list = [Command(command, variables=variables) for variables in matrix]
    else:
        if command.get("command") is not None:
            cmd = command.get("command")
        else:
            cmd = command.get("cmd")
        creates = str(command.get("creates", ""))
        requires = str(command.get("requires", ""))

        assert isinstance(cmd, (list, str))
        command_list = [
            Command(cmd, variables, creates, requires) for variables in matrix
        ]
    return uniqueify(command_list)
1041608
function throwOrConsole (msg, info) {
    if (debugLevel >= EventEmitter.DEBUG_THROW) throw new Error(msg + info);
    console.error(msg + info);
}
677657
function validate(cmd, args, info) {
  AbstractCommand.prototype.validate.apply(this, arguments);
  if(!info.conn.transaction) {
    throw DiscardWithoutMulti;
  }
}
1021939
function FilterCommand(value, engine) {
        var match = value.match(/^\s*([a-z0-9_-]+)\s*(\(([\s\S]*)\))?\s*$/i);
        if (!match) {
            throw new Error('Invalid ' + this.type + ' syntax: ' + value);
        }

        this.name = match[1];
        this.args = match[3];
        Command.call(this, value, engine);
        this.cloneProps = ['name', 'args'];
    }
119498
private Object executeCommandWithInjectedTx(InvocationContext ctx, VisitableCommand command) {
      final Object result;
      try {
         result = invoker.invoke(ctx, command);
      } catch (Throwable e) {
         tryRollback();
         throw e;
      }
      tryCommit();
      return result;
   }
862872
function parse (argv, opts, target) {
  if ('string' === typeof argv) argv = argv.split(rSplit).filter(ignore);
  if (!opts) opts = {};
  opts[don] = true;
  var parsed = parseArray(argv, opts);
  opts[don] = false;
  var through = parsed[don].length ? parseArray(parsed[don], opts) : null;
  if (!target) target = {};
  target.options = parsed;
  target.commands = parsed[din];
  target.input = argv;
  if (through) {
    target.through = {
      options: through,
      commands: through[din]
    };
    delete through[din];
  }
  delete parsed[din];
  delete parsed[don];
  return target;
  function ignore (s) {
    return s && '' !== s;
  }
}
866593
function parseThrowStatement(node) {
        var argument;

        expectKeyword('throw');

        if (hasLineTerminator) {
            throwError(Messages.NewlineAfterThrow);
        }

        argument = parseExpression();

        consumeSemicolon();

        return node.finishThrowStatement(argument);
    }