The idea is to split strings into a words, but if there is some groups of characters withing quotes or double quotes it's considered to be a single term.

For example: `Multiple "texts to be found" and also 'this one' at least` =>["Multiple", "texts to be found", "and", "also", "this one",  "at", "least"].

So I`m using finite state machine. Each letter read generates an event, which depending on a current state, move to new state and performs some action. The map of state-event transitions is presented in the variable const fsm.

const testString1 = `Some text in "qoutes" to be found`;
const testString2 = `Some "complex text" to be found`;
const testString3 = `Multiple "textes to be found" and 'also' "this one" at least`;
const testString4 = `Edge case when "Double are around 'single'"`;

const states = Object.freeze({
  "readString": "readString",
  "readDoubleQuoted": "readDoubleQuoted",
  "readSingleQuoted": "readSingleQuoted"
});

const actions = Object.freeze({
  "saveChar": "saveChar",
  "storeString": "storeString",
  "storeSpecial": "storeSpecial"
});

const events = {
  doubleQuote: "\"",
  singleQuote: "'",
  space: " ",
  other: "*",
  end: ":("
}

const fsm = {
  [states.readString]: {
    [events.doubleQuote]: {
      state: states.readDoubleQuoted,
      action: actions.storeString
    },
    [events.singleQuote]: {
      state: states.readSingleQuoted,
      action: actions.storeString
    },
    [events.space]: {
      state: states.readString,
      action: actions.storeString
    },
    [events.other]: {
      state: states.readString,
      action: actions.saveChar
    },
    [events.end]: {
      state: null,
      action: actions.storeString
    }
  },
  [states.readDoubleQuoted]: {
    [events.doubleQuote]: {
      state: states.readString,
      action: actions.storeSpecial
    },
    [events.other]: {
      state: states.readDoubleQuoted,
      action: actions.saveChar
    },
    [events.end]: {
      state: null,
      action: actions.storeSpecial
    }
  },
  [states.readSingleQuoted]: {
    [events.singleQuote]: {
      state: states.readString,
      action: actions.storeSpecial
    },
    [events.other]: {
      state: states.readSingleQuoted,
      action: actions.saveChar
    },
    [events.end]: {
      state: null,
      action: actions.storeSpecial
    }
  }
}

function processString(str) {
  let buffer = [];
  let strings = [];
  let specials = [];
  let currentState = "readString";


  for (let i = 0; i < str.length; i++) {
    const char = str[i];
    const charKey = charToEvent(char);
    const transition = fsm[currentState][charKey] || fsm[currentState][events.other];

    handleStringAction(transition.action, char, buffer, strings, specials);
    currentState = transition.state;
  }

  const lastTransition = fsm[currentState][events.end];
  handleStringAction(lastTransition.action, "", buffer, strings, specials)

  return [strings, specials];
}

function charToEvent(char) {
  if (char === events.singleQuote) {
    return events.singleQuote;
  }
  if (char === events.doubleQuote) {
    return events.doubleQuote;
  }
  if (char === events.space) {
    return events.space;
  }
  return events.other;
}

function handleStringAction(action, char, buffer, strings, specials) {
    switch (action) {
      case actions.storeString: {
        if (buffer.length > 0) {
          strings.push(buffer.join(""));
        }
        buffer.splice(0, buffer.length);
        break;
      }
      case actions.storeSpecial: {
        specials.push(buffer.join(""));
        buffer.splice(0, buffer.length);
        break;
      }
      case actions.saveChar: {
        buffer.push(char);
        break;
      }
      default: {
        throw new Error(`Not valid action ${action}`);
      }
    }
}

console.log(processString(testString1));
console.log(processString(testString2));
console.log(processString(testString3));
console.log(processString(testString4));