Overriding an internal method with Decorator Design Pattern

I am writing an object-oriented code in which I am trying to use Decorator pattern to implement a variety of optimizations to be applied on a family of core classes at runtime. The main behaviour of core classes is a complex behaviour that is fully implemented in those classes, which indeed calls other internal methods to fulfill pieces of the task. The decorators will only customize the internal methods which are called by the complex behaviour in core class.

Here is a pseudo-code of what I'm trying to reach:

interface I{
  complex();
  step1();
  step2();
}

class C implements I{
  complex(){
    ...
    this.step1();
    ...
    this.step2();
  }
  step1(){
    ...
  }
  step2(){
    ...
  }
}

abstract class Decorator implements I{
  I wrapped;
  constructor(I obj){
    this.wrapped = obj;
  }
  complex(){
    this.wrapped.complex();
  }
  step1(){
    this.wrapped.step1();
  }
  step2(){
    this.wrapped.step2();
  }
}

class ConcreteDecorator extends Decorator{
  constructor(I obj){
    super(obj);
  }
  step2(){
    ... // customizing step2()
  }
}

Now if I try to create object of the decorated class:

x = new C();
y = new ConcreteDecorator(x);
y.complex();

I expect the complex() method to be executed form the wrapped core object, while using the overridden step2() method from decorator. But it does not work this way as the complex() method in abstract decorator directly calls the method on core object which indeed skips the overridden step2() in decorator.

Could this functionality be implemented using Decorator design pattern at all? If yes how, and if not what is the appropriate design pattern for tackling this problem.

Thanks.