Thinking outside the box - Am I doing it right? I keep hearing that thinking outside the box is a goal worth achieving, but how can I tell if I'm successfully doing it?

To solve this dilemma I have already wrote a Brainwave-to-ASCII-translator which in theory should produce outputs like

                    #
   +------------+   #
   |   thinking |   #
   |            |   #
   +------------+   #
                    #


or

                   #
 +------+          #
 |      | thinking #
 |      |          #
 |      |          #
 +------+          #
                   #


which make it fairly easy to tell whether one is thinking outside the box or not. (The # are not part of the output and represent new lines.)

However, due to a bug sometimes only a smaller section of the output is returned:

   |         |         #
   +---------+         #
    thinking           #




        #
       +#
       |#
inking |#




    #
    #


The Task

Please help me to automatically classify the Brainwave-to-ASCII-translator output by writing a program or function which reads an ascii-reprensentation and returns whether thinking is in the box, outside of it or it could not tell from the input.

Input

A set of same-length strings either as a list or delimited by newlines containing


the string thinking or valid pre- or suffixes thereof
the characters +-| forming a rectangular box or valid parts of it
spaces
NO #, those are only included in the challenge to mark the ends of the input lines.


Output


a truthy value if thinking is outside the box
a falsy value if thinking is in the box 
a distinct third maybe value if it can not be determined from the input whether thinking is in the box or not


Examples

Truthy:

                   #
 +------+          #
 |      | thinking #
 |      |          #
 |      |          #
 +------+          #
                   #




   |         |         #
   +---------+         #
    thinking           #




        #
       +#
       |#
       |#
inking |#




thinking #
-------+ #




 ++ # (thinking is not in the box, so it must be outside)
 ++ # (this is also the smallest possible box)




+ #
 t#


 

+----+# (The box is not wide enough to contain "thinking")




---# (The box is not high enough to contain "thinking")
---#


As string input:

"                   \n +------+          \n |      | thinking \n |      |          \n |      |          \n +------+          \n                   "
"   |         |         \n   +---------+         \n    thinking           "
"        \n       +\n       |\n       |\ninking |"
"thinking \n-------+ "
" ++ \n ++ "
"+ \n t"
"+----+"
"---\n---"
"g++"
"k\n+"


Falsy:

                    #
   +------------+   #
   |   thinking |   #
   |            |   #
   +------------+   #
                    #




  +---------------#
  |               #
  |               #
  |   thinking    #




      | #
king  | #
------+ #




+---#
|thi#
+---#




-#
n#
-#


As string input:

"                    \n   +------------+   \n   |   thinking |   \n   |            |   \n   +------------+   \n                    "
"  +---------------\n  |               \n  |               \n  |   thinking    "
"      | \nking  | \n------+ "
"+---\n|thi\n+---"
"-\nn\n-"


Maybe:

thinking#




g|#




think#
-----#




|          |# (box large enough to possibly contain the string)
|          |#




   +--#
   |  #




# (empty input)


As string input:

"thinking"
"g|"
"|t"
"-\ni"
"h\n-"
"think\n-----"
"|          |\n|          |"
"   +--\n   |  "
""


Rules


This is code-golf, so try to use as few bytes as possible.
The maybe value can be chosen freely as long as it's different from the truthy/falsy value and is the same for all maybe-inputs. It can also be an error.
You can assume that the input is always valid (eg. contains no other chars than +-ghiknt|, no more than one box, ...).
Javascript (ES6), 274 263 bytes

f=(a,b=(b,c="")=&gt;a=a.replace(b,c),c=b=&gt;b.test(`,${a},`))=&gt;(b(/\w+/,5),b(/\+/g,1),b(/\-/g,2),b(/\|/g,3),b(/\n/g,4),c(/[13][2 ]{0,7}[13]|[12] *4 *[12]/)||(b(/ /g),b(/43+(?=4)/g),!c(/353|24542|12+435|21453|35412|5342+1/)&amp;&amp;(!c(/^([^1]*|([^15]*1){1,2}[^15]*)$/)||-1)))


The function f returns true, false, or -1 as its "maybe" value. It should be called with one argument: the input. The other two parameters only exist to shorten the code.

Here's a less golfed version with comments:

var f = (input) =&gt; {
    var replace = (re, s) =&gt; input = input.replace(re, s);
    var test = re =&gt; re.test(input);

    /*
        Replace some "special" characters with ones that are shorter to put in a regex.
        "+" --&gt; "1"
        "-" --&gt; "2"
        "|" --&gt; "3"
        "\n" --&gt; ","
    */
    replace(/\+/g,1);
    replace(/\-/g,2);
    replace(/\|/g,3);
    replace(/\n/g,',');

    /*
        Shorten the word, if there is one, to just a single character "a".
    */
    replace(/[a-z]+/g,'a');

    /*
        Append a newline to the beginning and end of the input.
    */
    input = ','+input+',';

    /*
        Test the size of the box. These are the cases covered:
        /[13][2 ]{0,7}[13]/ : A horizontal edge or middle section has an inner width of fewer than 8 characters.
        /[12] *, *[12]/     : There are two horizontal edges in a row, with no space between.

        If either of these match, the word must be outside of the box. Return the truthy value (true).
    */
    if (test(/[13][2 ]{0,7}[13]|[12] *, *[12]/)) return true;

    /*
        Remove any spacing from the input. It it unnecessary from this point onwards.
    */
    replace(/ /g,'');

    /*
        Remove any lines with only vertical bars. These are also unnecessary.
    */
    replace(/,3+(?=,)/g,'');

    /*
        Edge / corner cases (heh). These are the cases covered:
        /3a3/    : two vertical bars with the word between.
        /2,a,2/  : two horizontal bars with the word between.
        /12+,3a/ : word inside the top left corner.
        /21,a3/  : word inside the top right corner.
        /3a,12/  : word inside the bottom left corner.
        /a3,2+1/ : word inside the bottom right corner.

        If any of these match, the word is inside the box. Return the falsy value (false).
    */
    if (test(/3a3|2,a,2|12+,3a|21,a3|3a,12|a3,2+1/)) return false;

    /*
        "Maybe" cases. These are the cases covered:
        /^[^1]*$/                : Input contains no corners, and may or may not contain a word.
        /^([^1a]*1){1,2}[^1a]*$/ : Input contains 1 or 2 corners, and no word.

        If either of these match, assuming the previous test cases have not been hit,
        we cannot tell if the word is inside or outside the box. Return the maybe value (-1).
    */
    if (test(/^([^1]*|([^1a]*1){1,2}[^1a]*)$/)) return -1;

    /*
        If none of the previous cases matched, the word must be outside of the box. Return the truthy value (true).
    */
    return true;
};


Had a lot of fun with this one. Thanks!

Edit: Saved 6 bytes thanks @L. Serné by modifying b to use a default argument, saving 3 bytes, and changing [a-z] to \w, saving 3 more bytes. Also saved 5 more bytes by making the word replacement non-global, saving 1 byte, and changing "a" to 5 and "," to 4, saving 4 bytes.