There, I broke it (with scissors) Challenge

Given a string describing a cutting rule and another string, cut parts out of the second string using the rule described by the first string.

Both strings will consist of letters a-z or A-Z, whichever one you choose (they don't have to be represented the same way). The way the second string is to be modified is described below:

Algorithm

Take the first string and imagine filling in the gaps between non-adjacent (increasing) letters with =; for example, abcfg => abc==fg. Then, line up the two strings and return all characters from the first string that aren't above an equal sign. For example, given abcfg and qrstuvw as inputs:

qrstuvw - Modify
abc==fg - Modifier

qrs--vw -&gt; qrsvw


If the modifier is shorter after filling with equal signs, all trailing characters in the second string should be included. If the modifier is longer, the trailing characters are ignored.

The modifier isn't guaranteed to be sorted.

Test Cases

abcfg, qrstuvw -&gt; qrsvw
abqrs, qwertyuiopasdfghjklzxcvbnm -&gt; qwjklzxcvbnm
za, qr -&gt; qr
azazaz, qwertyuioplkjhgfdsazxcvbnmnbvcxzasdfghjklpoiuytrewq -&gt; qmn


Reference Implementation (used to generate test cases) -> TIO

Rules


Standard Loopholes Apply
You may take input as two strings, two lists of characters, a matrix of characters, etc. (any other reasonable format is acceptable)
You may output as a string or a list of characters (or some other standard format for strings)
This is code-golf, so the shortest answer in bytes in each language is declared the winner for its language. No answer will be accepted.
Either string may be empty.


Happy Golfing!

Inspired by Kevin Cruijssen's recent two challenges, "There, I fixed it (with tape/rope)"
JavaScript (ES6), 81 80 bytes
Takes input in currying syntax (modify)(modifier).

s=&gt;g=([c,...a],d=i=0,x=s[k=parseInt(c,36),i+=c?d&amp;&amp;(k-d+26)%26:1])=&gt;x?x+g(a,k):''

Try it online!
Commented
s =&gt;                       // outer function, taking the string s to modify
  g = (                    // recursive inner function g(), taking:
    [c, ...a],             //   c = current modifier character; a[] = remaining characters
    d = i = 0,             //   d = code of previous modifier character; i = pointer in s
    x = s[                 //   x = i-th character of s
      k = parseInt(c, 36), //     k = code of the current modifier character in [10..35]
      i += c ?             //     update i; if c is defined:
        d &amp;&amp;               //       if d = 0, let i unchanged
        (k - d + 26) % 26  //       otherwise, add the difference between k and d (mod 26)
      :                    //     else:
        1                  //       just pick the next character by adding 1
    ]                      //   end of character lookup in s
  ) =&gt;                     //
    x ?                    // if x is defined:
      x + g(a, k)          //   append x and do a recursive call to g()
    :                      // else:
      ''                   //   stop recursion