regex.🍇

🕊️ 🖼️ 🍇
    🖍️🆕isMatch👌
    🖍️🆕matchPosition🍬🔢
    🖍️🆕matchLength🍬🔢

    🆕 🍼isMatch👌 🍼matchPosition🍬🔢 🍼matchLength🍬🔢 🍇🍉
    🆕▶️📙 🍇
        👎 ➡️ 🖍️isMatch
        🤷 ➡️ 🖍️matchPosition
        🤷 ➡️ 🖍️matchLength
    🍉

    ❓👌 ➡️ 👌 🍇
        ↩️ isMatch
    🍉

    ❓🐽 ➡️ 🍬🔢 🍇
        ↩️ matchPosition
    🍉

    ❓📏 ➡️ 🍬🔢 🍇
        ↩️ matchLength
    🍉
🍉

📗 A Regular Expression Engine using Emoji Syntax 📗
🐇 🔭 🍇
    🖍️🆕OPEN_SET🔡 ⬅️ 🔤🍿🔤
    🖍️🆕CLOSE_SET🔡 ⬅️ 🔤🍆🔤
    🖍️🆕OPEN_GROUP🔡 ⬅️ 🔤🤜🔤
    🖍️🆕CLOSE_GROUP🔡 ⬅️ 🔤🤛🔤
    🖍️🆕ALTERNATE🔡 ⬅️ 🔤👐🔤
    🖍️🆕ZERO_TO_MANY🔡 ⬅️ 🔤🔘🔤
    🖍️🆕ONE_TO_MANY🔡 ⬅️ 🔤🍺🔤
    🖍️🆕ZERO_OR_ONE🔡 ⬅️ 🔤🍬🔤
    🖍️🆕ANY_CHARACTER🔡 ⬅️ 🔤⚪🔤
    🖍️🆕INPUT_START🔡 ⬅️ 🔤🍇🔤
    🖍️🆕INPUT_END🔡 ⬅️ 🔤🍉🔤
    🖍️🆕ESCAPE🔡 ⬅️ 🔤❌❌🔤
    🖍️🆕CLASS_WORD_ID🔡 ⬅️ 🔤🔡🔤
    🖍️🆕CLASS_WORD🍨🐚🔡🍆 ⬅️ 🎶🔤abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ🔤❗
    🖍️🆕CLASS_DIGIT_ID🔡 ⬅️ 🔤🔢🔤
    🖍️🆕CLASS_DIGIT🍨🐚🔡🍆 ⬅️ 🎶🔤0123456789🔤❗
    🖍️🆕CLASS_WHITESPACE_ID🔡 ⬅️ 🔤⚫🔤
    🖍️🆕CLASS_WHITESPACE🍨🐚🔡🍆 ⬅️ 🎶🔤 ❌r❌n❌t🔤❗
    🖍️🆕SPECIAL_CHARS🍨🐚🔡🍆

    🆕 🍇
        🍿
            OPEN_SET 
            CLOSE_SET 
            OPEN_GROUP 
            CLOSE_GROUP 
            ALTERNATE 
            ZERO_TO_MANY 
            ONE_TO_MANY 
            ZERO_OR_ONE
            ANY_CHARACTER
            INPUT_START
            INPUT_END
            ESCAPE
        🍆 ➡️ 🖍️SPECIAL_CHARS
    🍉

    📗 finds the first occurrence of the specified pattern in the specified string 📗
    ❗👀 pattern🔡 string🔡 ➡️ 🖼️ 🍇
        🎶pattern❗ ➡️ 🖍️🆕patternChars
        🎶string❗ ➡️ stringChars
        📏stringChars❓ ➡️ stringLength

        0 ➡️ 🖍️🆕matchPosition
        stringLength ➖ 1 ➡️ 🖍️🆕maxMatchPosition

        ↪️ 🐽patternChars 0❗ 🙌 INPUT_START 🍇
            0 ➡️ 🖍️maxMatchPosition
            🐨patternChars 0❗
        🍉

        🔁 
            matchPosition ◀️🙌 maxMatchPosition 🤝 
            matchPosition ◀️ stringLength
        🍇
            🔪👇 stringChars matchPosition 🤷 ❗ ➡️ substringChars
            👁️👇 patternChars substringChars 0 ❗ ➡️ result
            ↪️ 👌result❓ 🍇
                ↩️ 🆕🖼️ 👍 matchPosition 🍺📏result❓ ❗
            🍉
            matchPosition ⬅️➕ 1
        🍉

        ↩️ 🆕🖼️ 👎 🤷 🤷 ❗
    🍉

    📗
        Matches the specified pattern at the start of the specified string
        matchLength: the length of the match prior to this match
    📗
    ❗👁️ pattern🍨🐚🔡🍆 string🍨🐚🔡🍆 matchLength🔢 ➡️ 🖼️ 🍇
        ↪️ 📏pattern❓ 🙌 0 🍇
            ↩️ 🆕🖼️ 👍 0 matchLength ❗
        🍉 🙅↪️ 🐽pattern 0❗ 🙌 INPUT_END 🍇
            ↪️ 📏string❓ 🙌 0 🍇
                ↩️ 🆕🖼️ 👍 0 matchLength ❗
            🍉 🙅 🍇
                ↩️ 🆕🖼️ 👎 🤷 🤷 ❗
            🍉
        🍉 🙅↪️ 📏string❓ 🙌 0 🍇
            ↩️ 🆕🖼️ 👎 🤷 🤷 ❗
        🍉

        🍺🔫👇 pattern ❗ ➡️ result
        🐽result 0❗ ➡️ head
        🐽result 1❗ ➡️ operatorArray
        🔤🔤 ➡️ 🖍️🆕operator
        ↪️ ❎📏operatorArray❓ 🙌 0❗ 🍇
            🐽operatorArray 0❗ ➡️ 🖍️operator
        🍉
        🐽result 2❗ ➡️ rest

        ↪️ operator 🙌 ZERO_TO_MANY 🍇
            ↩️ 👓👇 pattern string matchLength 0 🤷❗
        🍉 🙅↪️ operator 🙌 ONE_TO_MANY 🍇
            ↩️ 👓👇 pattern string matchLength 1 🤷❗
        🍉 🙅↪️ operator 🙌 ZERO_OR_ONE 🍇
            ↩️ 👓👇 pattern string matchLength 0 1❗
        🍉 🙅↪️ 🆎👇 head❓ 🍇
            ↩️ 🆎👇 pattern string matchLength❗
        🍉 🙅↪️ 💼👇 head❓ 🍇
            💼👇pattern string❗ ➡️ unitMatches
            ↪️ unitMatches 🍇
                ↩️ 👁️👇 rest 🔪👇 string 1 🤷❗ matchLength ➕ 1❗
            🍉
        🍉

        ↩️ 🆕🖼️ 👎 🤷 🤷❗
    🍉

    📗
        Matches the specified pattern multiple times at the start of the specified string
        matchLength: the length of the match prior to this match
        minMatches: the minimum number of matches to allow
        maxMatches: the maximum number of matches to allow (inclusive)
    📗
    ❗👓 pattern🍨🐚🔡🍆 string🍨🐚🔡🍆 matchLength🔢 minMatches🔢 maxMatches🍬🔢 ➡️ 🖼️ 🍇
        🍺🔫👇 pattern ❗ ➡️ splitPattern
        🐽splitPattern 0❗ ➡️ head
        🐽splitPattern 2❗ ➡️ rest

        0 ➡️ 🖍️🆕matchedTimes
        👎 ➡️ 🖍️🆕discoveryDone

        🔁 
            ❎discoveryDone❗ 🤝
            matchedTimes ◀️ 📏string❓ 🤝
            🤜 
                maxMatches 🙌 🤷 👐 
                matchedTimes ◀️ 🍺maxMatches
            🤛
        🍇
            📋👇head matchedTimes➕1❗ ➡️ patternRepeated
            👁️👇 patternRepeated string matchLength❗ ➡️ result
            ↪️ 👌result❓ 🍇
                matchedTimes ⬅️➕ 1
            🍉 🙅 🍇
                👍 ➡️ 🖍️discoveryDone
            🍉
        🍉

        🔁 matchedTimes ▶️🙌 minMatches 🍇
            📋👇head matchedTimes❗ ➡️ patternRepeated
            👁️👇 🍪👇🍿patternRepeated rest🍆❗ string matchLength❗ ➡️ result
            ↪️ 👌result❓ 🍇
                ↩️ 🆕🖼️ 👍 0 matchLength❗
            🍉

            matchedTimes ⬅️➖ 1
        🍉

        ↩️ 🆕🖼️ 👎 🤷 🤷 ❗
    🍉

    📗 Joins multiple character arrays into a single character array 📗
    ❗🍪 strings🍨🐚🍨🐚🔡🍆🍆 ➡️ 🍨🐚🔡🍆 🍇
        🆕🔠❗ ➡️ builder
        🔂string strings🍇
            🔂char string🍇
                🐻builder char❗
            🍉
        🍉
        🔡builder❗ ➡️ fullString
        ↩️ 🎶fullString❗
    🍉

    📗 Splits a pattern into a head, operator, and the remainder 📗
    ❗🔫 pattern🍨🐚🔡🍆 ➡️ 🍨🐚🍨🐚🔡🍆🍆 🚧🚧 🍇
        🆕🍨🐚🔡🍆❗ ➡️ 🖍️🆕head
        🆕🍨🐚🔡🍆❗ ➡️ 🖍️🆕operator
        🆕🍨🐚🔡🍆❗ ➡️ 🖍️🆕rest
        -1 ➡️ 🖍️🆕restStartPosition
        🐽pattern 0❗ ➡️ firstChar

        ↪️ firstChar 🙌 OPEN_SET 🍇
            🍺🔍👇 pattern CLOSE_SET❓ ➕ 1 ➡️ 🖍️restStartPosition
            🔪👇pattern 0 restStartPosition❗ ➡️ 🖍️head
        🍉 🙅↪️ firstChar 🙌 OPEN_GROUP 🍇
            🍺🔍👇 pattern CLOSE_GROUP❓ ➕ 1 ➡️ 🖍️restStartPosition
            🔪👇pattern 0 restStartPosition❗ ➡️ 🖍️head
        🍉 🙅↪️ 🔽👇 firstChar❓ 👐 firstChar 🙌 ANY_CHARACTER 🍇
            1 ➡️ 🖍️restStartPosition
            🍿firstChar🍆 ➡️ 🖍️head
        🍉 🙅↪️ firstChar 🙌 ESCAPE 🍇
            2 ➡️ 🖍️restStartPosition
            🔪👇pattern 0 2❗ ➡️ 🖍️head
        🍉 🙅 🍇
            🚨🆕🚧🔤Unrecognized start of expression: 🧲firstChar🧲🔤❗
        🍉

        ↪️ restStartPosition ◀️ 📏pattern❓ 🤝 👷👇 🐽pattern restStartPosition❗ ❓ 🍇
            🐻operator 🐽pattern restStartPosition❗❗
            restStartPosition ⬅️➕ 1
        🍉

        🔪👇 pattern restStartPosition 🤷❗ ➡️ 🖍️rest

        ↩️ 🍿 head operator rest 🍆
    🍉

    📗 returns whether the character is an operator 📗
    ❓👷 char🔡 ➡️ 👌 🍇
        ↩️ ❎char 🙌 🔤🔤❗ 🤝 🐦🍿 ZERO_OR_ONE ONE_TO_MANY ZERO_TO_MANY 🍆 char❓
    🍉

    📗 Returns whether the pattern is a single "unit" 📗
    ❓💼 pattern🍨🐚🔡🍆 ➡️ 👌 🍇
        ↪️ 📏pattern❓ 🙌 0 🍇
            ↩️ 👎
        🍉

        🐽pattern 0❗ ➡️ firstChar
        ↩️ 🔽👇firstChar❓ 👐
            🍦👇pattern❓ 👐
            firstChar 🙌 ANY_CHARACTER 👐
            🧯👇pattern❓
    🍉

    📗 Matches the "unit" at the start of the string 📗
    ❗💼 pattern🍨🐚🔡🍆 string🍨🐚🔡🍆 ➡️ 👌 🍇
        🍺🔫👇 pattern❗ ➡️ parts
        🐽parts 0❗ ➡️ head
        🐽head 0❗ ➡️ firstChar

        ↪️ firstChar 🙌 ANY_CHARACTER 🍇
            ↩️ 📏string❓ ▶️ 0
        🍉 🙅↪️ 🔽👇firstChar❓ 🍇
            ↩️ firstChar 🙌 🐽string 0❗
        🍉 🙅↪️ 🧯👇head❓ 🍇
            ↩️ 🍺🧯👇head string❗
        🍉 🙅↪️ 🍦👇head❓ 🍇
            ↩️ 🍦👇head string❗
        🍉

        ↩️ 👎
    🍉

    📗 returns whether the pattern is a set 📗
    ❓🍦 pattern🍨🐚🔡🍆 ➡️ 👌 🍇

        ↩️ 📏pattern❓ ▶️ 0 🤝
            🐽pattern 0❗ 🙌 OPEN_SET 🤝
            🐽pattern 📏pattern❓➖1❗ 🙌 CLOSE_SET
    🍉

    📗 returns whether the given set pattern matches at the start of the string 📗
    ❗🍦 pattern🍨🐚🔡🍆 string🍨🐚🔡🍆 ➡️ 👌 🍇
        pattern ➡️ 🖍️🆕patternCopy
        💭 remove first and last character in pattern (start and end set chars)
        🐨patternCopy 0❗
        🐨patternCopy 📏patternCopy❓ ➖ 1❗

        ↩️ 🐦patternCopy 🐽string 0❗❓
    🍉

    📗 returns whether the character is a 'literal' (non-special) character 📗
    ❓🔽 char🔡 ➡️ 👌 🍇
        ↩️ ❎char 🙌 🔤🔤❗ 🤝 ❎🐦SPECIAL_CHARS char❓❗
    🍉

    📗 returns whether the pattern is an escape sequence 📗
    ❓🧯 pattern🍨🐚🔡🍆 ➡️ 👌 🍇
        ↩️ 📏pattern❓ ▶️ 0 🤝 🐽pattern 0❗ 🙌 ESCAPE
    🍉

    📗
        matches the specified escape sequence at the start of the string
        throws an error if unrecognized escape sequence detected
    📗
    ❗🧯 pattern🍨🐚🔡🍆 string🍨🐚🔡🍆 ➡️ 👌 🚧🚧 🍇
        🐽pattern 1❗ ➡️ escapeId
        🐽string 0❗ ➡️ char
        ↪️ escapeId 🙌 CLASS_WORD_ID 🍇
            ↩️ 🐦CLASS_WORD char❓
        🍉 🙅↪️ escapeId 🙌 CLASS_DIGIT_ID 🍇
            ↩️ 🐦CLASS_DIGIT char❓
        🍉 🙅↪️ escapeId 🙌 CLASS_WHITESPACE_ID 🍇
            ↩️ 🐦CLASS_WHITESPACE char❓
        🍉 🙅↪️ 🐦SPECIAL_CHARS escapeId❓ 🍇
            ↩️ escapeId 🙌 char
        🍉

        🔡👇 pattern❗ ➡️ patternString
        🚨🆕🚧🔤Unrecognized escape sequence: 🧲patternString🧲🔤❗
    🍉

    📗 returns whether the pattern is an alternate expression 📗
    ❓🆎 pattern🍨🐚🔡🍆 ➡️ 👌 🍇
        ↩️ 📏pattern❓ ▶️ 0 🤝
            🐽pattern 0❗ 🙌 OPEN_GROUP 🤝
            🐽pattern 📏pattern❓➖1❗ 🙌 CLOSE_GROUP 🤝
            🐦pattern ALTERNATE❓
    🍉

    📗 matches the alternate expression at the start of the string 📗
    ❗🆎 pattern🍨🐚🔡🍆 string🍨🐚🔡🍆 matchLength🔢 ➡️ 🖼️ 🍇
        🍺🔫👇pattern❗ ➡️ split
        🐽split 0❗ ➡️ head
        🐽split 2❗ ➡️ rest
        
        ⚔️👇head❗ ➡️ options
        🔂 option options 🍇
            👁️👇 🍪👇🍿option rest🍆❗ string matchLength ❗ ➡️ result
            ↪️ 👌result❓ 🍇
                ↩️ 🆕🖼️ 👍 0 📏result❓ ❗
            🍉
        🍉

        ↩️ 🆕🖼️ 👎 🤷 🤷❗
    🍉

    📗 splits all alternates in the expression into their own character array 📗
    ❗⚔️ pattern🍨🐚🔡🍆 ➡️ 🍨🐚🍨🐚🔡🍆🍆 🍇
        🔪👇 pattern 1 📏pattern❓➖2 ❗ ➡️ slice
        🔡👇 slice❗ ➡️ substring
        🔫substring ALTERNATE❗ ➡️ alternateStrings
        ↩️ 🐰alternateStrings 🍇 alternateString🔡 ➡️ 🍨🐚🔡🍆
            ↩️ 🎶alternateString❗
        🍉❗
    🍉

    📗 converts a char array into a string 📗
    ❗🔡 charArray🍨🐚🔡🍆 ➡️ 🔡 🍇
        🆕🔠❗ ➡️ builder
        🔂 char charArray 🍇
            🐻builder char❗
        🍉
        ↩️ 🔡builder❗
    🍉

    📗 Duplicates the char array multiple times into a single array 📗
    ❗📋 string🍨🐚🔡🍆 times🔢  ➡️ 🍨🐚🔡🍆 🍇
        🆕🍨🐚🍨🐚🔡🍆🍆❗ ➡️ 🖍️🆕strings
        🔂 i 🆕⏩ 0 times 1❗ 🍇
            🐻strings string❗
        🍉
        ↩️ 🍪👇strings❗
    🍉

    💭 TODO: contribute this back to Emojicode repository (array slice)
    📗 Returns a new list consisting of length elements beginning from the element at index from in this list. Complexity: O(n). 📗
    ❗🔪 list🍨🐚🔡🍆 from🔢 length🍬🔢 ➡️ 🍨🐚🔡🍆 🍇
        📏list❓ ➡️ 🖍️🆕end
        ↪️ ❎ length 🙌 🤷 ❗ 🤝 from ➕ 🍺length ◀️ 📏list❓ 🍇
            from ➕ 🍺length ➡️ 🖍️end
        🍉

        🆕🍨🐚🔡🍆▶️🐴 end ➖ from ❗ ➡️ 🖍️🆕output
        🔂 i 🆕⏩ from end 1 ❗ 🍇
            🐻output 🐽list i❗❗
        🍉
        ↩️ output
    🍉

    💭 TODO: contribute this back to Emojicode repository (array indexOf)
    📗
        Finds the first occurrences of element in this list. Search is performed in list order.

        Returns the index of the first occurrence or no value if search does not occur.
    📗
    ❓🔍 list🍨🐚🔡🍆 search🔡 ➡️ 🍬🔢 🍇
        0 ➡️ 🖍️🆕 index
        🔂 element list 🍇
            ↪️ element 🙌 search 🍇
                ↩️ index
            🍉
            index ⬅️➕ 1
        🍉
        ↩️ 🤷
    🍉
