spanish.json

{
  "'{0}' found at index {1}": "'{0}' encontrado en la posicion {1}",
  "(*ANY) makes it so that any unicode newline character or sequence thereof counts as a line break.": "(*ANY) makes it so that any unicode newline character or sequence thereof counts as a line break.",
  "(*ANYCRLF) makes it so that either a carriage return character or a line feed character, or the two in sequence are considered a line break.": "(*ANYCRLF) makes it so that either a carriage return character or a line feed character, or the two in sequence are considered a line break.",
  "(*CR) makes it so that only a carriage return character is considered a line break.": "(*CR) makes it so that only a carriage return character is considered a line break.",
  "(*CRLF) makes it so that only a carriage return character followed by a line feed character is considered a line break. Common in Windows documents.": "(*CRLF) makes it so that only a carriage return character followed by a line feed character is considered a line break. Common in Windows documents.",
  "(*FAIL) or (*F) is a synonym for (?!), and it allows you to force a matching failure at a specific point in the regex.": "(*FAIL) or (*F) is a synonym for (?!), and it allows you to force a matching failure at a specific point in the regex.",
  "(*LF) makes it so that only a line feed character is considered a line break. Common in UNIX documents.": "(*LF) makes it so that only a line feed character is considered a line break. Common in UNIX documents.",
  "(*LIMIT_MATCH=x) where x is the number of times the regex engine is allowed to call match(). This user set limit cannot be increased past the compile time value or the default, however it can be restricted.": "(*LIMIT_MATCH=x) where x is the number of times the regex engine is allowed to call match(). This user set limit cannot be increased past the compile time value or the default, however it can be restricted.",
  "(*LIMIT_RECURSION=d) at the start of a pattern will limit the regex engine to 'd' number of recursions when matching. This user set limit cannot be increased past the compile time value or the default, however it can be restricted.": "(*LIMIT_RECURSION=d) at the start of a pattern will limit the regex engine to 'd' number of recursions when matching. This user set limit cannot be increased past the compile time value or the default, however it can be restricted.",
  "(*MARK:NAME) or (*:NAME) is used to track how a match was arrived at. Name is always required, but it doesn't need to be unique. When used in conjunction with the /K modifier, pcretest can return the mark together with a successful match.": "(*MARK:NAME) or (*:NAME) is used to track how a match was arrived at. Name is always required, but it doesn't need to be unique. When used in conjunction with the /K modifier, pcretest can return the mark together with a successful match.",
  "(*PRUNE) or (*PRUNE:NAME) will cause the regex to exit if it tries to backtrack past its position. This is useful when looking to cut down on backtracking at specific points in the regex. The example above would normally match both terms but due to (*PRUNE) the second alternative is not acted on.": "(*PRUNE) or (*PRUNE:NAME) will cause the regex to exit if it tries to backtrack past its position. This is useful when looking to cut down on backtracking at specific points in the regex. The example above would normally match both terms but due to (*PRUNE) the second alternative is not acted on.",
  "(*SKIP) or (*SKIP:NAME) will cause the regex to give up on the current match if it tries to backtrack past its position. This is useful when looking to cut down on backtracking at specific points in the regex.": "(*SKIP) or (*SKIP:NAME) will cause the regex to give up on the current match if it tries to backtrack past its position. This is useful when looking to cut down on backtracking at specific points in the regex.",
  "(*THEN) or (*THEN:NAME) allows one to cut down on backtracking within an alternation. It won't allow regex to backtrack past its position, and it will give up matching the current alternation.": "(*THEN) or (*THEN:NAME) allows one to cut down on backtracking within an alternation. It won't allow regex to backtrack past its position, and it will give up matching the current alternation.",
  "(except for line terminators)": "(except for line terminators)",
  "{1} — Matches between {2} and {3} times, {4} {5}": "{1} — Matches between {2} and {3} times, {4} {5}",
  "{1} — Matches exactly {2} {3} {4}": "{1} — Matches exactly {2} {3} {4}",
  "{1} Alternative": "{1} Alternative",
  "{1} and {2} are also available with the use of '{3}'": "{1} and {2} are also available with the use of '{3}'",
  "{1} Capturing Group": "{1} Capturing Group",
  "{1} checks whether the {2} capturing group matched when it was last attempted": "{1} checks whether the {2} capturing group matched when it was last attempted",
  "{1} checks whether the {2} subroutine matches": "{1} checks whether the {2} subroutine matches",
  "{1} checks whether the whole pattern matches": "{1} checks whether the whole pattern matches",
  "{1} match": "{1} encuentro",
  "{1} matches": "{1} encuentros",
  "{1} modifier:": "{1} modificador:",
  "{1} step": "{1} step",
  "{1} steps": "{1} steps",
  "{1} upvotes, {2} downvotes ({3}% like it)": "{1} upvotes, {2} downvotes ({3}% like it)",
  "{1}, matches any position": "{1}, matches any position",
  "{1}. A {2} followed by a letter with no special meaning is faulted": "{1}. A {2} followed by a letter with no special meaning is faulted",
  "{1}. A dot won't match {2}": "{1}. A dot won't match {2}",
  "{1}. All matches (don't return after first match)": "{1}. All matches (don't return after first match)",
  "{1}. Case insensitive match (ignores case of {2})": "{1}. Case insensitive match (ignores case of {2})",
  "{1}. Case sensitive match": "{1}. Case sensitive match",
  "{1}. Causes {2} and {3} to match begin/end of string": "{1}. Causes {2} and {3} to match begin/end of string",
  "{1}. Causes {2} and {3} to match the begin/end of each line (not only begin/end of string)": "{1}. Causes {2} and {3} to match the begin/end of each line (not only begin/end of string)",
  "{1}. Dot matches newline characters": "{1}. Dot matches newline characters",
  "{1}. Enable all unicode features and interpret all unicode escape sequences as such": "{1}. Enable all unicode features and interpret all unicode escape sequences as such",
  "{1}. Force the a dollar sign, {2}, to always match end of the string, instead of end of the line. This option is ignored if the {3}-flag is set": "{1}. Force the a dollar sign, {2}, to always match end of the string, instead of end of the line. This option is ignored if the {3}-flag is set",
  "{1}. Force the escape sequences {2}, {3}, {4}, {5}, {6}, {7}, {8} and {9} to perform ASCII-only matching instead of full Unicode matching": "{1}. Force the escape sequences {2}, {3}, {4}, {5}, {6}, {7}, {8} and {9} to perform ASCII-only matching instead of full Unicode matching",
  "{1}. Force the pattern to only match consecutive matches from where the previous match ended.": "{1}. Force the pattern to only match consecutive matches from where the previous match ended.",
  "{1}. Make {2}, {3}, {4}, {5}, {6}, {7}, {8} and {9} perform matching with Unicode semantic (redundant in Python 3)": "{1}. Make {2}, {3}, {4}, {5}, {6}, {7}, {8} and {9} perform matching with Unicode semantic (redundant in Python 3)",
  "{1}. Pattern is forced to {2}": "{1}. Pattern is forced to {2}",
  "{1}. Pattern strings are treated as {2}. Also causes escape sequences to match unicode characters": "{1}. Pattern strings are treated as {2}. Also causes escape sequences to match unicode characters",
  "{1}. Spaces and text after a {2} in the pattern are ignored": "{1}. Spaces and text after a {2} in the pattern are ignored",
  "{1}. The match becomes greedy by default": "{1}. The match becomes greedy by default",
  "{1}. The match becomes lazy by default. Now a {2} following a quantifier makes it greedy": "{1}. The match becomes lazy by default. Now a {2} following a quantifier makes it greedy",
  "{1}. Whitespaces and {2} in the pattern are treated literally": "{1}. Whitespaces and {2} in the pattern are treated literally",
  "`(?R1)` checks if a call to capture group 1 was made, which will return false the first time it is encountered because the regex engine is simply parsing capture group one.": "`(?R1)` checks if a call to capture group 1 was made, which will return false the first time it is encountered because the regex engine is simply parsing capture group one.",
  "^ and $ match start/end of line": "^ and $ match start/end of line",
  "$ matches only end of pattern": "$ matches only end of pattern",
  "3 or more of a": "3 or more of a",
  "A case insensitive match is performed, meaning capital letters will be matched by non-capital letters and vice versa.": "A case insensitive match is performed, meaning capital letters will be matched by non-capital letters and vice versa.",
  "A character except: a, b or c": "A character except: a, b or c",
  "A character in the range: a-z": "A character in the range: a-z",
  "A character in the range: a-z or A-Z": "A character in the range: a-z or A-Z",
  "A character not in the range: a-z": "A character not in the range: a-z",
  "a line": "a line",
  "A lookbehind assertion has to be fixed width": "A lookbehind assertion has to be fixed width",
  "A named subpattern may not have a name which length exceeds 32 characters": "A named subpattern may not have a name which length exceeds 32 characters",
  "A posix character class may only appear inside a character class": "A posix character class may only appear inside a character class",
  "A quantifier inside a lookbehind makes it non-fixed width": "A quantifier inside a lookbehind makes it non-fixed width",
  "A repeated capturing group will only capture the last iteration. Put a capturing group around the repeated group to capture all iterations or use a non-capturing group instead if you're not interested in the data": "A repeated capturing group will only capture the last iteration. Put a capturing group around the repeated group to capture all iterations or use a non-capturing group instead if you're not interested in the data",
  "a single character in the range between {1} {2} and {3} {4} ({5})": "a single character in the range between {1} {2} and {3} {4} ({5})",
  "A single character of: a, b or c": "A single character of: a, b or c",
  "A subpattern name must be alpha numeric and may not begin with a digit": "A subpattern name must be alpha numeric and may not begin with a digit",
  "A subpattern name must be unique": "A subpattern name must be unique",
  "A word boundary": "A word boundary",
  "Absolute end of string": "Absolute end of string",
  "Account": "Cuenta",
  "Account Page": "Página de la Cuenta",
  "acts like {1}, except that if the pattern is unanchored, the bumpalong advance is not to the next character, but to the position in the subject where {2} was encountered": "acts like {1}, except that if the pattern is unanchored, the bumpalong advance is not to the next character, but to the position in the subject where {2} was encountered",
  "Add bold text": "Add bold text",
  "Add bulleted list": "Add bulleted list",
  "Add header": "Add header",
  "Add italic text": "Add italic text",
  "Add numbered list": "Add numbered list",
  "Add tag": "Add tag",
  "Add test": "Add test",
  "Add to favorites": "Agrega a los favoritos",
  "All the errors detected are listed below, from left to right, as they appear in the pattern.": "All the errors detected are listed below, from left to right, as they appear in the pattern.",
  "All Tokens": "All Tokens",
  "Allow duplicate subpattern names": "Allow duplicate subpattern names",
  "Allow others to edit permalink": "Allow others to edit permalink",
  "Allows regex to match unicode characters via dotall and unicode escape sequences, as well as ES6 unicode code point escapes such as \\u{1D306}.": "Allows regex to match unicode characters via dotall and unicode escape sequences, as well as ES6 unicode code point escapes such as \\u{1D306}.",
  "Alternative (acts like boolean OR)": "Alternative (acts like boolean OR)",
  "An alternate way to match alphabet letters. Equivalent to [A-Za-z]. [[:alpha:]] is a POSIX notation and it needs to be inside a [character class] notation.": "An alternate way to match alphabet letters. Equivalent to [A-Za-z]. [[:alpha:]] is a POSIX notation and it needs to be inside a [character class] notation.",
  "An alternate way to match any letter or digit. Equivalent to [A-Za-z0-9]. [[:alnum:]] is a POSIX notation and it needs to be inside a [character class] notation.": "An alternate way to match any letter or digit. Equivalent to [A-Za-z0-9]. [[:alnum:]] is a POSIX notation and it needs to be inside a [character class] notation.",
  "An alternator at this position effectively truncates the entire pattern, rendering any other tokens beyond this point useless": "An alternator at this position effectively truncates the entire pattern, rendering any other tokens beyond this point useless",
  "An alternator at this position effectively truncates the group, rendering any other tokens beyond this point useless": "An alternator at this position effectively truncates the group, rendering any other tokens beyond this point useless",
  "An empty alternative effectively makes this group optional which suggests the alternative is completely redundant": "An empty alternative effectively makes this group optional which suggests the alternative is completely redundant",
  "An end quote token encountered before a start quote token": "An end quote token encountered before a start quote token",
  "An explanation of your regex will be automatically generated as you type.": "An explanation of your regex will be automatically generated as you type.",
  "An unescaped delimiter must be escaped with a backslash (\\)": "An unescaped delimiter must be escaped with a backslash (\\)",
  "Anchor": "Anchor",
  "Anchor to start of pattern": "Anchor to start of pattern",
  "Anchors": "Anchors",
  "anonymous": "anonymous",
  "Any character following a \\ that is not a valid meta sequence will be faulted and raise an error. For example, escaping a (.) meta character will cause an error, and it will not match.": "Any character following a \\ that is not a valid meta sequence will be faulted and raise an error. For example, escaping a (.) meta character will cause an error, and it will not match.",
  "Any characters between \\Q and \\E, including metacharacters, will be treated as literals.": "Any characters between \\Q and \\E, including metacharacters, will be treated as literals.",
  "Any digit": "Any digit",
  "Any non-digit": "Any non-digit",
  "Any non-whitespace character": "Any non-whitespace character",
  "Any non-word character": "Any non-word character",
  "Any single character": "Any single character",
  "Any subpatterns in (...) in such a group share the same number.": "Any subpatterns in (...) in such a group share the same number.",
  "Any text appearing in this group is ignored in the regex. Another option is enabling the x flag to allow #comments. This flag will also cause regex to ignore spaces.": "Any text appearing in this group is ignored in the regex. Another option is enabling the x flag to allow #comments. This flag will also cause regex to ignore spaces.",
  "Any Unicode sequences, linebreaks included": "Any Unicode sequences, linebreaks included",
  "Any whitespace character": "Any whitespace character",
  "Any word can be used as a tag": "Any word can be used as a tag",
  "Any word character": "Any word character",
  "Application Settings": "Application Settings",
  "as few times as possible, expanding as needed": "as few times as possible, expanding as needed",
  "as many times as possible, giving back as needed": "as many times as possible, giving back as needed",
  "as many times as possible, without giving back": "as many times as possible, without giving back",
  "ASCII codes 0-127": "ASCII codes 0-127",
  "ASCII control characters": "ASCII control characters",
  "assert position at a word boundary {1}": "assert position at a word boundary {1}",
  "assert position where {1} does not match": "assert position where {1} does not match",
  "assert that": "assert that",
  "Assert that the Regex below does not match": "Assert that the Regex below does not match",
  "Assert that the Regex below matches": "Assert that the Regex below matches",
  "asserts position at start of {1}": "asserts position at start of {1}",
  "asserts position at start of the string": "asserts position at start of the string",
  "asserts position at the end of a line": "asserts position at the end of a line",
  "asserts position at the end of the previous match or the start of the string for the first match": "asserts position at the end of the previous match or the start of the string for the first match",
  "asserts position at the end of the string": "asserts position at the end of the string",
  "asserts position at the end of the string, or before the line terminator right at the end of the string (if any)": "asserts position at the end of the string, or before the line terminator right at the end of the string (if any)",
  "Asserts that the given subpattern can be matched here, without consuming characters": "Asserts that the given subpattern can be matched here, without consuming characters",
  "Atomic Group": "Atomic Group",
  "Atomic group (non-capturing)": "Atomic group (non-capturing)",
  "Author": "Author",
  "Auto-complete Brackets": "Auto-complete Brackets",
  "Backspace character": "Backspace character",
  "Backtrack": "Backtrack",
  "Before even attempting a match, the regex engine makes some checks, such as the length of the string. If it is not long enough to fit the pattern, it will automatically return a no match. This optimization can be disabled by using this modifier.": "Before even attempting a match, the regex engine makes some checks, such as the length of the string. If it is not long enough to fit the pattern, it will automatically return a no match. This optimization can be disabled by using this modifier.",
  "Beta Sign-in": "Beta Sign-in",
  "Between 3 and 6 of a": "Between 3 and 6 of a",
  "Beware that this will refresh the page and any unsaved progress will be lost!": "Beware that this will refresh the page and any unsaved progress will be lost!",
  "Bug Reports & Feedback": "Bug Reports & Feedback",
  "Bugs or suggestions go here": "Bugs or suggestions go here",
  "Cancel": "Cancel",
  "Capture everything enclosed": "Capture everything enclosed",
  "capture group {1}": "capture group {1}",
  "Capture Group {1} is {2} ... and so on": "Capture Group {1} is {2} ... and so on",
  "Capture Group {1} is {2} and its start/end positions can be obtained via {3} and {4}": "Capture Group {1} is {2} and its start/end positions can be obtained via {3} and {4}",
  "Carriage return": "Carriage return",
  "Case insensitive": "Case insensitive",
  "case insensitive": "case insensitive",
  "Case insensitive match": "Case insensitive match",
  "case sensitive": "case sensitive",
  "Catastrophic Backtracking": "Catastrophic Backtracking",
  "Catastrophic backtracking has been detected and the execution of your expression has been halted. To find out more what this is, please read the following article:": "Catastrophic backtracking has been detected and the execution of your expression has been halted. To find out more what this is, please read the following article:",
  "Categories": "Categoría",
  "causes a skip to the next innermost alternative if the rest of the pattern does not match": "causes a skip to the next innermost alternative if the rest of the pattern does not match",
  "causes the whole match to fail outright if the rest of the pattern does not match": "causes the whole match to fail outright if the rest of the pattern does not match",
  "causes token to be ignored": "causes token to be ignored",
  "Change delimiter": "Change delimiter",
  "character": "character",
  "Character class missing closing bracket": "Character class missing closing bracket",
  "Character Classes": "Character Classes",
  "Character range is out of order": "Character range is out of order",
  "characters": "characters",
  "Close": "Cierra",
  "Close details": "Close details",
  "Code Generator": "Code Generator",
  "Collapse all tests": "Collapse all tests",
  "Comment": "Comment",
  "Common Tokens": "Common Tokens",
  "Complete match contents": "Complete match contents",
  "Conditional statement": "Conditional statement",
  "Consider a donation": "Consider a donation",
  "Contact": "Contact",
  "contains": "contains",
  "Contents after match": "Contents after match",
  "Contents before match": "Contents before match",
  "Contents in capture group `foo`": "Contents in capture group `foo`",
  "Contents in capture group 1": "Contents in capture group 1",
  "Control character Y": "Control character Y",
  "Control characters": "Control characters",
  "Control verb": "Control verb",
  "Copied!": "¡Copiado!",
  "Copy to clipboard": "Copy to clipboard",
  "Could not compile regex": "Could not compile regex",
  "Custom regex101 property that converts all subsequent tokens to their {1} equivalence until `\\E` is encountered": "Custom regex101 property that converts all subsequent tokens to their {1} equivalence until `\\E` is encountered",
  "Dark": "Dark",
  "Data": "Data",
  "Debug data": "Debug data",
  "Decimal digits": "Número con decimales",
  "Delete library entry": "Delete library entry",
  "Delete link": "Elimina enlace",
  "Delete permalink": "Delete permalink",
  "Delimiters": "Delimitadores",
  "Description": "Descripción",
  "Description of regular expression": "Descripción de la expresión regular",
  "Detailed match information will be displayed here automatically.": "Detailed match information will be displayed here automatically.",
  "Different names for groups of the same index is not allowed": "Different names for groups of the same index is not allowed",
  "Disallow duplicate subpattern names": "Disallow duplicate subpattern names",
  "Disallow meaningless escapes": "Disallow meaningless escapes",
  "Disallow others to edit permalink": "Disallow others to edit permalink",
  "does match": "does match",
  "does not match": "does not match",
  "Don't return after first match": "Don't return after first match",
  "Donate": "Donate",
  "Dot matches newline": "Dot matches newline",
  "Due to a bug in PCRE creating ranges with an escaped literal is unsafe. To avoid this, simply use the literal representation instead.": "Due to a bug in PCRE creating ranges with an escaped literal is unsafe. To avoid this, simply use the literal representation instead.",
  "Duplicate group names": "Duplicate group names",
  "Duplicate Subpattern Group": "Duplicate Subpattern Group",
  "Duplicate subpattern group number": "Duplicate subpattern group number",
  "Edit account entry": "Edit account entry",
  "Edit test": "Edit test",
  "Edit title": "Edit title",
  "Edit title and tags": "Modifica título y etiquetas",
  "Editor": "Editor",
  "Else match the following regex": "Else match the following regex",
  "empty character class — matches {1}": "empty character class — matches {1}",
  "empty string": "empty string",
  "Enable or disable the syntax highlighting of your regular expression in the editor.": "Enable or disable the syntax highlighting of your regular expression in the editor.",
  "Enable unicode support": "Enable unicode support",
  "End of quoted literals": "End of quoted literals",
  "End of string": "End of string",
  "End of word": "End of word",
  "ends with": "ends with",
  "Engine Error": "Engine Error",
  "Ensures that the given pattern will match, ending at the current position in the expression. The pattern must have a fixed width. Does not consume any characters.": "Ensures that the given pattern will match, ending at the current position in the expression. The pattern must have a fixed width. Does not consume any characters.",
  "Ensures that the given pattern would not match and end at the current position in the expression. The pattern must have a fixed width. Does not consume characters.": "Ensures that the given pattern would not match and end at the current position in the expression. The pattern must have a fixed width. Does not consume characters.",
  "equal to {1}": "equal to {1}",
  "equals": "equals",
  "Evaluate the condition below and proceed accordingly": "Evaluate the condition below and proceed accordingly",
  "Exactly 3 of a": "Exactly 3 of a",
  "Expand all tests": "Expand all tests",
  "Expected group {1} to contain `{2}` but did not": "Expected group {1} to contain `{2}` but did not",
  "Expected group {1} to end with `{2}` but was instead `{3}`": "Expected group {1} to end with `{2}` but was instead `{3}`",
  "Expected group {1} to equal `{2}` but was instead `{3}`": "Expected group {1} to equal `{2}` but was instead `{3}`",
  "Expected group {1} to start with `{2}` but was instead `{3}`": "Expected group {1} to start with `{2}` but was instead `{3}`",
  "Expected regex to match, but did not.": "Expected regex to match, but did not.",
  "Expected regex to not match, but did.": "Expected regex to not match, but did.",
  "Explanation": "Explanation",
  "Export Matches": "Export Matches",
  "Export matches": "Export matches",
  "Export Method": "Export Method",
  "eXtended": "eXtended",
  "Favorite Regex": "Favorite Regex",
  "Fewest points": "Fewest points",
  "Filter by Flavor": "Filter by Flavor",
  "Flags/Modifiers": "Flags/Modifiers",
  "Flavor": "Flavor",
  "Follow me on twitter!": "Follow me on twitter!",
  "For a full regex reference for {1}, please visit:": "For a full regex reference for {1}, please visit:",
  "Fork Regex": "Fork Regex",
  "Fork Regular Expression": "Fork Regular Expression",
  "Form-feed": "Form-feed",
  "Format Regex": "Format Regex",
  "Full match": "Full match",
  "full match": "full match",
  "Full Search Result": "Full Search Result",
  "General": "General",
  "General Tokens": "General Tokens",
  "Generated Code": "Generated Code",
  "Github": "Github",
  "given the string": "given the string",
  "Global": "Global",
  "Global pattern flags": "Global pattern flags",
  "Google": "Google",
  "greedy": "greedy",
  "Greedy quantifier": "Greedy quantifier",
  "Group": "Group",
  "Group {1}": "Group {1}",
  "Group {1} found at {2}": "Group {1} found at {2}",
  "Group {1} no longer exists in the pattern or did not participate in the match": "Group {1} no longer exists in the pattern or did not participate in the match",
  "Group {1} was not expected to participate in the match but did anyway": "Group {1} was not expected to participate in the match but did anyway",
  "group {1}: {2}": "group {1}: {2}",
  "Group Constructs": "Group Constructs",
  "group did not participate in match": "group did not participate in match",
  "Headers": "Headers",
  "Here comes a {1} tab character.": "Here comes a {1} tab character.",
  "Hex character YY": "Hex character YY",
  "Hex character YYYY": "Hex character YYYY",
  "Hexadecimal digits": "Hexadecimal digits",
  "Hexadecimal replacement values": "Hexadecimal replacement values",
  "Highlight Syntax": "Highlight Syntax",
  "Horizontal whitespace character": "Horizontal whitespace character",
  "I recommend you launch the debugger in the menu to the left and analyze the data to find out the cause.": "I recommend you launch the debugger in the menu to the left and analyze the data to find out the cause.",
  "If capturing group 1 was matched so far, matches the pattern before the vertical bar. Otherwise, matches the pattern after the vertical bar. A group name, or a relative position (-1) in PCRE, can be used. Global flag breaks conditionals.": "If capturing group 1 was matched so far, matches the pattern before the vertical bar. Otherwise, matches the pattern after the vertical bar. A group name, or a relative position (-1) in PCRE, can be used. Global flag breaks conditionals.",
  "If Clause": "If Clause",
  "If condition is met, match the following regex": "If condition is met, match the following regex",
  "If recursion of the whole pattern is successful, do something | otherwise do this.": "If recursion of the whole pattern is successful, do something | otherwise do this.",
  "If the lookahead succeeds, matches the pattern before the vertical bar. Otherwise, matches the pattern after the vertical bar. The lookaround can be negative. Global flag breaks conditionals.": "If the lookahead succeeds, matches the pattern before the vertical bar. Otherwise, matches the pattern after the vertical bar. The lookaround can be negative. Global flag breaks conditionals.",
  "If the lookbehind succeeds, match the pattern before the vertical bar. Otherwise, matches the pattern after the vertical bar. The lookaround can be negative. Global flag, 'g', breaks conditionals.": "If the lookbehind succeeds, match the pattern before the vertical bar. Otherwise, matches the pattern after the vertical bar. The lookaround can be negative. Global flag, 'g', breaks conditionals.",
  "If this token is inside a capturing group, only that capturing group is ended successfully at that particular location, while the parent pattern continues to execute.": "If this token is inside a capturing group, only that capturing group is ended successfully at that particular location, while the parent pattern continues to execute.",
  "If you want to use this regex and data in your own experiments, click the `Fork Regex` button below instead.": "If you want to use this regex and data in your own experiments, click the `Fork Regex` button below instead.",
  "Ignore whitespace": "Ignore whitespace",
  "In the example below, the first alternate matched \"a\", and the second one matched \"bc\", however once it bumped into \"X\" none of the alternatives resulted in a match. Therefore the engine cannot return the next \"a\" as a match because \"X\" is not the last location where a match occurred.": "In the example below, the first alternate matched \"a\", and the second one matched \"bc\", however once it bumped into \"X\" none of the alternatives resulted in a match. Therefore the engine cannot return the next \"a\" as a match because \"X\" is not the last location where a match occurred.",
  "In this case `(?(R&sub1)...|...)` checks if a call to `sub1` has been made. The first time the recursive conditional is parsed, the engine is in the process of matching what `sub1` requires, but it isn't because of a callback to `sub1`.": "In this case `(?(R&sub1)...|...)` checks if a call to `sub1` has been made. The first time the recursive conditional is parsed, the engine is in the process of matching what `sub1` requires, but it isn't because of a callback to `sub1`.",
  "Include non-participating groups in match result": "Include non-participating groups in match result",
  "include the latest version of the regex crate in your Cargo.toml": "include the latest version of the regex crate in your Cargo.toml",
  "Incomplete group structure": "Incomplete group structure",
  "Inline modifiers": "Inline modifiers",
  "Insert a carriage return character.": "Insert a carriage return character.",
  "Insert a form-feed character.": "Insert a form-feed character.",
  "Insert a newline character.": "Insert a newline character.",
  "Insert a personal title": "Insert a personal title",
  "Insert a tab character.": "Insert a tab character.",
  "Insert code snippet": "Insert code snippet",
  "insert comparison string": "insert comparison string",
  "Insert link": "Insert link",
  "Insert quote": "Insert quote",
  "insert test description": "insert test description",
  "insert test string": "insert test string",
  "insert your regular expression here": "insert your regular expression here",
  "insert your replacement value here": "insert your replacement value here",
  "insert your test string here": "insert your test string here",
  "Invalid control character": "Invalid control character",
  "Invalid unicode escape": "Invalid unicode escape",
  "is null": "is null",
  "It will not be deleted unless you decide to delete it.": "It will not be deleted unless you decide to delete it.",
  "Keep in mind that Python 3 is going to treat your whole script as unicode by default, therefore using this flag would be redundant. See the \"a\" flag to limit matches to ASCII characters only. Python 2 requires this flag to turn on unicode support.": "Keep in mind that Python 3 is going to treat your whole script as unicode by default, therefore using this flag would be redundant. See the \"a\" flag to limit matches to ASCII characters only. Python 2 requires this flag to turn on unicode support.",
  "Language": "Idioma",
  "lazy": "lazy",
  "Lazy quantifier": "Lazy quantifier",
  "Letters": "Letters",
  "Letters and digits": "Letters and digits",
  "Library entries": "Library entries",
  "Library Entry": "Library Entry",
  "Light": "Light",
  "Like regex101? Support it by donating!": "Like regex101? Support it by donating!",
  "Line break modifier": "Line break modifier",
  "Line terminator(s) are {1} {2}": "Line terminator(s) are {1} {2}",
  "Lined are delimited by {1} {2}": "Lined are delimited by {1} {2}",
  "Link to regular expression": "Link to regular expression",
  "Live Help (IRC, opens new window)": "Live Help (IRC, opens new window)",
  "Load more": "Load more",
  "Loading...": "Loading...",
  "Lookahead conditional": "Lookahead conditional",
  "Lookbehind conditional": "Lookbehind conditional",
  "lowercase": "lowercase",
  "Lowercase letters": "Lowercase letters",
  "Make escape sequences perform ASCII-only matching": "Make escape sequences perform ASCII-only matching",
  "Make permalink private": "Make permalink private",
  "Make permalink public": "Make permalink public",
  "Make quantifiers lazy": "Make quantifiers lazy",
  "Make regex perform ASCII-only matching instead of full Unicode matching. Applies to [a-z] ranges and escape sequences.": "Make regex perform ASCII-only matching instead of full Unicode matching. Applies to [a-z] ranges and escape sequences.",
  "Makes any character literal": "Makes any character literal",
  "marker verb whose main purpose is to track how a match was arrived at": "marker verb whose main purpose is to track how a match was arrived at",
  "Match": "Match",
  "Match {1}": "Match {1}",
  "Match {1} failed in {2} step(s)": "Match {1} failed in {2} step(s)",
  "Match {1} found in {2} step(s)": "Match {1} found in {2} step(s)",
  "Match {1} halted after {2} step(s)": "Match {1} halted after {2} step(s)",
  "Match {1} was found at {2}": "Match {1} was found at {2}",
  "Match a single character not present in the list below": "Match a single character not present in the list below",
  "Match a single character not present in the set": "Match a single character not present in the set",
  "Match a single character present in the list below": "Match a single character present in the list below",
  "Match a single character present in the set": "Match a single character present in the set",
  "match any non-word character in any script (equal to {1})": "match any non-word character in any script (equal to {1})",
  "match any word character in any script (equal to {1})": "match any word character in any script (equal to {1})",
  "Match either a or b": "Match either a or b",
  "Match everything enclosed": "Match everything enclosed",
  "Match Information": "Match Information",
  "Match nth relative previous subpattern": "Match nth relative previous subpattern",
  "Match nth relative upcoming subpattern": "Match nth relative upcoming subpattern",
  "Match nth subpattern": "Match nth subpattern",
  "Match one data unit": "Match one data unit",
  "Match previously-named capture group `name`": "Match previously-named capture group `name`",
  "Match subpattern `name`": "Match subpattern `name`",
  "Match the first capture group following the current position in the expression. (?+2) is the second one, (?-1) is before current position.": "Match the first capture group following the current position in the expression. (?+2) is the second one, (?-1) is before current position.",
  "match the remainder of the pattern with the following effective flags: {1}": "match the remainder of the pattern with the following effective flags: {1}",
  "Match was found at {1}": "Match was found at {1}",
  "Match with full unicode": "Match with full unicode",
  "matched result": "matched result",
  "matches a alphabetic character {1}": "matches a alphabetic character {1}",
  "matches a alphanumeric character {1}": "matches a alphanumeric character {1}",
  "matches a alphanumeric character or {1} {2} (also written as {3})": "matches a alphanumeric character or {1} {2} (also written as {3})",
  "matches a backspace character {1}": "matches a backspace character {1}",
  "matches a carriage return {1}": "matches a carriage return {1}",
  "Matches a carriage return character, unicode character 2185.": "Matches a carriage return character, unicode character 2185.",
  "matches a character intended to be combined with another character (e.g. accents, umlauts, enclosing boxes, etc.)": "matches a character intended to be combined with another character (e.g. accents, umlauts, enclosing boxes, etc.)",
  "matches a character intended to be combined with another character that takes up extra space (vowel signs in many Eastern languages)": "matches a character intended to be combined with another character that takes up extra space (vowel signs in many Eastern languages)",
  "matches a character intended to be combined with another character without taking up extra space (e.g. accents, umlauts, etc.)": "matches a character intended to be combined with another character without taking up extra space (e.g. accents, umlauts, etc.)",
  "matches a character that encloses the character is is combined with (circle, square, keycap, etc.)": "matches a character that encloses the character is is combined with (circle, square, keycap, etc.)",
  "matches a character with {1} value {2} through {3}": "matches a character with {1} value {2} through {3}",
  "matches a combining character (mark) as a full character on its own": "matches a combining character (mark) as a full character on its own",
  "matches a control character {1}": "matches a control character {1}",
  "matches a digit (equal to {1})": "matches a digit (equal to {1})",
  "matches a digit {1} (also written as {2})": "matches a digit {1} (also written as {2})",
  "matches a digit zero through nine in any script except ideographic scripts": "matches a digit zero through nine in any script except ideographic scripts",
  "matches a digit zero through nine in any script except ideographic scripts (equal to {1})": "matches a digit zero through nine in any script except ideographic scripts (equal to {1})",
  "matches a form-feed character {1}": "matches a form-feed character {1}",
  "matches a hexadecimal digit {1}": "matches a hexadecimal digit {1}",
  "matches a letter or ideograph that does not have lowercase and uppercase variants": "matches a letter or ideograph that does not have lowercase and uppercase variants",
  "matches a letter that appears at the start of a word when only the first letter of the word is capitalized": "matches a letter that appears at the start of a word when only the first letter of the word is capitalized",
  "matches a letter that exists in lowercase and uppercase variants (combination of {1}, {2} and {3})": "matches a letter that exists in lowercase and uppercase variants (combination of {1}, {2} and {3})",
  "matches a line separator character {1}": "matches a line separator character {1}",
  "matches a line-feed (newline) character {1}": "matches a line-feed (newline) character {1}",
  "matches a lowercase letter {1}": "matches a lowercase letter {1}",
  "matches a lowercase letter that has an uppercase variant": "matches a lowercase letter that has an uppercase variant",
  "Matches a newline character": "Matches a newline character",
  "Matches a null character, most often visually represented in unicode using U+2400.": "Matches a null character, most often visually represented in unicode using U+2400.",
  "matches a number that looks like a letter, such as a Roman numeral": "matches a number that looks like a letter, such as a Roman numeral",
  "matches a paragraph separator character {1}": "matches a paragraph separator character {1}",
  "matches a punctuation character {1}": "matches a punctuation character {1}",
  "matches a punctuation character such as an underscore that connects words": "matches a punctuation character such as an underscore that connects words",
  "matches a single character in the list {1} {2}": "matches a single character in the list {1} {2}",
  "matches a special character that is used like a letter": "matches a special character that is used like a letter",
  "matches a superscript or subscript digit, or a number that is not a digit (excluding numbers from ideographic scripts)": "matches a superscript or subscript digit, or a number that is not a digit (excluding numbers from ideographic scripts)",
  "matches a tab character {1}": "matches a tab character {1}",
  "Matches a tab character. Historically, tab stops happen every 8 characters.": "Matches a tab character. Historically, tab stops happen every 8 characters.",
  "Matches a unicode character that doesn't have any of the given properties.": "Matches a unicode character that doesn't have any of the given properties.",
  "Matches a unicode character with the given group of properties or categories:": "Matches a unicode character with the given group of properties or categories:",
  "Matches a unicode character with the given property:": "Matches a unicode character with the given property:",
  "Matches a unicode character without the given property.": "Matches a unicode character without the given property.",
  "matches a uppercase letter {1}": "matches a uppercase letter {1}",
  "matches a vertical tab character": "matches a vertical tab character",
  "matches a visible character {1}": "matches a visible character {1}",
  "matches a visible character or the space character {1}": "matches a visible character or the space character {1}",
  "matches a whitespace character that is invisible, but does take up space": "matches a whitespace character that is invisible, but does take up space",
  "matches a whitespace character, including a line break {1} (also written as {2})": "matches a whitespace character, including a line break {1} (also written as {2})",
  "Matches an `a` character or nothing.": "Matches an `a` character or nothing.",
  "matches an ASCII {1} or Latin-1 {2} control character": "matches an ASCII {1} or Latin-1 {2} control character",
  "matches an uppercase letter that has a lowercase variant": "matches an uppercase letter that has a lowercase variant",
  "matches any character {1}": "matches any character {1}",
  "Matches any character except for an a, b or c": "Matches any character except for an a, b or c",
  "Matches any character in the valid ASCII range. Equivalent to [\u0000-]. [[:ascii:]] is a POSIX notation and it needs to be inside a [character class] notation.": "Matches any character in the valid ASCII range. Equivalent to [\u0000-]. [[:ascii:]] is a POSIX notation and it needs to be inside a [character class] notation.",
  "Matches any character other than newline (or including newline with the /s flag)": "Matches any character other than newline (or including newline with the /s flag)",
  "Matches any character that is not horizontal whitespace (\\H).": "Matches any character that is not horizontal whitespace (\\H).",
  "matches any character that's not a horizontal whitespace character": "matches any character that's not a horizontal whitespace character",
  "matches any character that\\'s not a digit (equal to {1})": "matches any character that\\'s not a digit (equal to {1})",
  "matches any character that\\'s not a vertical whitespace character": "matches any character that\\'s not a vertical whitespace character",
  "matches any character, including newline": "matches any character, including newline",
  "matches any character, including unicode {1}": "matches any character, including unicode {1}",
  "Matches any characters between a and z, including a and z.": "Matches any characters between a and z, including a and z.",
  "Matches any characters between a-z or A-Z. You can combine as much as you please.": "Matches any characters between a-z or A-Z. You can combine as much as you please.",
  "Matches any characters except those in the range a-z.": "Matches any characters except those in the range a-z.",
  "matches any characters in the {1} script": "matches any characters in the {1} script",
  "matches any characters that {1} does not": "matches any characters that {1} does not",
  "matches any code point reserved for private use": "matches any code point reserved for private use",
  "matches any code point to which no character has been assigned": "matches any code point to which no character has been assigned",
  "matches any currency sign": "matches any currency sign",
  "Matches any decimal digit. Equivalent to [0-9].": "Matches any decimal digit. Equivalent to [0-9].",
  "matches any horizontal whitespace character (equal to {1})": "matches any horizontal whitespace character (equal to {1})",
  "matches any kind of closing bracket": "matches any kind of closing bracket",
  "matches any kind of closing quote": "matches any kind of closing quote",
  "matches any kind of hyphen or dash": "matches any kind of hyphen or dash",
  "matches any kind of invisible character (equal to {1})": "matches any kind of invisible character (equal to {1})",
  "matches any kind of letter from any language": "matches any kind of letter from any idioma",
  "matches any kind of numeric character in any script": "matches any kind of numeric character in any script",
  "matches any kind of opening bracket": "matches any kind of opening bracket",
  "matches any kind of opening quote": "matches any kind of opening quote",
  "matches any kind of punctuation character": "matches any kind of punctuation character",
  "matches any kind of punctuation character that is not a dash, bracket, quote or connector": "matches any kind of punctuation character that is not a dash, bracket, quote or connector",
  "matches any kind of visible character (equal to {1})": "matches any kind of visible character (equal to {1})",
  "matches any kind of whitespace or invisible separator": "matches any kind of whitespace or invisible separator",
  "Matches any letter, digit or underscore. Equivalent to [a-zA-Z0-9_].": "Matches any letter, digit or underscore. Equivalent to [a-zA-Z0-9_].",
  "matches any math symbols, currency signs, dingbats, box-drawing characters, etc": "matches any math symbols, currency signs, dingbats, box-drawing characters, etc",
  "matches any mathematical symbol": "matches any mathematical symbol",
  "matches any non-newline character": "matches any non-newline character",
  "matches any non-numeric character in any script (equal to {1})": "matches any non-numeric character in any script (equal to {1})",
  "matches any non-whitespace character (equal to {1})": "matches any non-whitespace character (equal to {1})",
  "matches any non-word character (equal to {1})": "matches any non-word character (equal to {1})",
  "matches any number of Unicode characters that form an extended Unicode sequence": "matches any number of Unicode characters that form an extended Unicode sequence",
  "Matches any space, tab or newline character.": "Matches any space, tab or newline character.",
  "Matches any Unicode newline character: <CR>, <LF>;, <CR><LF>. Equivalent to [\\r\\n].": "Matches any Unicode newline character: <CR>, <LF>;, <CR><LF>. Equivalent to [\\r\\n].",
  "matches any Unicode newline sequence; can be modified using verbs": "matches any Unicode newline sequence; can be modified using verbs",
  "Matches any valid Unicode sequence, including line breaks.": "Matches any valid Unicode sequence, including line breaks.",
  "matches any vertical whitespace character": "matches any vertical whitespace character",
  "matches any whitespace character (equal to {1})": "matches any whitespace character (equal to {1})",
  "matches any word character (equal to {1})": "matches any word character (equal to {1})",
  "Matches anything not matched by \u000b (newlines and vertical tabs)": "Matches anything not matched by \u000b (newlines and vertical tabs)",
  "Matches anything other than a decimal digit.": "Matches anything other than a decimal digit.",
  "Matches anything other than a letter, digit or underscore.": "Matches anything other than a letter, digit or underscore.",
  "Matches anything other than a space, tab or newline.": "Matches anything other than a space, tab or newline.",
  "Matches as few characters as possible.": "Matches as few characters as possible.",
  "Matches as many characters as possible; backtracking can't reduce the number of characters matched. Because it is greedy, it will match all the way to the last digit, leaving nothing else for the {1} to match. Without backtracking, this regex fails to produce a match.": "Matches as many characters as possible; backtracking can't reduce the number of characters matched. Because it is greedy, it will match all the way to the last digit, leaving nothing else for the {1} to match. Without backtracking, this regex fails to produce a match.",
  "Matches as many characters as possible.": "Matches as many characters as possible.",
  "Matches ASCII characters typically associated with Control+A through Control+Z: \\x01 through \\x1A.": "Matches ASCII characters typically associated with Control+A through Control+Z: \\x01 through \\x1A.",
  "Matches at least 3 consecutive `a` characters.": "Matches at least 3 consecutive `a` characters.",
  "Matches between 3 and 6 (inclusive) consecutive `a` characters.": "Matches between 3 and 6 (inclusive) consecutive `a` characters.",
  "Matches characters that are not whitespace, letters or numbers. [[:punct:]] is a POSIX notation and it needs to be inside a [character class] notation.": "Matches characters that are not whitespace, letters or numbers. [[:punct:]] is a POSIX notation and it needs to be inside a [character class] notation.",
  "Matches characters that are often used to control text presentation, including newlines, null characters, tabs and the escape character. Equivalent to [\\x00-\\x1F\\x7F]. [[:cntrl:]] is a POSIX notation and it needs to be inside a [character class] notation.": "Matches characters that are often used to control text presentation, including newlines, null characters, tabs and the escape character. Equivalent to [\\x00-\\x1F\\x7F]. [[:cntrl:]] is a POSIX notation and it needs to be inside a [character class] notation.",
  "Matches decimal digits. Equivalent to [0-9]. [[:digit:]] is a POSIX notation and it needs to be inside a [character class] notation.": "Matches decimal digits. Equivalent to [0-9]. [[:digit:]] is a POSIX notation and it needs to be inside a [character class] notation.",
  "Matches either an a, b or c character": "Matches either an a, b or c character",
  "matches esc {1}": "matches esc {1}",
  "Matches exactly 3 consecutive `a` characters.": "Matches exactly 3 consecutive `a` characters.",
  "Matches exactly one data unit of input. Can match individual bytes in UTF-8 mode, leading to undefined behaviour if a search starts inside a character.": "Matches exactly one data unit of input. Can match individual bytes in UTF-8 mode, leading to undefined behaviour if a search starts inside a character.",
  "Matches hexadecimal digits, case insensitive. Equivalent to [0-9a-fA-F].": "Matches hexadecimal digits, case insensitive. Equivalent to [0-9a-fA-F].",
  "matches invisible control characters and unused code points": "matches invisible control characters and unused code points",
  "matches invisible formatting indicator": "matches invisible formatting indicator",
  "Matches items captured in the nth capture group ahead of the current position of \\g<+n>. \\g'+2' is the second capture group after \\g.": "Matches items captured in the nth capture group ahead of the current position of \\g<+n>. \\g'+2' is the second capture group after \\g.",
  "Matches items captured in the nth capture group ahead of the current position of \\g<+n>. \\g<+2> is the second capture group after \\g.": "Matches items captured in the nth capture group ahead of the current position of \\g<+n>. \\g<+2> is the second capture group after \\g.",
  "Matches items captured in the nth capture group prior to the current position of \\g{-n}. \\g{-1} would be the last capture group before \\g. \\g{-2} would be the capture group before the last, and so on.": "Matches items captured in the nth capture group prior to the current position of \\g{-n}. \\g{-1} would be the last capture group before \\g. \\g{-2} would be the capture group before the last, and so on.",
  "Matches letters, numbers and underscores. Equivalent to \\w or [a-zA-Z0-9_]. [[:word:]] is a POSIX notation and it needs to be inside a [character class] notation.": "Matches letters, numbers and underscores. Equivalent to \\w or [a-zA-Z0-9_]. [[:word:]] is a POSIX notation and it needs to be inside a [character class] notation.",
  "Matches lowercase letters. Equivalent to [a-z]. [[:lower:]] is a POSIX notation and it needs to be inside a [character class] notation.": "Matches lowercase letters. Equivalent to [a-z]. [[:lower:]] is a POSIX notation and it needs to be inside a [character class] notation.",
  "Matches newlines and vertical tabs. Works with Unicode. Vertical tabs can be inserted in some word processors using CMD/CTRL+ENTER.": "Matches newlines and vertical tabs. Works with Unicode. Vertical tabs can be inserted in some word processors using CMD/CTRL+ENTER.",
  "matches one data unit, even in UTF mode (best avoided)": "matches one data unit, even in UTF mode (best avoided)",
  "matches one half of a surrogate pair in {1} encoding": "matches one half of a surrogate pair in {1} encoding",
  "Matches one or more consecutive `a` characters.": "Matches one or more consecutive `a` characters.",
  "Matches printable characters, part of the basic latin set, such as letters and spaces, without including control characters. [[:print:]] is a POSIX notation and it needs to be inside a [character class] notation.": "Matches printable characters, part of the basic latin set, such as letters and spaces, without including control characters. [[:print:]] is a POSIX notation and it needs to be inside a [character class] notation.",
  "Matches printable, non-whitespace, non-control characters only. Equivalent to [!-~]. [[:graph:]] is a POSIX notation and it needs to be inside a [character class] notation.": "Matches printable, non-whitespace, non-control characters only. Equivalent to [!-~]. [[:graph:]] is a POSIX notation and it needs to be inside a [character class] notation.",
  "Matches spaces and horizontal tabs. Works with Unicode. Equivalent to [\ts].": "Matches spaces and horizontal tabs. Works with Unicode. Equivalent to [\ts].",
  "Matches spaces and tabs (but not newlines). Equivalent to [ \t]. [[:blank:]] is a POSIX notation and it needs to be inside a [character class] notation.": "Matches spaces and tabs (but not newlines). Equivalent to [ \t]. [[:blank:]] is a POSIX notation and it needs to be inside a [character class] notation.",
  "matches the {1} {2} literally {3}": "matches the {1} {2} literally {3}",
  "Matches the 16-bit character with the given hex value.": "Matches the 16-bit character with the given hex value.",
  "Matches the 8-bit character with the given hex value.": "Matches the 8-bit character with the given hex value.",
  "Matches the 8-bit character with the given octal value.": "Matches the 8-bit character with the given octal value.",
  "Matches the a or the b part of the subexpression.": "Matches the a or the b part of the subexpression.",
  "Matches the backspace control character.": "Matches the backspace control character.",
  "matches the bell character {1}": "matches the bell character {1}",
  "Matches the capture group called \"name\". Capture group has to be named before \\g is called. This is an alternative notation for \\g'name' or \\g{name}": "Matches the capture group called \"name\". Capture group has to be named before \\g is called. This is an alternative notation for \\g'name' or \\g{name}",
  "Matches the capture group called \"name\". Capture group has to be named before \\g is called. This is an alternative notation for \\g'name' or \\g<name>. Note that you cannot use curly brackets (?{name}a+) to name a capture group in PCRE": "Matches the capture group called \"name\". Capture group has to be named before \\g is called. This is an alternative notation for \\g'name' or \\g<name>. Note that you cannot use curly brackets (?{name}a+) to name a capture group in PCRE",
  "Matches the capture group called `name`. Capture group has to be named before \\g is called.": "Matches the capture group called `name`. Capture group has to be named before \\g is called.",
  "matches the character {1} with index {2} ({3} or {4}) literally ({5})": "matches the character {1} with index {2} ({3} or {4}) literally ({5})",
  "matches the control sequence {1} {2}": "matches the control sequence {1} {2}",
  "Matches the end of a string only. Unlike $, this is not affected by multiline mode, and, in contrast to \\Z, will not match before a trailing newline at the end of a string.": "Matches the end of a string only. Unlike $, this is not affected by multiline mode, and, in contrast to \\Z, will not match before a trailing newline at the end of a string.",
  "Matches the end of a string only. Unlike $, this is not affected by multiline mode.": "Matches the end of a string only. Unlike $, this is not affected by multiline mode.",
  "Matches the end of a string without consuming any characters. If multiline mode is used, this will also match immediately before a newline character.": "Matches the end of a string without consuming any characters. If multiline mode is used, this will also match immediately before a newline character.",
  "Matches the longest possible substring in the group and doesn't allow later backtracking to reevaluate the group. It is not a capturing group.": "Matches the longest possible substring in the group and doesn't allow later backtracking to reevaluate the group. It is not a capturing group.",
  "matches the negation of {1}": "matches the negation of {1}",
  "matches the same text as most recently matched by the {1} capturing group": "matches the same text as most recently matched by the {1} capturing group",
  "matches the same text as most recently matched by the capturing group named {1}": "matches the same text as most recently matched by the capturing group named {1}",
  "matches the same text as most recently matched by the entire pattern": "matches the same text as most recently matched by the entire pattern",
  "Matches the start of a string only. Unlike ^, this is not affected by multiline mode.": "Matches the start of a string only. Unlike ^, this is not affected by multiline mode.",
  "Matches the start of a string without consuming any characters. If multiline mode is used, this will also match immediately after a newline character.": "Matches the start of a string without consuming any characters. If multiline mode is used, this will also match immediately after a newline character.",
  "Matches the text captured in the nth group. n can contain more than one digit, if necessary. Alternate syntax for \\g{n}": "Matches the text captured in the nth group. n can contain more than one digit, if necessary. Alternate syntax for \\g{n}",
  "Matches the text captured in the nth group. n can contain more than one digit, if necessary. Alternate syntax for \\g<n>": "Matches the text captured in the nth group. n can contain more than one digit, if necessary. Alternate syntax for \\g<n>",
  "Matches the text captured in the nth group. n can contain more than one digit, if necessary. This may be useful in order to avoid ambiguity with octal characters.": "Matches the text captured in the nth group. n can contain more than one digit, if necessary. This may be useful in order to avoid ambiguity with octal characters.",
  "Matches the text captured in the nth group. n can contain more than one digit, if necessary. This may be useful in order to avoid ambiguity with octal characters. This is an alternate syntax for \\gn. It can be useful in a situation where a literal number needs to be matched immediately after a \\gn in the regex.": "Matches the text captured in the nth group. n can contain more than one digit, if necessary. This may be useful in order to avoid ambiguity with octal characters. This is an alternate syntax for \\gn. It can be useful in a situation where a literal number needs to be matched immediately after a \\gn in the regex.",
  "Matches the text matched by a previously named capture group.": "Matches the text matched by a previously named capture group.",
  "Matches the text matched by a previously named capture group. This is the python specific notation.": "Matches the text matched by a previously named capture group. This is the python specific notation.",
  "Matches the unicode character with the given hex value.": "Matches the unicode character with the given hex value.",
  "Matches uppercase letters. Equivalent to [A-Z]. [[:upper:]] is a POSIX notation and it needs to be inside a [character class] notation.": "Matches uppercase letters. Equivalent to [A-Z]. [[:upper:]] is a POSIX notation and it needs to be inside a [character class] notation.",
  "matches various symbols that are not math symbols, currency signs, or combining characters": "matches various symbols that are not math symbols, currency signs, or combining characters",
  "Matches whitespace characters. Equivalent to \\s. [[:space:]] is a POSIX notation and it needs to be inside a [character class] notation.": "Matches whitespace characters. Equivalent to \\s. [[:space:]] is a POSIX notation and it needs to be inside a [character class] notation.",
  "Matches zero or more consecutive `a` characters.": "Matches zero or more consecutive `a` characters.",
  "Matches, without consuming any characters, at the position between two characters matched by \\w.": "Matches, without consuming any characters, at the position between two characters matched by \\w.",
  "Matches, without consuming any characters, immediately between a character matched by \\w and a character not matched by \\w (in either order). It cannot be used to separate non words from words.": "Matches, without consuming any characters, immediately between a character matched by \\w and a character not matched by \\w (in either order). It cannot be used to separate non words from words.",
  "Max Execution Time": "Max Execution Time",
  "May only be used to define functions. No matching is done in this group.": "May only be used to define functions. No matching is done in this group.",
  "meaningless quantifier": "meaningless quantifier",
  "Meta Sequences": "Meta Sequences",
  "Most points": "Most points",
  "Most recent": "Most recent",
  "Multiline": "Multiline",
  "My Favorites": "Mis Favoritos",
  "My History": "Mi Historial",
  "My Library Entries": "Mis Entradas del Archivo",
  "My Regular Expressions": "Mis Expresiones Regulares",
  "Name or other identifier of the author": "Name or other identifier of the author",
  "Named Capture Group {1}": "Named Capture Group {1}",
  "Named capture groups can be called via {1}": "Named capture groups can be called via {1}",
  "Named Capturing Group": "Named Capturing Group",
  "Negation of \\h": "Negation of \\h",
  "Negation of \\p": "Negation of \\p",
  "Negation of \\pX": "Negation of \\pX",
  "Negation of \\v - anything except newlines and vertical tabs": "Negation of \\v - anything except newlines and vertical tabs",
  "Negative Lookahead": "Negative Lookahead",
  "Negative Lookbehind": "Negative Lookbehind",
  "Newline": "Newline",
  "no description available": "no description available",
  "No hex code was specified": "No hex code was specified",
  "No Match": "No Match",
  "No match groups were extracted.": "No match groups were extracted.",
  "Non-capturing group": "Non-capturing group",
  "Non-capturing Group. Matches the regex below with the following effective flags: {1}": "Non-capturing Group. Matches the regex below with the following effective flags: {1}",
  "Non-word boundary": "Non-word boundary",
  "Note: for Python 2.7 compatibility, use ur{1}{2} to prefix the regex and u\"\" to prefix the test string and substitution.": "Note: for Python 2.7 compatibility, use ur{1}{2} to prefix the regex and u\"\" to prefix the test string and substitution.",
  "Nothing to preview": "Nothing to preview",
  "Null character": "Null character",
  "Octal character ddd": "Octal character ddd",
  "Octal Character Table": "Octal Character Table",
  "Oh no!": "Oh no!",
  "Once `(?1)` is called, `(?(R1)true|false)` will return true since capture group 1 was called, and will match `ction`": "Once `(?1)` is called, `(?(R1)true|false)` will return true since capture group 1 was called, and will match `ction`",
  "Once we actually call `sub1` the conditional will return true, at which point `ction` matches.": "Once we actually call `sub1` the conditional will return true, at which point `ction` matches.",
  "one": "one",
  "One or more of a": "One or more of a",
  "Open regex in editor": "Open regex in editor",
  "Order By": "Order By",
  "Parts of the regex enclosed in parentheses may be referred to later in the expression or extracted from the results of a successful match.": "Parts of the regex enclosed in parentheses may be referred to later in the expression or extracted from the results of a successful match.",
  "Pattern Error": "Pattern Error",
  "Pattern may not end with a trailing backslash": "Pattern may not end with a trailing backslash",
  "Pattern modifier": "Pattern modifier",
  "Pattern strings will be treated as UTF-16, which means that unicode characters will also be included in [a-z] ranges, and in escape sequences.": "Pattern strings will be treated as UTF-16, which means that unicode characters will also be included in [a-z] ranges, and in escape sequences.",
  "Plain Text": "Plain Text",
  "Please enable JavaScript to use this web application.": "Please enable JavaScript to use this web application.",
  "Please keep in mind that these code samples are automatically generated and are not guaranteed to work. If you find any syntax errors, feel free to submit a bug report.": "Please keep in mind that these code samples are automatically generated and are not guaranteed to work. If you find any syntax errors, feel free to submit a bug report.",
  "Please upgrade your browser and come back.": "Please upgrade your browser and come back.",
  "Please wait while the app is loading...": "Please wait while the app is loading...",
  "Please wait while your expression is being debugged...": "Please wait while your expression is being debugged...",
  "Please wait while your request is being processed.": "Please wait while your request is being processed.",
  "pos: {1}-{2}": "pos: {1}-{2}",
  "Positive Lookahead": "Positive Lookahead",
  "Positive lookahead": "Positive lookahead",
  "Positive Lookbehind": "Positive Lookbehind",
  "possessive": "possessive",
  "Possessive quantifier": "Possessive quantifier",
  "Pre-define patterns before using them": "Pre-define patterns before using them",
  "Press {1} to copy": "Pulse {1} para copiar",
  "Preview": "Preview",
  "Print the match result": "Print the match result",
  "Print the result of the substitution": "Print the result of the substitution",
  "Proceed matching from where previous match ended only": "Proceed matching from where previous match ended only",
  "Processing...": "Processing...",
  "Quantifier": "Quantifier",
  "Quantifier range is too large": "Quantifier range is too large",
  "Quantifiers": "Quantifiers",
  "Quick Reference": "Quick Reference",
  "Quote; treat as literals": "Quote; treat as literals",
  "Quoted Literals": "Quoted Literals",
  "Quoted Literals: match the string enclosed in the quote literally": "Quoted Literals: match the string enclosed in the quote literally",
  "Recurse entire pattern": "Recurse entire pattern",
  "Recurse first relative subpattern": "Recurse first relative subpattern",
  "Recurse first subpattern": "Recurse first subpattern",
  "Recurse subpattern `name`": "Recurse subpattern `name`",
  "recurses the {1} subpattern": "recurses the {1} subpattern",
  "recurses the entire pattern": "recurses the entire pattern",
  "recurses the subpattern named {1}": "recurses the subpattern named {1}",
  "Recursive Conditional statement": "Recursive Conditional statement",
  "Recursively match the entire expression. (?0) and \\g<0> are synonymous. This is useful for balanced tags.": "Recursively match the entire expression. (?0) and \\g<0> are synonymous. This is useful for balanced tags.",
  "Recursively match the first capture group.": "Recursively match the first capture group.",
  "Recursively matches the given named capture group. Python supports (?P=named_group), but 'named group' has to be previously defined.": "Recursively matches the given named capture group. Python supports (?P=named_group), but 'named group' has to be previously defined.",
  "Recursively matches the given named subpattern or capture group.": "Recursively matches the given named subpattern or capture group.",
  "regex": "regex",
  "Regex Debugger": "Regex Debugger",
  "Regex Editor": "Regex Editor",
  "Regex engine modifier": "Regex engine modifier",
  "Regex Flags": "Regex Flags",
  "Regex Library": "Regex Library",
  "Regex Versions": "Regex Versions",
  "Regex will continue parsing the string keeping in mind the last match location. If the next match is not located directly after the last, this next match is discarded.": "Regex will continue parsing the string keeping in mind the last match location. If the next match is not located directly after the last, this next match is discarded.",
  "Regex101 only supports inline modifiers to be placed at the start of the regex for python (which is also best practice)": "Regex101 only supports inline modifiers to be placed at the start of the regex for python (which is also best practice)",
  "Regular Expression": "Regular Expression",
  "Remember that you can also delete this regex from the account page at any time.": "Remember that you can also delete this regex from the account page at any time.",
  "Remove from favorites": "Elimina de los favoritos",
  "Reset match": "Reset match",
  "resets the starting point of the reported match. Any previously consumed characters are no longer included in the final match": "resets the starting point of the reported match. Any previously consumed characters are no longer included in the final match",
  "Restrict matches to ASCII only": "Restrict matches to ASCII only",
  "result will be a String with the substituted value": "result will be a String with the substituted value",
  "result will be a tuple containing the start and end indices for the first match in the string": "result will be a tuple containing the start and end indices for the first match in the string",
  "result will be an iterator over tuples containing the start and end indices for each match in the string": "result will be an iterator over tuples containing the start and end indices for each match in the string",
  "Run tests": "Run tests",
  "Save": "Save",
  "Save & Share": "Save & Share",
  "Save Regex": "Save Regex",
  "Save Regular Expression": "Save Regular Expression",
  "Search library": "Search library",
  "Search reference": "Search reference",
  "Select Regex Version": "Select Regex Version",
  "Send me an email": "Send me an email",
  "Set Regex Options": "Set Regex Options",
  "Sets the given position in the regex as the new \"start\" of the match. This means that nothing preceding the K will be captured in the overall match.": "Sets the given position in the regex as the new \"start\" of the match. This means that nothing preceding the K will be captured in the overall match.",
  "sets the property mode to {1}": "sets the property mode to {1}",
  "sets the property mode to Unicode": "sets the property mode to Unicode",
  "Settings": "Settings",
  "shorthand for {1}": "shorthand for {1}",
  "Show informative and helpful tooltips when hovering tokens in the regex editor": "Show informative and helpful tooltips when hovering tokens in the regex editor",
  "Show Line Numbers in Regex Editor": "Show Line Numbers in Regex Editor",
  "Show Line Numbers in Test String Editor": "Show Line Numbers in Test String Editor",
  "Show Sidebar": "Show Sidebar",
  "Show tooltips": "Show tooltips",
  "Show Whitespace": "Show Whitespace",
  "Sign In": "Sign In",
  "Sign in with one of the providers below": "Sign in with one of the providers below",
  "Sign out": "Sign out",
  "Signing in allows you to add favorites as well as manage, make private, and delete your expressions.": "Signing in allows you to add favorites as well as manage, make private, and delete your expressions.",
  "Single line": "Single line",
  "Sorry!": "Sorry!",
  "Space or tab only": "Space or tab only",
  "specifies a newline convention: {1}, {2} or {3}": "specifies a newline convention: {1}, {2} or {3}",
  "specifies a newline convention: {1}, {2} or {3} only": "specifies a newline convention: {1}, {2} or {3} only",
  "specifies a newline convention: {1}, followed by {2}": "specifies a newline convention: {1}, followed by {2}",
  "specifies a newline convention: all unicode newline sequences {1}": "specifies a newline convention: all unicode newline sequences {1}",
  "specifies a newline convention: any Unicode newline sequence": "specifies a newline convention: any Unicode newline sequence",
  "specifies a newline convention: carriage return": "specifies a newline convention: carriage return",
  "specifies a newline convention: line-feed": "specifies a newline convention: line-feed",
  "Start of match": "Start of match",
  "Start of string": "Start of string",
  "Start of word": "Start of word",
  "Starting at the current position in the expression, ensures that the given pattern will not match. Does not consume characters.": "Starting at the current position in the expression, ensures that the given pattern will not match. Does not consume characters.",
  "starts with": "starts with",
  "Sticky - searches in strings only from the index of the last match": "Sticky - searches in strings only from the index of the last match",
  "Style": "Style",
  "Styling with Markdown is supported": "Styling with Markdown is supported",
  "Submit": "Submit",
  "Submit to Regex Library": "Submit to Regex Library",
  "Submitted by": "Submitted by",
  "Submitting entry, please wait.": "Submitting entry, please wait.",
  "Subpattern definition construct": "Subpattern definition construct",
  "Subpatterns declared within each alternative of this construct will start over from the same index": "Subpatterns declared within each alternative of this construct will start over from the same index",
  "Substitution": "Substitution",
  "Substitution result": "Substitution result",
  "suppresses the start-of-match optimizations that are otherwise run by Perl": "suppresses the start-of-match optimizations that are otherwise run by Perl",
  "Surrogates are disallowed": "Surrogates are disallowed",
  "Switch to Test Area": "Switch to Test Area",
  "Switch to Unit Tests {1}": "Switch to Unit Tests {1}",
  "Tab": "Tab",
  "Tags": "Tags",
  "Tells the engine not to stop after the first match has been found, but rather to continue until no more matches can be found.": "Tells the engine not to stop after the first match has been found, but rather to continue until no more matches can be found.",
  "Test String": "Test String",
  "The `Fork Regex` button will create a copy of this document, but one that you may modify, without altering this entry.": "The `Fork Regex` button will create a copy of this document, but one that you may modify, without altering this entry.",
  "The ^ and $ anchors now match at the beginning/end of each line respectively, instead of beginning/end of the entire string.": "The ^ and $ anchors now match at the beginning/end of each line respectively, instead of beginning/end of the entire string.",
  "The character offset is too large": "The character offset is too large",
  "The condition is invalid (you may be referencing a non-existent subpattern or group)": "The condition is invalid (you may be referencing a non-existent subpattern or group)",
  "The DEFINE group is completely ignored by regex. It gets treated as a var name=\"value\", whereas you can recall the specific pattern for use via its name. Multiple patterns can be defined in the same DEFINE group.": "The DEFINE group is completely ignored by regex. It gets treated as a var name=\"value\", whereas you can recall the specific pattern for use via its name. Multiple patterns can be defined in the same DEFINE group.",
  "The engine will per default do lazy matching, instead of greedy. This means that a ? following a quantifier instead makes it greedy.": "The engine will per default do lazy matching, instead of greedy. This means that a ? following a quantifier instead makes it greedy.",
  "The escape sequence to match backspace is not supported in the selected flavor": "The escape sequence to match backspace is not supported in the selected flavor",
  "The match was halted because the offset does not point to the beginning of a valid UTF-16 character.": "The match was halted because the offset does not point to the beginning of a valid UTF-16 character.",
  "The owner of this permalink has locked it and as such, nobody but the creator may edit it.": "The owner of this permalink has locked it and as such, nobody but the creator may edit it.",
  "The pattern is forced to become anchored, equal to a ^.": "The pattern is forced to become anchored, equal to a ^.",
  "The PCRE regex engine automatically applies some internal optimizations to regexes to avoid unnecessary backtracking. This modifier will disable that behavior, and thus the engine will backtrack until the previously matching instruction fails to do so.": "The PCRE regex engine automatically applies some internal optimizations to regexes to avoid unnecessary backtracking. This modifier will disable that behavior, and thus the engine will backtrack until the previously matching instruction fails to do so.",
  "The posix class is unknown/invalid": "The posix class is unknown/invalid",
  "The preceding token is not quantifiable": "The preceding token is not quantifiable",
  "The quantifier range is out of order": "The quantifier range is out of order",
  "The range is invalid because either the left or right token is erroneous": "The range is invalid because either the left or right token is erroneous",
  "The range is invalid because the rightmost token is not rangeable": "The range is invalid because the rightmost token is not rangeable",
  "The regex debugger returned no data for the input you provided.": "The regex debugger returned no data for the input you provided.",
  "The regex debugger was unable to debug your pattern due to an error.": "The regex debugger was unable to debug your pattern due to an error.",
  "The regex did not match the subject string.": "The regex did not match the subject string.",
  "The regex formatter is only able to format the parts of the regex affected by the x-flag (ignore whitespace).": "The regex formatter is only able to format the parts of the regex affected by the x-flag (ignore whitespace).",
  "The result can be accessed through the `m`-variable.": "The result can be accessed through the `m`-variable.",
  "The result of the substitution is": "The result of the substitution is",
  "the string": "the string",
  "The substituted value will be contained in the result variable": "The substituted value will be contained in the result variable",
  "The token is incomplete": "The token is incomplete",
  "The value specified is too large": "The value specified is too large",
  "Theme": "Theme",
  "There are no unit tests yet; add some!": "There are no unit tests yet; add some!",
  "There are too many alternatives within the parent structure": "There are too many alternatives within the parent structure",
  "There is no need to save these urls as they are stored on your account and can be found on the account page. You may at any time delete or modify your library entry from there.": "There is no need to save these urls as they are stored on your account and can be found on the account page. You may at any time delete or modify your library entry from there.",
  "There seems to be nothing here!": "There seems to be nothing here!",
  "There was a problem trying to fetch the library data. Please try again later.": "There was a problem trying to fetch the library data. Please try again later.",
  "There was a problem when trying to fetch the details for this entry. Please try again later.": "There was a problem when trying to fetch the details for this entry. Please try again later.",
  "There was a problem while trying to submit your regex to the library. Please try again later.": "There was a problem while trying to submit your regex to the library. Please try again later.",
  "There was an error trying to save your regex. Please try again later.": "There was an error trying to save your regex. Please try again later.",
  "There was an error while fetching your account data. Please try again later.": "No pude cargar los datos de tú cuenta. Por favor, inténtelo nuevamente más tarde.",
  "These enable setting regex flags within the expression itself. You can also unset flags using a minus sign: (?-i)": "These enable setting regex flags within the expression itself. You can also unset flags using a minus sign: (?-i)",
  "This allows regex to accept duplicate pattern names, however each capture group still has its own ID. Thus the two capture groups produce their own match instead of a single combined one.": "This allows regex to accept duplicate pattern names, however each capture group still has its own ID. Thus the two capture groups produce their own match instead of a single combined one.",
  "This allows regex to treat the string as UTF-16, specifically.": "This allows regex to treat the string as UTF-16, specifically.",
  "This allows regex to treat the string as UTF-32, specifically.": "This allows regex to treat the string as UTF-32, specifically.",
  "This allows regex to treat the string as UTF-8, specifically.": "This allows regex to treat the string as UTF-8, specifically.",
  "This allows regex to treat the string as UTF, be it 8, 16, or 32.": "This allows regex to treat the string as UTF, be it 8, 16, or 32.",
  "This capturing group can be referred to using the given name instead of a number. Alternative notation for (?'name'...) and (?P<name>...).": "This capturing group can be referred to using the given name instead of a number. Alternative notation for (?'name'...) and (?P<name>...).",
  "This capturing group can be referred to using the given name instead of a number. Alternative notation for (?<name>...) and (?'name'...) when using a PCRE flavor.": "This capturing group can be referred to using the given name instead of a number. Alternative notation for (?<name>...) and (?'name'...) when using a PCRE flavor.",
  "This capturing group can be referred to using the given name instead of a number. Alternative notation for (?<name>...) and (?P<name>...).": "This capturing group can be referred to using the given name instead of a number. Alternative notation for (?<name>...) and (?P<name>...).",
  "This causes the regex to end successfully, skipping the rest of the pattern.": "This causes the regex to end successfully, skipping the rest of the pattern.",
  "This construct is similar to (...), but won't create a capture group.": "This construct is similar to (...), but won't create a capture group.",
  "This enables the dot (.) metacharacter to also match new lines. The string could be visualised as a single line input.": "This enables the dot (.) metacharacter to also match new lines. The string could be visualised as a single line input.",
  "This flag does not exist in Python2, as by default your script is parsed in ascii mode. In Python3 this will behave as described.": "This flag does not exist in Python2, as by default your script is parsed in ascii mode. In Python3 this will behave as described.",
  "This flag tells the engine to ignore all whitespace and allow for comments in the regex. Comments are indicated by a starting \"#\"-character. If you need to include a space character in your regex, it must now be escaped '\\ '.": "This flag tells the engine to ignore all whitespace and allow for comments in the regex. Comments are indicated by a starting \"#\"-character. If you need to include a space character in your regex, it must now be escaped '\\ '.",
  "This group does not allow any backtracking to occur": "This group does not allow any backtracking to occur",
  "This is an alternate syntax for \\k<name> or \\k'name' and it is valid for .NET. Note that you cannot use curly brackets (?{name}a+) to name a capture group in PCRE": "This is an alternate syntax for \\k<name> or \\k'name' and it is valid for .NET. Note that you cannot use curly brackets (?{name}a+) to name a capture group in PCRE",
  "This is an alternate syntax for \\k<name> or \\k{name}.": "This is an alternate syntax for \\k<name> or \\k{name}.",
  "This is because it would otherwise break the functionality of the regular expression.": "This is because it would otherwise break the functionality of the regular expression.",
  "This is necessary to avoid infinite loops with zero-width matches": "This is necessary to avoid infinite loops with zero-width matches",
  "This is to avoid confusion for anyone else viewing this permalink and to not corrupt the authors work.": "This is to avoid confusion for anyone else viewing this permalink and to not corrupt the authors work.",
  "This link will only be presented to you once! Save it if you want to be able to delete your regex in the future.": "This link will only be presented to you once! Save it if you want to be able to delete your regex in the future.",
  "This may be used to match the literal value of any metacharacter, or the / delimiter.": "This may be used to match the literal value of any metacharacter, or the / delimiter.",
  "This means that your pattern did match but there were no capturing groups that matched anything in the subject string.": "This means that your pattern did match but there were no capturing groups that matched anything in the subject string.",
  "This metacharacter matches any unicode newline character or sequence thereof. Its behavior can be controlled by (*UTF) pattern modifiers. In (*UTF8) mode, '\\R' will match the line separator, paragraph separator, carriage return, carriage return & newline sequence, line feed, vertical tab, form feed, and next line. When outside (*UTF8) mode, line and paragraph separators are not matched. Newline conventions can also be specified via (*BSR_ANYCRLF) and (*BSR_UNICODE)": "This metacharacter matches any unicode newline character or sequence thereof. Its behavior can be controlled by (*UTF) pattern modifiers. In (*UTF8) mode, '\\R' will match the line separator, paragraph separator, carriage return, carriage return & newline sequence, line feed, vertical tab, form feed, and next line. When outside (*UTF8) mode, line and paragraph separators are not matched. Newline conventions can also be specified via (*BSR_ANYCRLF) and (*BSR_UNICODE)",
  "This POSIX equivalent of the \"\\b\" word boundary is interpreted as": "This POSIX equivalent of the \"\\b\" word boundary is interpreted as",
  "This POSIX equivalent of the `\\\\b` word boundary is interpreted as {1}": "This POSIX equivalent of the `\\\\b` word boundary is interpreted as {1}",
  "This script is unknown/invalid": "This script is unknown/invalid",
  "This sets the convention for newline matching to '\\r\\n','\\r', or '\\n' for things like the '\\R' metacharacter.": "This sets the convention for newline matching to '\\r\\n','\\r', or '\\n' for things like the '\\R' metacharacter.",
  "This sets the convention for newline matching to any unicode newline character or sequence thereof, for things like the '\\R' metacharacter.": "This sets the convention for newline matching to any unicode newline character or sequence thereof, for things like the '\\R' metacharacter.",
  "This setting adjusts the site-wide theme.": "This setting adjusts the site-wide theme.",
  "This setting affects how long the matcher will try to match your regex before it decides to give up.": "This setting affects how long the matcher will try to match your regex before it decides to give up.",
  "This setting determines whether groups in your regex, which did not match anything in the subject string, should be included in the results or not.": "This setting determines whether groups in your regex, which did not match anything in the subject string, should be included in the results or not.",
  "This token can not be used in a lookbehind as it makes it non-fixed width": "This token can not be used in a lookbehind as it makes it non-fixed width",
  "This token does nothing without a corresponding open quote tag (\\Q). If you meant to match a literal `E`, remove the backslash": "This token does nothing without a corresponding open quote tag (\\Q). If you meant to match a literal `E`, remove the backslash",
  "This token has no special meaning and has thus been rendered erroneous": "This token has no special meaning and has thus been rendered erroneous",
  "This token is not supported in the selected flavor": "This token is not supported in the selected flavor",
  "This token must be escaped when the `u` flag is enabled unless they form a valid quantifier": "This token must be escaped when the `u` flag is enabled unless they form a valid quantifier",
  "This token references a non-existent or invalid subpattern": "This token references a non-existent or invalid subpattern",
  "this verb causes the match to end successfully, skipping the remainder of the pattern": "this verb causes the match to end successfully, skipping the remainder of the pattern",
  "this verb causes the match to fail at the current starting position in the subject if the rest of the pattern does not match": "this verb causes the match to fail at the current starting position in the subject if the rest of the pattern does not match",
  "This verb does not allow regex to continue parsing after a matching failure, even if there are other matching strings ahead, and regardless of how many successful matches are before the failure.": "This verb does not allow regex to continue parsing after a matching failure, even if there are other matching strings ahead, and regardless of how many successful matches are before the failure.",
  "This verb is unknown or invalid": "This verb is unknown or invalid",
  "This verb must be placed at the start of the regex": "This verb must be placed at the start of the regex",
  "This will match only at the starting point of the search or the position the previous successful match ended. Useful with the /g flag, or when you are only trying to match after a certain point in a string.": "This will match only at the starting point of the search or the position the previous successful match ended. Useful with the /g flag, or when you are only trying to match after a certain point in a string.",
  "This will return a portion of the source string that follows the match.": "This will return a portion of the source string that follows the match.",
  "This will return a portion of the source string that precedes the match.": "This will return a portion of the source string that precedes the match.",
  "This will return a string with the complete match result from the regex.": "This will return a string with the complete match result from the regex.",
  "This will return a string with the contents from the capture group named `foo`. Any name can be used as long as it is defined in the regex. If the J-flag is specified, content will be taken from the first capture group with the same name.": "This will return a string with the contents from the capture group named `foo`. Any name can be used as long as it is defined in the regex. If the J-flag is specified, content will be taken from the first capture group with the same name.",
  "This will return a string with the contents from the capture group named `foo`. Any name can be used as long as it is defined in the regex. This syntax is made up and specific to only Regex101. If the J-flag is specified, content will be taken from the first capture group with the same name.": "This will return a string with the contents from the capture group named `foo`. Any name can be used as long as it is defined in the regex. This syntax is made up and specific to only Regex101. If the J-flag is specified, content will be taken from the first capture group with the same name.",
  "This will return a string with the contents from the first capture group. The number, in this case 1, can be any number as long as it corresponds to a valid capture group.": "This will return a string with the contents from the first capture group. The number, in this case 1, can be any number as long as it corresponds to a valid capture group.",
  "time": "time",
  "Timeout": "Timeout",
  "times": "times",
  "Title": "Title",
  "Title of regular expression": "Title of regular expression",
  "Tools": "Tools",
  "Twitter": "Twitter",
  "UCP (Unicode Character Properties) allows regex to treat the string as unicode, which means that \\d and \\w are extended to match other unicode characters than [0-9] and [a-zA-Z0-9_].": "UCP (Unicode Character Properties) allows regex to treat the string as unicode, which means that \\d and \\w are extended to match other unicode characters than [0-9] and [a-zA-Z0-9_].",
  "Unable to fetch versions": "Unable to fetch versions",
  "Undescribed specific verb; No description for it yet (nothing's perfect)": "Undescribed specific verb; No description for it yet (nothing's perfect)",
  "Unfavorite Regex": "Unfavorite Regex",
  "Unfortunately it seems your browser does not meed the criteria to properly render and utilize this website.": "Unfortunately it seems your browser does not meed the criteria to properly render and utilize this website.",
  "Ungreedy": "Ungreedy",
  "Unicode": "Unicode",
  "Unicode Character Table": "Unicode Character Table",
  "Unicode newlines": "Unicode newlines",
  "Unicode property or script category": "Unicode property or script category",
  "Unicode property X": "Unicode property X",
  "Unit Tests": "Unit Tests",
  "unlimited": "unlimited",
  "Unmatched parenthesis": "Unmatched parenthesis",
  "Unspecified unit test": "Unspecified unit test",
  "Update Library Entry": "Update Library Entry",
  "Update Regex": "Update Regex",
  "Update Regular Expression": "Update Regular Expression",
  "Upload to Library": "Upload to Library",
  "uppercase": "uppercase",
  "Uppercase letters": "Uppercase letters",
  "Usually referred to as a `backreference`, this will match a repeat of the text captured in a previous set of parentheses.": "Usually referred to as a `backreference`, this will match a repeat of the text captured in a previous set of parentheses.",
  "verb synonymous with {1}. Forces a matching failure at the given position in the pattern": "verb synonymous with {1}. Forces a matching failure at the given position in the pattern",
  "Version {1}": "Version {1}",
  "Vertical whitespace character": "Vertical whitespace character",
  "View account": "View account",
  "View Explanation": "View Explanation",
  "View Match Information": "View Match Information",
  "View Regex Quick Reference": "View Regex Quick Reference",
  "Visible characters": "Visible characters",
  "Visible characters (not space)": "Visible characters (not space)",
  "Visible punctuation characters": "Visible punctuation characters",
  "Whitespace": "Whitespace",
  "Whole match is {1} and its start/end positions can be obtained via {2} and {3}": "Whole match is {1} and its start/end positions can be obtained via {2} and {3}",
  "Wiki": "Wiki",
  "Wiki (Info & FAQ)": "Wiki (Info & FAQ)",
  "with no special consideration for the \\r\\n sequence": "with no special consideration for the \\r\\n sequence",
  "Word characters": "Word characters",
  "Wrap Long Lines": "Wrap Long Lines",
  "Write": "Write",
  "You are seeing this message because your expression is either already formatted or nothing else could be done to it without breaking functionality.": "You are seeing this message because your expression is either already formatted or nothing else could be done to it without breaking functionality.",
  "You can manually specify the number of replacements by changing the 4th argument": "You can manually specify the number of replacements by changing the 4th argument",
  "You can not create a range with a shorthand escape sequences": "You can not create a range with a shorthand escape sequences",
  "You can not set both the `a` and `u` flag simultaneously": "You can not set both the `a` and `u` flag simultaneously",
  "You can use hexadecimals to insert any character into the replacement string using the standard syntax.": "You can use hexadecimals to insert any character into the replacement string using the standard syntax.",
  "You can't do that!": "You can't do that!",
  "You have made changes since you last saved, leaving the website will result in a permanent loss of the data.": "You have made changes since you last saved, leaving the website will result in a permanent loss of the data.",
  "You have no tags yet, add some and organize your entries!": "You have no tags yet, add some and organize your entries!",
  "You have not added anything to your favorites yet.": "You have not added anything to your favorites yet.",
  "You have not created anything yourself yet.": "You have not created anything yourself yet.",
  "You have not submitted anything to the library yet.": "Todavía no has entregado nada en el archivo.",
  "You must be signed in to vote": "You must be signed in to vote",
  "You will find a link to your library entry here:": "You will find a link to your library entry here:",
  "Your entry has successfully been submitted to the library": "Your entry has successfully been submitted to the library",
  "Your expression caused an unhandled error:": "Your expression caused an unhandled error:",
  "Your expression took too long to finish and was terminated. Please increase the timeout and try again.": "Your expression took too long to finish and was terminated. Please increase the timeout and try again.",
  "Your history is empty.": "No hay entradas en tú historial.",
  "Your pattern contains one or more errors, please see the explanation section above.": "Your pattern contains one or more errors, please see the explanation section above.",
  "Your regex has been permanently saved and may be accessed with this link by anybody you give it to. {1}": "Your regex has been permanently saved and may be accessed with this link by anybody you give it to. {1}",
  "Your regular expression does not match the subject string.": "Your regular expression does not match the subject string.",
  "Your tag filtration returned no results.": "No encontre nada con esta etiqueta",
  "Your workspace has been forked into a separate entry that only you can modify, which you can find here": "Your workspace has been forked into a separate entry that only you can modify, which you can find here",
  "zero": "zero",
  "Zero or more of a": "Zero or more of a",
  "Zero or one of a": "Zero or one of a"
}