transition_to : function (name, params) { },
775540
function (url) {
		var current = this.current, params = current.params;

		var state = find(url);

		if (state.is_changed(current.name, params)) {
			this.current = state;
			this.trigger_event("state_changed", state);
			this.trigger_event("state_changed_success", url);
		}
	}
1169428
def thing_params
      @params ||= thing.new.attributes.keys.map(&:to_sym)
      params.require(thing.name.underscore.to_sym).permit(
        @params,
        :page
      )
    end
212244
function transition() {
    var ts = this.__transitions__, i, len;

    if (!ts || ts.length === 0) { return; }

    for (i = 0, len = ts.length; i < len; i++) {
      enter.call(ts[i].pivot, ts[i].states, ts[i].opts);
    }

    this.__transitions__ = [];
  }
395536
function setTransitionProperties(transition) {
        PermTransitionProperties.toState = transition.to();
        PermTransitionProperties.toParams = transition.params('to');
        PermTransitionProperties.fromState = transition.from();
        PermTransitionProperties.fromParams = transition.params('from');
        PermTransitionProperties.options = transition.options();
      }
1371118
function(callback) {
        var anim = this;

        if (!anim._running) {
            anim._running = true;

            anim._node.fire('transition:start', {
                type: 'transition:start',
                config: anim._config
            });

            anim._start();
            anim._callback = callback;
        }

        return anim;
    }
781926
def recently_walked?(transition)
        transitions = self
        if @target && @target != to_name && target_transition = detect {|t| t.to_name == @target}
          transitions = transitions[index(target_transition) + 1..-1]
        end
        transitions.include?(transition)
      end
1188129
function main() {
    this.prior = this.current;
    this.current = this.current.apply(this, arguments) || this.current;
    // Call user transition function, if defined
    if (this.transition) {
        this.transition.apply(this, arguments);
    }
}
808778
function func(ast) {
  var params = list(ast["params"])
  var id = ast["id"] ? to_s(ast["id"]) : ""
  return "function " + id + "(" + params + ") " + to_s(ast["body"])
}
557258
function(options) {
        this._transitions = {}
        this._states = {}
        options = options || {}
        this._bindStates()
        this._bindTransitions()
        if (options.debugStateMachine === true)
          StateMachine.DebugView.register(this)
        this.bind('all', this._onMachineEvent, this)
        this.currentState = INIT_STATE
        this.startStateMachine = function() {
          throw new Error('startStateMachine has been called twice!')
        }
      }
519453
def transition_function(self, qi, u):
        
        try:
            return self.transition[qi][u]
        except KeyError:
            if u in self.alphabet:
                try:
                    return self.transition[qi]['*']
                except KeyError:
                    return None
            return None
737100
def _post_transition(self, result, *args, **kwargs):
        """"""
        for hook in self._filter_hooks(HOOK_AFTER, HOOK_ON_ENTER):
            hook(self.instance, result, *args, **kwargs)
1078180
function functionEntry (name) {
      const fn = functions[name]
      let syntax = SYNTAX[name] || (fn.doc && fn.doc.syntax && fn.doc.syntax[0]) || name
      syntax = syntax
        // .replace(/^math\./, '')
        .replace(/\s+\/\/.*$/, '')
        .replace(/;$/, '')
      if (syntax.length < 40) {
        syntax = syntax.replace(/ /g, '&nbsp;')
      }

      let description = ''
      if (fn.doc.description) {
        description = fn.doc.description.replace(/\n/g, ' ').split('.')[0] + '.'
      }

      return '[' + syntax + '](functions/' + name + '.md) | ' + description
    }
677185
def get_transition(self,  # suppress(too-many-arguments)
                       line,
                       line_index,
                       column,
                       is_escaped,
                       *args,
                       **kwargs):
        """"""
        del line_index
        del args
        del kwargs

        wait_until_len = len(self._waiting_until)
        if (_token_at_col_in_line(line,
                                  column,
                                  self._waiting_until,
                                  wait_until_len) and
                not _is_escaped(line, column, is_escaped)):
            return (InTextParser(), 1, None)

        return (self, 1, None)
638640
function toFunction(term){
    return eval(transmogrify(
      function(varName, body){ return "(function("+varName+"){return "+body+"})"; },
      function(fun, arg){ return fun+"("+arg+")"; })
      (term));
  }
305867
def transitions
        @transitions ||= empty? ? [] : machine.events.transitions_for(object, :from => to_name, :guard => @guard).select {|transition| can_walk_to?(transition)}
      end
1348588
function( to, from, prefix ) {
            var samePage = false;

            prefix = prefix || "";

            // TODO decide if these events should in fact be triggered on the container
            if ( from ) {

                //Check if this is a same page transition and tell the handler in page
                if( to[0] === from[0] ){
                    samePage = true;
                }

                //trigger before show/hide events
                // TODO deprecate nextPage in favor of next
                this._triggerWithDeprecated( prefix + "hide", {

                    // Deprecated in 1.4 remove in 1.5
                    nextPage: to,
                    toPage: to,
                    prevPage: from,
                    samePage: samePage
                }, from );
            }

            // TODO deprecate prevPage in favor of previous
            this._triggerWithDeprecated( prefix + "show", {
                prevPage: from || $( "" ),
                toPage: to
            }, to );
        }
1336567
function(convert, options) {
      var callback = options && 'process' in options ? options.process : options;

      if(typeof(callback) !== 'function') {
        return convert;
      }

      return function(string, options) {
        return callback(string, convert, options);
      }
    }