🍉

regexTests.🍇

📦 testtube 🏠
📜 🔤regex.🍇🔤

🏁 ➡️ 🔢 🍇
  ↩️ 👔🆕🧑‍🔬❗️❗️
🍉

🐇 🧑‍🔬 🧪 🍇
    ✒️ ❗️ 🏁 🍇
        🆕🔭❗ ➡️ regex

        💭 NO MATCH
        ❎👇
            👌👀regex 🔤abc🔤 🔤cba🔤❗❓ 
            🔤literal pattern should not match the reversed string🔤
        ❗
        ⛔👇
            🐽👀regex 🔤abc🔤 🔤cba🔤❗❓ 🙌 🤷
            🔤match failure should have no value for match index🔤
        ❗
        ⛔👇
            📏👀regex 🔤abc🔤 🔤cba🔤❗❓ 🙌 🤷
            🔤match failure should have no value for match length🔤
        ❗

        💭 LITERAL PATTERN - FULL STRING MATCH
        ⛔👇
            👌👀regex 🔤abc🔤 🔤abc🔤❗❓ 
            🔤literal pattern should match the exact string🔤
        ❗
        🔢👇
            🍺🐽👀regex 🔤abc🔤 🔤abc🔤❗❓
            0
            🔤literal pattern should be found at the correct index🔤
        ❗
        🔢👇
            🍺📏👀regex 🔤abc🔤 🔤abc🔤❗❓
            3
            🔤literal pattern should be have correct match length🔤
        ❗

        💭 LITERAL PATTERN - SUBSTRING MATCH
        ⛔👇
            👌👀regex 🔤abc🔤 🔤     abc     🔤❗❓ 
            🔤literal substring pattern should match the exact string at any position🔤
        ❗
        🔢👇
            🍺🐽👀regex 🔤abc🔤 🔤     abc     🔤❗❓
            5
            🔤literal substring pattern should be found at the correct index🔤
        ❗
        🔢👇
            🍺📏👀regex 🔤abc🔤 🔤     abc     🔤❗❓
            3
            🔤literal substring pattern should be have correct match length🔤
        ❗

        💭 PREFIX MATCH (🍇)
        ⛔👇
            👌👀regex 🔤🍇abc🔤 🔤abc     🔤❗❓ 
            🔤prefix pattern should match the string starting with that pattern🔤
        ❗
        ❎👇
            👌👀regex 🔤🍇abc🔤 🔤     abc     🔤❗❓ 
            🔤prefix pattern should not match if string does not start with that pattern🔤
        ❗
        🔢👇
            🍺🐽👀regex 🔤🍇abc🔤 🔤abc     🔤❗❓
            0
            🔤prefix pattern should be found at the correct index🔤
        ❗
        🔢👇
            🍺📏👀regex 🔤🍇abc🔤 🔤abc     🔤❗❓
            3
            🔤prefix pattern should be have correct match length🔤
        ❗

        💭 SUFFIX MATCH (🍉)
        ⛔👇
            👌👀regex 🔤abc🍉🔤 🔤     abc🔤❗❓ 
            🔤suffix pattern should match the string ending with that pattern🔤
        ❗
        ❎👇
            👌👀regex 🔤abc🍉🔤 🔤     abc     🔤❗❓ 
            🔤suffix pattern should not match if string does not end with that pattern🔤
        ❗
        🔢👇
            🍺🐽👀regex 🔤abc🍉🔤 🔤     abc🔤❗❓
            5
            🔤suffix pattern should be found at the correct index🔤
        ❗
        🔢👇
            🍺📏👀regex 🔤abc🍉🔤 🔤     abc🔤❗❓
            3
            🔤suffix pattern should be have correct match length🔤
        ❗

        💭 ZERO OR ONE / OPTIONAL (🍬)
        ⛔👇
            👌👀regex 🔤ab🍬c🔤 🔤abc🔤❗❓ 
            🔤optional pattern should match the string with that pattern🔤
        ❗
        ⛔👇
            👌👀regex 🔤ab🍬c🔤 🔤ac🔤❗❓ 
            🔤optional pattern should match the string without that pattern🔤
        ❗
        ❎👇
            👌👀regex 🔤ab🍬c🔤 🔤abbc🔤❗❓ 
            🔤optional pattern should not match if string has too many of the optional🔤
        ❗

        💭 ZERO OR MORE (🔘)
        ⛔👇
            👌👀regex 🔤ab🔘c🔤 🔤abc🔤❗❓ 
            🔤zero or more pattern should match the string with that pattern🔤
        ❗
        ⛔👇
            👌👀regex 🔤ab🔘c🔤 🔤ac🔤❗❓ 
            🔤zero or more pattern should match the string without that pattern🔤
        ❗
        ⛔👇
            👌👀regex 🔤ab🔘c🔤 🔤abbbbbbbbbbbbbbbbbbbbbc🔤❗❓ 
            🔤zero or more pattern should match if string has multiple of the optional🔤
        ❗

        💭 ONE OR MORE (🍺)
        ⛔👇
            👌👀regex 🔤ab🍺c🔤 🔤abc🔤❗❓ 
            🔤one or more pattern should match the string with that pattern🔤
        ❗
        ❎👇
            👌👀regex 🔤ab🍺c🔤 🔤ac🔤❗❓ 
            🔤one or more pattern should not match the string without that pattern🔤
        ❗
        ⛔👇
            👌👀regex 🔤ab🍺c🔤 🔤abbbbbbbbbbbbbbbbbbbbbc🔤❗❓ 
            🔤one or more pattern should match if string has multiple of the optional🔤
        ❗

        💭 SETS (🍿ABC🍆)
        ⛔👇
            👌👀regex 🔤a🍿ABC🍆c🔤 🔤aAc🔤❗❓ 
            🔤set pattern should match the string with any unit in the set🔤
        ❗
        ⛔👇
            👌👀regex 🔤a🍿ABC🍆c🔤 🔤aBc🔤❗❓ 
            🔤set pattern should match the string with any unit in the set🔤
        ❗
        ⛔👇
            👌👀regex 🔤a🍿ABC🍆c🔤 🔤aCc🔤❗❓ 
            🔤set pattern should match the string with any unit in the set🔤
        ❗
        ❎👇
            👌👀regex 🔤a🍿ABC🍆c🔤 🔤ac🔤❗❓ 
            🔤set pattern should not match the string without a unit from the set🔤
        ❗
        ❎👇
            👌👀regex 🔤a🍿ABC🍆c🔤 🔤aDc🔤❗❓ 
            🔤set pattern should not match the string with a unit not in the set🔤
        ❗
        ❎👇
            👌👀regex 🔤a🍿ABC🍆c🔤 🔤aAAAAAAAAAAAc🔤❗❓ 
            🔤set pattern should not match if string has multiple of the set unit🔤
        ❗
        ❎👇
            👌👀regex 🔤a🍿ABC🍆c🔤 🔤aABCc🔤❗❓ 
            🔤set pattern should not match if string has multiple of the set unit🔤
        ❗

        💭 ALTERNATES (🤜AB👐C🤛)
        ⛔👇
            👌👀regex 🔤a🤜AB👐C🤛c🔤 🔤aABc🔤❗❓ 
            🔤alternate pattern should match the string with any pattern in the alternate list🔤
        ❗
        ⛔👇
            👌👀regex 🔤a🤜AB👐C🤛c🔤 🔤aCc🔤❗❓ 
            🔤alternate pattern should match the string with any pattern in the alternate list🔤
        ❗
        ❎👇
            👌👀regex 🔤a🤜AB👐C🤛c🔤 🔤ac🔤❗❓ 
            🔤alternate pattern should not match the string without a pattern from the alternate list🔤
        ❗
        ❎👇
            👌👀regex 🔤a🤜AB👐C🤛c🔤 🔤aAc🔤❗❓ 
            🔤alternate pattern should not match the string with a pattern not in the alternate list🔤
        ❗
        ❎👇
            👌👀regex 🔤a🤜AB👐C🤛c🔤 🔤aCCCCCCCCCCc🔤❗❓ 
            🔤alternate pattern should not match if string has multiple of the alternate list🔤
        ❗
        ❎👇
            👌👀regex 🔤a🤜AB👐C🤛c🔤 🔤aABCc🔤❗❓ 
            🔤alternate pattern should not match if string has multiple of the alternate list🔤
        ❗

        💭 ANY CHARACTER (⚪)
        🔂 char 🎶
            🔤b 👪0👍~🔤
        ❗ 🍇
            ⛔👇
                👌👀regex 🔤a⚪c🔤 🔤a🧲char🧲c🔤❗❓ 
                🔤any character token should match any character (🧲char🧲)🔤
            ❗
        🍉
        ❎👇
            👌👀regex 🔤a⚪c🔤 🔤ac🔤❗❓
            🔤any character token should not match no character🔤
        ❗

        💭 ESCAPE (❌)
        🔂 char 🎶
            🔤🍿🍆🤜🤛👐🔘🍺🍬⚪🍇🍉❌❌🔤
        ❗ 🍇
            ⛔👇
                👌👀regex 🔤a❌❌🧲char🧲c🔤 🔤a🧲char🧲c🔤❗❓ 
                🔤a pattern escaping a special character should match that literal character (🧲char🧲)🔤
            ❗
        🍉
