           expr.radicand()
         else false
 
-      invokeOrDefault: (@action)->
+      performOrDefault: (@action)->
         result = @findAndPerformAction(@expr)
         if @wasFound()
           result

        else
          power.open()

      invoke: (expression)->
        last = expression.last()

        # in the first case, our base case comes


    class_mixer(_TrailingOperatorHandling)

    class _ExpressionManipulator
      initialize: (@expr)->
      clone: ->
        @expr = @expr.clone()
        @
      withComponent: (position, fn)->
        comp = ttm.lib.math.ExpressionTraversal.build(@expr).
          findForID(position.position())
        fn(comp)
        @

      value: -> @expr

    class_mixer(_ExpressionManipulator)

    exports =
      calculate: Calculate
      square: Square
      append_decimal: AppendDecimal
      append_number: AppendNumber
      exponentiate_last: ExponentiateLast
      append_exponentiation: AppendExponentiation
      append_multiplication: AppendMultiplication
      append_addition: AppendAddition
      append_equals: AppendEquals
      append_subtraction: AppendSubtraction
      negate_last: Negation
      append_open_sub_expression: AppendOpenSubExpression
      close_sub_expression: CloseSubExpression
      append_division: AppendDivision
      append_pi: AppendPi
      update_position: UpdatePosition
      square_root: SquareRoot
      append_root: AppendRoot
      append_variable: AppendVariable
      reset: Reset

    class ExpressionManipulationSource
      initialize: (@comps, @pos)->
      classes: exports
    ttm.class_mixer(ExpressionManipulationSource)

    for name, klass of exports
      build_klass = do (name, klass)->
        (opts={})->
          opts.comps = @comps
          opts.pos = @pos
          klass.build(opts)
      ExpressionManipulationSource.prototype["build_#{name}"] = build_klass