💭🔜 
        💭 💭 TODO: There isn't a way to test this since I declared it not-error-prone. When I refactor, I will need to make sure this test case works as expected.
        💭 🍇 ➡️ ⚪ 🚧🚧
        💭     ↩️ 👀regex 🔤a❌❌ c🔤 🔤a c🔤❗
        💭 🍉 ➡️ invalidCall
        💭 🆗 ⁉️invalidCall❗ 🍇
        💭     🙁👇 🔤providing an invalid escape sequence should throw an error🔤 ❗
        💭 🍉 🙅 error 🍇
        💭     ✅👇 🔤providing an invalid escape sequence should throw an error🔤 ❗
        💭 🍉
🔚💭 

        💭 WORD CHARACTER CLASS (❌🔡)
        🔂 char 🎶
            🔤abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ🔤
        ❗ 🍇
            ⛔👇
                👌👀regex 🔤a❌❌🔡c🔤 🔤a🧲char🧲c🔤❗❓ 
                🔤a pattern including a word character escape sequence should allow any word character (🧲char🧲)🔤
            ❗
        🍉
        🔂 char 🎶
            🔤0123456789 ❌t❌r❌n~👍👪,.-🔤
        ❗ 🍇
            ❎👇
                👌👀regex 🔤a❌❌🔡c🔤 🔤a🧲char🧲c🔤❗❓ 
                🔤a pattern including a word character escape sequence should not allow a character not included in the class (🧲char🧲)🔤
            ❗
        🍉

        💭 DIGIT CHARACTER CLASS (❌🔢)
        🔂 char 🎶
            🔤0123456789🔤
        ❗ 🍇
            ⛔👇
                👌👀regex 🔤a❌❌🔢c🔤 🔤a🧲char🧲c🔤❗❓ 
                🔤a pattern including a digit character escape sequence should allow any digit character (🧲char🧲)🔤
            ❗
        🍉
        🔂 char 🎶
            🔤abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ ❌t❌r❌n~👍👪,.-🔤
        ❗ 🍇
            ❎👇
                👌👀regex 🔤a❌❌🔢c🔤 🔤a🧲char🧲c🔤❗❓ 
                🔤a pattern including a digit character escape sequence should not allow a character not included in the class (🧲char🧲)🔤
            ❗
        🍉
        
        💭 WHITESPACE CHARACTER CLASS (❌⚫)
        🔂 char 🎶
            🔤 ❌r❌n❌t🔤
        ❗ 🍇
            ⛔👇
                👌👀regex 🔤a❌❌⚫c🔤 🔤a🧲char🧲c🔤❗❓ 
                🔤a pattern including a digit character escape sequence should allow any digit character (🧲char🧲)🔤
            ❗
        🍉
        🔂 char 🎶
            🔤abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789~👍👪,.-🔤
        ❗ 🍇
            ❎👇
                👌👀regex 🔤a❌❌⚫c🔤 🔤a🧲char🧲c🔤❗❓ 
                🔤a pattern including a digit character escape sequence should not allow a character not included in the class (🧲char🧲)🔤
            ❗
        🍉

        💭 TORTURE TEST
        🔤🍇he🤜❌❌🔡👐❌❌🔢👐❌❌🍇🤛🔘o a🤜cat👐dog🤛🍺❌❌⚫🍬b🍺R🔘❌❌🔡❌❌🔢🍺❌❌🍉🍿0123🍆⚪🔘AAA🍉🔤 ➡️ pattern
        🔤he🍇0eo adogcatdogdog bbbbbbbbbbbbj009🍉2~~AAA🔤 ➡️ string
        👀regex pattern string❗ ➡️ result
        ⛔👇 👌result❓ 🔤torture test pattern/input should match🔤❗ 
    🍉
🍉

syntax.md

EmojiRegex Syntax

Feature	EmojiRegex	Traditional Regex
Sets	🍿ABC🍆	[ABC]
Alternates	🤜A👐B🤛	A|B
Zero or More	A🔘	A*
One or More	A🍺	A+
Zero or One (optional)	A🍬	A?
Any Character	⚪	.
Input Start	🍇	^
Input End	🍉	$
Escaping	❌	\
any 'word' character	❌🔡	\w
any 'digit' character	❌🔢	\d
any 'whitespace' character	❌⚫	\s

A HUGE thanks to "clumsy computer" on YouTube for his live-stream implementation of a regex engine in Python. I gained the understanding, coded along with him in TypeScript, got it working the way I wanted to, then translated it into EmojiCode.