{

"'{0}' found at index {1}": "'{০}' পাওয়া গেছে ইনডেক্স {১} এ",

"(except for line terminators)": "(except for line terminators)",

"{1} a backspace character {2}": "{1} a backspace character {2}",

"{1} a carriage return {2}": "{1} a carriage return {2}",

"{1} a form-feed character {2}": "{1} a form-feed character {2}",

"{1} a line-feed (newline) character {2}": "{1} a line-feed (newline) character {2}",

"{1} a tab character {2}": "{1} a tab character {2}",

"{1} a vertical tab character {2}": "{1} a vertical tab character {2}",

"{1} Alternative": "{1} Alternative",

"{1} always fails to match": "{1} always fails to match",

"{1} always finds a zero-length match": "{1} always finds a zero-length match",

"{1} and {2} are also available with the use of '{3}'": "{1} and {2} are also available with the use of '{3}'",

"{1} and {2} match start/end of line": "{1} and {2} match start/end of line",

"{1} can be used to match the same text the third preceding capture group matched and captured.": "{1} can be used to match the same text the third preceding capture group matched and captured.",

"{1} Capturing Group": "{1} Capturing Group",

"{1} esc {2}": "{1} esc {2}",

"{1} is a line separator which can stand for {2}, {3}, {4}, or {5}.": "{1} is a line separator which can stand for {2}, {3}, {4}, or {5}.",

"{1} is a paragraph separator (PS) character.": "{1} is a paragraph separator (PS) character.",

"{1} is NEL, next line character.": "{1} is NEL, next line character.",

"{1} matches only end of pattern": "{1} matches only end of pattern",

"{1} modifier:": "{1} modifier:",

"{1} or {2}": "{1} or {2}",

"{1} subpattern": "{1} subpattern",

"{1} the bell character {2}": "{1} the bell character {2}",

"{1} to {2}": "{1} to {2}",

"{1} upvotes, {2} downvotes (score {3}%)": "{1} upvotes, {2} downvotes (score {3}%)",

"{1} warmup configured": "{1} warmup configured",

"{1} warmup excluded, {2} runs, avg {3}": "{1} warmup excluded, {2} runs, avg {3}",

"{1} would be the second previous capture group, for example. {2} would be the third capture group.": "{1} would be the second previous capture group, for example. {2} would be the third capture group.",

"{1}, match this regex:": "{1}, match this regex:",

"{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 capturing groups {2} are instead treated as if they were non-capturing groups {3}.": "{1}. All capturing groups {2} are instead treated as if they were non-capturing groups {3}.",

"{1}. All line terminators are recognized in the behavior of {3}, {4}, and {5}.": "{1}. All line terminators are recognized in the behavior of {3}, {4}, and {5}.",

"{1}. All matches (don't return after first match)": "{1}. All matches (don't return after first match)",

"{1}. Apply case insensitive matching to unicode characters in accordance with the unicode standard": "{1}. Apply case insensitive matching to unicode characters in accordance with the unicode standard",

"{1}. Capturing groups {2} are no longer treated as if they were non-capturing groups {3}.": "{1}. Capturing groups {2} are no longer treated as if they were non-capturing groups {3}.",

"{1}. Case insensitive match (ignores case of {2})": "{1}. Case insensitive match (ignores case of {2})",

"{1}. Case insensitive matching is only applied to the US-ASCII character set": "{1}. Case insensitive matching is only applied to the US-ASCII character set",

"{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 and additional character class set features. This is an extension of the existing {2}-flag": "{1}. Enable all unicode and additional character class set features. This is an extension of the existing {2}-flag",

"{1}. Enable matching using an approach that avoids backtracking and guarantees linear-time processing in the length of the input.": "{1}. Enable matching using an approach that avoids backtracking and guarantees linear-time processing in the length of the input.",

"{1}. Enable the built in character classes to also match unicode characters": "{1}. Enable the built in character classes to also match unicode characters",

"{1}. Enables all unicode features, but does not affect short hand classes": "{1}. Enables all unicode features, but does not affect short hand classes",

"{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}. Only the {2} line terminator is recognized in the behavior of {3}, {4}, and {5}.": "{1}. Only the {2} line terminator is recognized in the behavior of {3}, {4}, and {5}.",

"{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}. Spaces and text after a {2} in the pattern are ignored (even whitespace inside character classes)": "{1}. Spaces and text after a {2} in the pattern are ignored (even whitespace inside character classes)",

"{1}. The .NET regex engine now now performs matches from right to left, instead of left ro right.": "{1}. The .NET regex engine now now performs matches from right to left, instead of left ro right.",

"{1}. The JavaScript regex engine now returns the indices at which the regex matched in the subject string.": "{1}. The JavaScript regex engine now returns the indices at which the regex matched in the subject string.",

"{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}. The pattern is forced to become anchored at the start of the search, or at the position of the last successful match, equivalent to a {2}": "{1}. The pattern is forced to become anchored at the start of the search, or at the position of the last successful match, equivalent to a {2}",

"{1}. Treats {2} as a single line break": "{1}. Treats {2} as a single line break",

"{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.",

"3 or more of a": "3 or more of a",

"A {1} warmup phase is excluded before measured samples begin.": "A {1} warmup phase is excluded before measured samples begin.",

"A {1} warmup phase ran before measurement began. {2} warmup runs were excluded. Avg warmup latency: {3}.": "A {1} warmup phase ran before measurement began. {2} warmup runs were excluded. Avg warmup latency: {3}.",

"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 common misconception is that repeating a capture group would create separate IDs for each time it matches. If that functionality is needed, one has to rely on the global (/g) flag instead. For example: {1}": "A common misconception is that repeating a capture group would create separate IDs for each time it matches. If that functionality is needed, one has to rely on the global (/g) flag instead. For example: {1}",

"A few of the latest notes from people who support regex101.": "A few of the latest notes from people who support regex101.",

"A free account gives your regex work a proper home. Save expressions, organize them with titles and tags, keep favorites close at hand, and decide what stays private. Upgrading to Pro supports the project, removes sponsor placements, and expands the paid feature set over time. Review the plans below for details, and continue when you're ready.": "A free account gives your regex work a proper home. Save expressions, organize them with titles and tags, keep favorites close at hand, and decide what stays private. Upgrading to Pro supports the project, removes sponsor placements, and expands the paid feature set over time. Review the plans below for details, and continue when you're ready.",

"a line": "a line",

"A lookbehind assertion has to be fixed width": "A lookbehind assertion has to be fixed width",

"A negated character class in JavaScript {1} mode cannot contain a {2} branch that matches a string": "A negated character class in JavaScript {1} mode cannot contain a {2} branch that matches a string",

"A non-atomic assertion that rescans the content of the listed capture groups using the given pattern. Shorthand: {1}.": "A non-atomic assertion that rescans the content of the listed capture groups using the given pattern. Shorthand: {1}.",

"A non-capturing group allows you to apply quantifiers to part of your regex but does not capture/assign an ID.": "A non-capturing group allows you to apply quantifiers to part of your regex but does not capture/assign an ID.",

"A posix character class may only appear inside a character class": "A posix character class may only appear inside a character class",

"A private setup for security-sensitive teams": "A private setup for security-sensitive teams",

"A quantifier inside a lookbehind makes it non-fixed width": "A quantifier inside a lookbehind makes it non-fixed width",

"A quote without content has ambiguous behavior and should be avoided": "A quote without content has ambiguous behavior and should be avoided",

"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 of: a, b or c": "A single character of: a, b or c",

"A single character of: a, b, c or d": "A single character of: a, b, c or d",

"A special thanks goes out to the following individuals for their hard work and contributions to the quiz:": "A special thanks goes out to the following individuals for their hard work and contributions to the quiz:",

"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",

"Access Link": "Access Link",

"Account": "Account",

"Account Page": "Account Page",

"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",

"Ad free workspace": "Ad free workspace",

"Add a public note": "Add a public note",

"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 Regex to the Community Pattern Library": "Add Regex to the Community Pattern Library",

"Add tag": "Add tag",

"Add test": "Add test",

"Add to Community Library": "Add to Community Library",

"Add to Favorites": "Add to Favorites",

"Added entry to your list of favorites ({1})": "Added entry to your list of favorites ({1})",

"Adds match indices to the result, including the start and end positions for capture groups.": "Adds match indices to the result, including the start and end positions for capture groups.",

"Adjust the threshold at which the left sidebar will collapse and hide. If the viewport is smaller than the set width, it is hidden, otherwise visible.": "Adjust the threshold at which the left sidebar will collapse and hide. If the viewport is smaller than the set width, it is hidden, otherwise visible.",

"Adjust the threshold at which the right sidebar will collapse and hide. If the viewport is smaller than the set width, it is hidden, otherwise visible.": "Adjust the threshold at which the right sidebar will collapse and hide. If the viewport is smaller than the set width, it is hidden, otherwise visible.",

"Advanced Regex Benchmarking": "Advanced Regex Benchmarking",

"After a long time in development, you can now finally enjoy {1}, directly on your desktop. The application supports all the features you know and love without any requirement for an internet connection or browser.": "After a long time in development, you can now finally enjoy {1}, directly on your desktop. The application supports all the features you know and love without any requirement for an internet connection or browser.",

"After you have finished a task you can continue improving upon your solution, making it shorter, and climb higher into the leader boards.": "After you have finished a task you can continue improving upon your solution, making it shorter, and climb higher into the leader boards.",

"Air-gapped deployment support when required": "Air-gapped deployment support when required",

"Align indentation, groups, and comments for faster review": "Align indentation, groups, and comments for faster review",

"All associated data with your account will be permanently deleted, such as your saved expressions, your library entries, and your quiz progression.": "All associated data with your account will be permanently deleted, such as your saved expressions, your library entries, and your quiz progression.",

"All available": "All available",

"All capturing groups {1} are instead treated as if they were non-capturing groups {2}.": "All capturing groups {1} are instead treated as if they were non-capturing groups {2}.",

"All Entries": "All Entries",

"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",

"All versions": "All versions",

"Allow duplicate subpattern names": "Allow duplicate subpattern names",

"Allows case insensitive matching of unicode characters, not only US-ASCII.": "Allows case insensitive matching of unicode characters, not only US-ASCII.",

"Allows regex to match unicode characters via dotall and unicode escape sequences, as well as ES6 unicode code point escapes such as {1} which is made up of {2}.": "Allows regex to match unicode characters via dotall and unicode escape sequences, as well as ES6 unicode code point escapes such as {1} which is made up of {2}.",

"Alphabetic lookaround assertions": "Alphabetic lookaround assertions",

"Already Pro? Sign in": "Already Pro? Sign in",

"Also known as global mode, it instruct the engine not to stop after the first match has been found, but rather to continue until no more matches can be found.": "Also known as global mode, it instruct the engine not to stop after the first match has been found, but rather to continue until no more matches can be found.",

"Alternate - match either a or b": "Alternate - match either a or b",

"Alternative": "Alternative",

"Alternative notation for {1}": "Alternative notation for {1}",

"Always collapse left sidebar": "Always collapse left sidebar",

"Always collapse right sidebar": "Always collapse right sidebar",

"Amount": "Amount",

"An alternate way to match alphabet letters. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "An alternate way to match alphabet letters. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.",

"An alternate way to match any letter or digit. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "An alternate way to match any letter or digit. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.",

"An error occurred while fetching the resource": "An error occurred while fetching the resource",

"An error occurred while trying to load the resource, please refresh and try again": "An error occurred while trying to load the resource, please refresh and try again",

"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, use {1}": "An unescaped delimiter must be escaped, use {1}",

"Anchor": "Anchor",

"Anchor to start of pattern, or at the end of the most recent match": "Anchor to start of pattern, or at the end of the most recent match",

"Anchors": "Anchors",

"and": "and",

"anonymous": "anonymous",

"Anonymous": "anonymous",

"Another option is enabling the x flag to allow `# comments` but it will also cause the regex engine to ignore space characters. To match space characters you have to escape them: {1}.": "Another option is enabling the x flag to allow `# comments` but it will also cause the regex engine to ignore space characters. To match space characters you have to escape them: {1}.",

"Any character following a {1} that is not a valid meta sequence will be faulted and raise an error. {2}, for example, will cause an error, and it will not match.": "Any character following a {1} that is not a valid meta sequence will be faulted and raise an error. {2}, for example, will cause an error, and it will not match.",

"Any characters between {1} and {2}, including metacharacters, will be treated as literals.": "Any characters between {1} and {2}, 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 text appearing in this group is ignored in the regex.": "Any text appearing in this group is ignored in the regex.",

"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",

"Appearance": "Appearance",

"Appreciate it!": "Appreciate it!",

"Are you sure you want to delete this community entry?": "Are you sure you want to delete this community entry?",

"Are you sure you want to delete this regex? This action is non-reversible and will delete all versions of this regex.": "Are you sure you want to delete this regex? This action is non-reversible and will delete all versions of this regex.",

"Are you sure you want to delete your account?": "Are you sure you want to delete your account?",

"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 {1} {2}": "assert that {1} {2}",

"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",

"At Sign": "At Sign",

"Atomic Group": "Atomic Group",

"Atomic group (non-capturing)": "Atomic group (non-capturing)",

"Atomic Script Run": "Atomic Script Run",

"Author": "Author",

"Automatic": "Automatic",

"Automatic test execution": "Automatic test execution",

"Automatic will infer the preferred theme from the host system": "Automatic will infer the preferred theme from the host system",

"Average {1}": "Average {1}",

"Avoid using this legacy syntax for any new patterns": "Avoid using this legacy syntax for any new patterns",

"Back to regex101": "Back to regex101",

"Backer": "Backer",

"Backreference": "Backreference",

"Backreferences may not be placed inside character classes. If you meant to create an octal escape, prefix the escape with a 0.": "Backreferences may not be placed inside character classes. If you meant to create an octal escape, prefix the escape with a 0.",

"Backspace": "Backspace",

"Backspace character": "Backspace character",

"Backtick": "Backtick",

"Backticks can not be used in a raw string, use {1} instead": "Backticks can not be used in a raw string, use {1} instead",

"Bad subpattern name. Ensure it does not contain anything but letters and digits": "Bad subpattern name. Ensure it does not contain anything but letters and digits",

"Bad subpattern name. Ensure it is alpha numeric and does not begin with a digit": "Bad subpattern name. Ensure it is alpha numeric and does not begin with a digit",

"Balancing Group": "Balancing Group",

"Balancing Named Capturing Group": "Balancing Named Capturing Group",

"Balancing Named Capturing Group {1}": "Balancing Named Capturing Group {1}",

"Balancing Non-capturing Group": "Balancing Non-capturing Group",

"Because of this, you are now running a local-only (offline) version. You will still be able to use all the base function of the applications like before, but some features that require a connection with the server might not work.": "Because of this, you are now running a local-only (offline) version. You will still be able to use all the base function of the applications like before, but some features that require a connection with the server might not work.",

"Because you are not signed in this entry has not been linked to an account. It is recommended you sign in so that your entries are never lost and you can manage them from the account page whenever you like.": "Because you are not signed in this entry has not been linked to an account. It is recommended you sign in so that your entries are never lost and you can manage them from the account page whenever you like.",

"Become a Github Sponsor": "Become a Github Sponsor",

"Become a sponsor today!": "Become a sponsor today!",

"Become a Supporter": "Become a Supporter",

"Become an Enterprise Sponsor": "Become an Enterprise Sponsor",

"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.",

"Bell": "Bell",

"Benchmark Evaluation Period": "Benchmark Evaluation Period",

"Benchmark Regex": "Benchmark Regex",

"Benchmarking runs on your local system. Compare patterns, flags, and test inputs only under identical conditions, and judge median, p95, jitter, and throughput together.": "Benchmarking runs on your local system. Compare patterns, flags, and test inputs only under identical conditions, and judge median, p95, jitter, and throughput together.",

"Better than": "Better than",

"Between 3 and 6 of a": "Between 3 and 6 of a",

"bidi-class": "bidi-class",

"Billing period": "Billing period",

"binary": "binary",

"block": "block",

"Branch Reset Group": "Branch Reset Group",

"Bucket width": "Bucket width",

"Buckets": "Buckets",

"Buy now!": "Buy now!",

"By default, {1} matches any unicode newline character or sequence thereof. Its behavior can be controlled by newline convention verbs like {2} or {3}.": "By default, {1} matches any unicode newline character or sequence thereof. Its behavior can be controlled by newline convention verbs like {2} or {3}.",

"Callout": "Callout",

"Cancel": "Cancel",

"Cannot format regex right now": "Cannot format regex right now",

"Cannot open export matches right now": "Cannot open export matches right now",

"Cannot open the code generator right now": "Cannot open the code generator right now",

"Cannot open the regex debugger right now": "Cannot open the regex debugger right now",

"Cannot run benchmark right now": "Cannot run benchmark right now",

"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}",

"Capturing Group": "Capturing Group",

"Capturing group": "Capturing group",

"Carriage return": "Carriage return",

"case insensitive": "case insensitive",

"Case insensitive": "Case insensitive",

"Case insensitive match": "Case insensitive match",

"Case insensitive matching affects unicode characters as well": "Case insensitive matching affects unicode characters as well",

"Case Modifier": "Case Modifier",

"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 and 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 and what this is, please read the following article:",

"Category": "Category",

"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 regex engine to give up on the current match if it tries to backtrack past {1}'s position. This is useful when looking to cut down on backtracking at specific points in the regex. Equivalent to {2}.": "Causes the regex engine to give up on the current match if it tries to backtrack past {1}'s position. This is useful when looking to cut down on backtracking at specific points in the regex. Equivalent to {2}.",

"Causes the regex to exit if it tries to backtrack past {1}'s position. This is useful when looking to cut down on backtracking at specific points in the regex. Equivalent to {2}.": "Causes the regex to exit if it tries to backtrack past {1}'s position. This is useful when looking to cut down on backtracking at specific points in the regex. Equivalent to {2}.",

"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",

"Change Mode to Read & Write": "Change Mode to Read & Write",

"Change Mode to Read Only": "Change Mode to Read Only",

"Changes line break recognition so that only {1} is treated as a line terminator.": "Changes line break recognition so that only {1} is treated as a line terminator.",

"Character Class": "Character Class",

"Character class intersection": "Character class intersection",

"Character class missing closing bracket": "Character class missing closing bracket",

"Character Class Quote": "Character Class Quote",

"Character class relative complement": "Character class relative complement",

"Character class subtraction": "Character class subtraction",

"Character class symmetric difference": "Character class symmetric difference",

"Character Classes": "Character Classes",

"Character range is out of order": "Character range is out of order",

"Character range with surrogate pairs without unicode enabled results in ambiguous behavior": "Character range with surrogate pairs without unicode enabled results in ambiguous behavior",

"Checkout Successful": "Checkout Successful",

"Choose your amount": "Choose your amount",

"Clarity over clutter. Format free-spacing regexes into a clean, deterministic layout that is easier to read, review, and maintain.": "Clarity over clutter. Format free-spacing regexes into a clean, deterministic layout that is easier to read, review, and maintain.",

"Class Intersection": "Class Intersection",

"Class modifiers are computed from left to right, and the descriptions below (leading with three dots) must be interpreted with this in mind.": "Class modifiers are computed from left to right, and the descriptions below (leading with three dots) must be interpreted with this in mind.",

"Class Subtraction": "Class Subtraction",

"Class Symmetric Difference": "Class Symmetric Difference",

"Click {1} to proceed with this action.": "Click {1} to proceed with this action.",

"Close": "Close",

"Close menu": "Close menu",

"Close quick reference details": "Close quick reference details",

"Close Sidebar": "Close Sidebar",

"Close the Fullscreen Modal": "Close the Fullscreen Modal",

"Close the Modal": "Close the Modal",

"Code Generator": "Code Generator",

"Coffee covered!": "Coffee covered!",

"Collapse all tests": "Collapse all tests",

"Collapse Subtree": "Collapse Subtree",

"Collapse test": "Collapse test",

"Collecting measured samples": "Collecting measured samples",

"Comment": "Comment",

"Comment group": "Comment group",

"Common Tokens": "Common Tokens",

"Community": "Community",

"Community Library": "Community Library",

"Community Library Entry": "Community Library Entry",

"Community Moderator": "Community Moderator",

"Community Patterns": "Community Patterns",

"Complete match contents": "Complete match contents",

"Conditional": "Conditional",

"Conditional replacement": "Conditional replacement",

"Conditional statement": "Conditional statement",

"Confirm": "Confirm",

"Confirm paste of large text": "Confirm paste of large text",

"Conservative": "Conservative",

"Contact Sales": "Contact Sales",

"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",

"Continue to Payment": "Continue to Payment",

"Control": "Control",

"Control Character": "Control Character",

"Control character Y": "Control character Y",

"Control characters": "Control characters",

"Control verb": "Control verb",

"Controls how much spacing Format Regex keeps between neighboring regex atoms": "Controls how much spacing Format Regex keeps between neighboring regex atoms",

"Controls when Format Regex wraps expressions across multiple lines": "Controls when Format Regex wraps expressions across multiple lines",

"Converts all subsequent tokens to their {1} equivalence until {2} is encountered": "Converts all subsequent tokens to their {1} equivalence until {2} is encountered",

"Converts metacharacters to literal characters, and also allows literal matching of the regex delimiter in use, like `/`.": "Converts metacharacters to literal characters, and also allows literal matching of the regex delimiter in use, like `/`.",

"Converts the subsequent token to their {1} equivalence": "Converts the subsequent token to their {1} equivalence",

"Copied": "Copied",

"Copy failed": "Copy failed",

"Copy Shareable Link": "Copy Shareable Link",

"Copy to clipboard": "Copy to clipboard",

"Core regex101 experience": "Core regex101 experience",

"Create an account and keep your work available across sessions and devices.": "Create an account and keep your work available across sessions and devices.",

"Created": "Created",

"CRLF mode": "CRLF mode",

"Cumulative": "Cumulative",

"Cumulative share": "Cumulative share",

"Current score: {1}": "Current score: {1}",

"Current Version: {1}": "Current Version: {1}",

"Custom": "Custom",

"Dark": "Dark",

"Data": "Data",

"Date": "Date",

"Debug": "Debug",

"Debug Test": "Debug Test",

"Debugger and code generator": "Debugger and code generator",

"Decimal digits": "Decimal digits",

"Decrease speed": "Decrease speed",

"Decrease step range": "Decrease step range",

"Default code generator language": "Default code generator language",

"Default delimiter": "Default delimiter",

"Default flags": "Default flags",

"Default flavor": "Default flavor",

"Default Flavor: {1}": "Default Flavor: {1}",

"Default function": "Default function",

"Definition": "Definition",

"Delete": "Delete",

"Delete Account": "Delete Account",

"Delete Account and Data": "Delete Account and Data",

"Delete community entry": "Delete community entry",

"Delete Community Entry?": "Delete Community Entry?",

"Delete Entry": "Delete Entry",

"Delete Link": "Delete Link",

"Delete Regex": "Delete Regex",

"Delete Version Link": "Delete Version Link",

"Delimiters": "Delimiters",

"Description": "Description",

"Description of regular expression": "Description of regular expression",

"Detailed match information will be displayed here automatically.": "Detailed match information will be displayed here automatically.",

"Details & Access": "Details & Access",

"Deterministically format free-spacing regexes": "Deterministically format free-spacing regexes",

"Disable all keyboard shortcuts": "Disable all keyboard shortcuts",

"Disable backtracking when matching": "Disable backtracking when matching",

"Disallow duplicate subpattern names": "Disallow duplicate subpattern names",

"Disallow meaningless escapes": "Disallow meaningless escapes",

"Disallows backtracking past {1}'s position, and gives up matching the current alternation if there's a failure. If instead {1} is used outside of an alternation, it will act like {3}. Equivalent to {2}.": "Disallows backtracking past {1}'s position, and gives up matching the current alternation if there's a failure. If instead {1} is used outside of an alternation, it will act like {3}. Equivalent to {2}.",

"Discard Changes": "Discard Changes",

"Dismiss for now": "Dismiss for now",

"Do note that these tasks do not necessarily promote best practices in real life scenarios, but rather aim to teach you the fundamentals of writing powerful regular expressions.": "Do note that these tasks do not necessarily promote best practices in real life scenarios, but rather aim to teach you the fundamentals of writing powerful regular expressions.",

"does {1} match": "does {1} match",

"does match": "does match",

"Does not allow the capture group ID to be incremented for all enclosed capture groups.": "Does not allow the capture group ID to be incremented for all enclosed capture groups.",

"Don't return after first match": "Don't return after first match",

"Dot matches newline": "Dot matches newline",

"Double Quote": "Double Quote",

"Downvote": "Downvote",

"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",

"Due to a bug in Rust this script is unavailable. Try specifying the category to work around this issue.": "Due to a bug in Rust this script is unavailable. Try specifying the category to work around this issue.",

"Duplicate group names": "Duplicate group names",

"Duplicate/reset subpattern group number": "Duplicate/reset subpattern group number",

"Each successful match will remove the content of the referenced group {1}, allowing for balanced matches to be performed.": "Each successful match will remove the content of the referenced group {1}, allowing for balanced matches to be performed.",

"Each task gives you a problem to solve, then lets you compare your result with other solutions and keep improving from there.": "Each task gives you a problem to solve, then lets you compare your result with other solutions and keep improving from there.",

"Edit account entry": "Edit account entry",

"Edit Community Entry": "Edit Community Entry",

"Edit Default Delimiter": "Edit Default Delimiter",

"Edit Default Flags": "Edit Default Flags",

"Edit Title and Tags": "Edit Title and Tags",

"Edit your public note": "Edit your public note",

"Editor": "Editor",

"Editor Mode: Read & Write": "Editor Mode: Read & Write",

"Editor Mode: Read Only": "Editor Mode: Read Only",

"email": "email",

"empty character class — matches {1}": "empty character class — matches {1}",

"Empty match modifier": "Empty match modifier",

"empty string": "empty string",

"Enable all unicode and character set features": "Enable all unicode and character set features",

"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",

"Enables or disables the i, m, and s flags for the enclosed expression only. Use a minus sign to turn a flag off, e.g. {1}.": "Enables or disables the i, m, and s flags for the enclosed expression only. Use a minus sign to turn a flag off, e.g. {1}.",

"Enables or disables the i, m, s, and U flags for the enclosed expression only. Use a minus sign to turn a flag off, e.g. {1}.": "Enables or disables the i, m, s, and U flags for the enclosed expression only. Use a minus sign to turn a flag off, e.g. {1}.",

"Enables Unicode set notation in character classes, including string literals and set operations.": "Enables Unicode set notation in character classes, including string literals and set operations.",

"Enables unicode support for predefined classes": "Enables unicode support for predefined classes",

"Enables Unicode-aware character classes and escapes. This is on by default; use (?-u) to switch to ASCII-only matching.": "Enables Unicode-aware character classes and escapes. This is on by default; use (?-u) to switch to ASCII-only matching.",

"End of string": "End of string",

"End of word": "End of word",

"End quote literals without a corresponding open quote literal {1} match null, and only serve to create visual noise. If you meant to match the literal {2}, remove the backslash.": "End quote literals without a corresponding open quote literal {1} match null, and only serve to create visual noise. If you meant to match the literal {2}, remove the backslash.",

"End-of-word boundary": "End-of-word boundary",

"ends with": "ends with",

"Engine Error": "Engine Error",

"Enjoy!": "Enjoy!",

"Ensures that the given pattern will match, ending at the current position in the expression. Does not consume any characters.": "Ensures that the given pattern will match, ending at the current position in the expression. 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 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. Does not consume characters.": "Ensures that the given pattern would not match and end at the current position in the expression. 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.": "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 the matched substring is a single Unicode script run. Shorthand: {1}.": "Ensures the matched substring is a single Unicode script run. Shorthand: {1}.",

"Enterprise": "Enterprise",

"Entry is now private — only you can view it ({1})": "Entry is now private — only you can view it ({1})",

"Entry is now public — others can view it ({1})": "Entry is now public — others can view it ({1})",

"Entry Type": "Entry Type",

"equals": "equals",

"equivalent to {1}": "equivalent to {1}",

"Equivalent to {1}": "Equivalent to {1}",

"Equivalent to {1}.": "Equivalent to {1}.",

"Equivalent to boolean OR": "Equivalent to boolean OR",

"Error": "Error",

"Error reported by engine: {1}": "Error reported by engine: {1}",

"Escape": "Escape",

"Escape sequences like {1} will also match unicode characters.": "Escape sequences like {1} will also match unicode characters.",

"Everything in {1}, plus:": "Everything in {1}, plus:",

"Exactly 3 of a": "Exactly 3 of a",

"Execution timeline": "Execution timeline",

"Expand all tests": "Expand all tests",

"Expand Subtree": "Expand Subtree",

"Expand test": "Expand test",

"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.",

"Experimental feature; may be removed in the future.": "Experimental feature; may be removed in the future.",

"Explanation": "Explanation",

"Export Matches": "Export Matches",

"Export Options": "Export Options",

"Export Type": "Export Type",

"eXtra": "eXtra",

"Failed": "Failed",

"Favorites": "Favorites",

"Feel free to refresh the page and try again later, the offline version will remain available to you.": "Feel free to refresh the page and try again later, the offline version will remain available to you.",

"Filter by Flavor": "Filter by Flavor",

"Filters": "Filters",

"Find out what's new!": "Find out what's new!",

"Fix the regex errors before formatting.": "Fix the regex errors before formatting.",

"Flags/Modifiers": "Flags/Modifiers",

"Flavor": "Flavor",

"Flavor Help": "Flavor Help",

"Flavor: {1}": "Flavor: {1}",

"Follow me on X!": "Follow me on X!",

"For a full regex reference for {1}, please visit:": "For a full regex reference for {1}, please visit:",

"For example, repeating 1-3 digits and a period 3 times can be done like this: {1}": "For example, repeating 1-3 digits and a period 3 times can be done like this: {1}",

"For lookbehind, use {1}, {2}, or {3}.": "For lookbehind, use {1}, {2}, or {3}.",

"Force a matching failure at a specific point in the regex. Equivalent to {1}, and a synonym of {2}.": "Force a matching failure at a specific point in the regex. Equivalent to {1}, and a synonym of {2}.",

"Fork regex": "Fork regex",

"Fork Regex into new Workspace": "Fork Regex into new Workspace",

"Form Feed": "Form Feed",

"Format Regex": "Format Regex",

"Format Regex max line length": "Format Regex max line length",

"Format Regex only works when free spacing mode is enabled somewhere in the pattern.": "Format Regex only works when free spacing mode is enabled somewhere in the pattern.",

"Format Regex preferred spacing mode": "Format Regex preferred spacing mode",

"Free": "Free",

"Free Plan": "Free Plan",

"from": "from",

"From €1": "From €1",

"full": "full",

"full match": "full match",

"Full Match": "full match",

"Full match": "Full match",

"Full Search Result": "Full Search Result",

"General": "General",

"General Tokens": "General Tokens",

"Generated Code": "Generated Code",

"Get help on {1}": "Get help on {1}",

"Get Started": "Get Started",

"Get the app": "Get the app",

"Get the Desktop Application": "Get the Desktop Application",

"Get the Regex Parser": "Get the Regex Parser",

"Give monthly, keep it improving": "Give monthly, keep it improving",

"Give once, help right now": "Give once, help right now",

"Given a regular expression that has capture groups, you may refer to them (by number or name) and perform a conditional replacement.": "Given a regular expression that has capture groups, you may refer to them (by number or name) and perform a conditional replacement.",

"given the string {1} assert that {2} {3} {4}": "given the string {1} assert that {2} {3} {4}",

"given the test string": "given the test string",

"Global": "Global",

"Global pattern flags": "Global pattern flags",

"Go to beginning": "Go to beginning",

"Go to end": "Go to end",

"Go to the beginning": "Go to the beginning",

"Go to the end": "Go to the end",

"Golang/RE2, Python, and Javascript consider {1} to be just vertical tab (ascii {2}).": "Golang/RE2, Python, and Javascript consider {1} to be just vertical tab (ascii {2}).",

"Golang/RE2, Python, and Javascript equivalent is {1}.": "Golang/RE2, Python, and Javascript equivalent is {1}.",

"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 Constructs": "Group Constructs",

"group did not participate in match": "group did not participate in match",

"Group Name": "Group Name",

"Group Number": "Group Number",

"Groups are no longer implicitly capturing": "Groups are no longer implicitly capturing",

"Groups have been nested too deeply, consider simplifying your pattern": "Groups have been nested too deeply, consider simplifying your pattern",

"Groups with the same index must either have the same name or both be non-named groups": "Groups with the same index must either have the same name or both be non-named groups",

"Guidance on licensing, procurement, and rollout": "Guidance on licensing, procurement, and rollout",

"Half end-of-word boundary": "Half end-of-word boundary",

"Half start-of-word boundary": "Half start-of-word boundary",

"Has indices": "Has indices",

"Hash": "Hash",

"Headers": "Headers",

"Help cover hosting and uptime": "Help cover hosting and uptime",

"Help fund bigger improvements": "Help fund bigger improvements",

"Help fund fixes and upkeep": "Help fund fixes and upkeep",

"here": "here",

"Here comes a {1} tab character.": "Here comes a {1} tab character.",

"Hex": "Hex",

"Hex character YY": "Hex character YY",

"Hex character YYYY": "Hex character YYYY",

"Hex character YYYYYYYY": "Hex character YYYYYYYY",

"Hex only": "Hex only",

"Hexadecimal digits": "Hexadecimal digits",

"Hexadecimal replacement values": "Hexadecimal replacement values",

"Hide public note": "Hide public note",

"Highest Score": "Highest Score",

"Highlight Syntax": "Highlight Syntax",

"Histogram built from every measured sample. Bucket share and cumulative share are plotted directly from the raw sample set so clustering and slow tails stay visible.": "Histogram built from every measured sample. Bucket share and cumulative share are plotted directly from the raw sample set so clustering and slow tails stay visible.",

"Horizontal whitespace character": "Horizontal whitespace character",

"Huge help!": "Huge help!",

"If {1}, match this regex:": "If {1}, match this regex:",

"If capturing group 1 returned a match, the pattern before the alternate {1} is matched. Otherwise, the pattern after the alternate {1} is matched.": "If capturing group 1 returned a match, the pattern before the alternate {1} is matched. Otherwise, the pattern after the alternate {1} is matched.",

"If left to Automatic, the code generator will mirror the currently selected flavor in the editor": "If left to Automatic, the code generator will mirror the currently selected flavor in the editor",

"If recursion of the whole pattern is successful, match the pattern before the {1} otherwise match the pattern after the {1}.": "If recursion of the whole pattern is successful, match the pattern before the {1} otherwise match the pattern after the {1}.",

"If regex101 helps you, your support helps keep it going.": "If regex101 helps you, your support helps keep it going.",

"If the error persists, and you believe this to be an error with regex101, please open an issue here: {1}": "If the error persists, and you believe this to be an error with regex101, please open an issue here: {1}",

"If the lookahead succeeds, matches the pattern before the vertical bar. Otherwise, matches the pattern after the vertical bar. The lookaround can be negative also. 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 also. 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 the referenced subpattern did match, the first text will be inserted, otherwise the second.": "If the referenced subpattern did match, the first text will be inserted, otherwise the second.",

"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 this tool has earned a place in your workflow, one of these purchases helps keep it fast, sustainable, and improving.": "If this tool has earned a place in your workflow, one of these purchases helps keep it fast, sustainable, and improving.",

"If you are working on very large and complex expressions, turning this option off will yield improved performance. Note: Only works in supported languages {1}.": "If you are working on very large and complex expressions, turning this option off will yield improved performance. Note: Only works in supported languages {1}.",

"If you encounter any issues, quirky behavior or bugs, please open up an issue on github with all the relevant details": "If you encounter any issues, quirky behavior or bugs, please open up an issue on github with all the relevant details",

"If your access has not updated within an hour, send an email to support and we will look into it.": "If your access has not updated within an hour, send an email to support and we will look into it.",

"Ignore all whitespace / verbose": "Ignore all whitespace / verbose",

"Ignore whitespace": "Ignore whitespace",

"Ignore whitespace / verbose": "Ignore whitespace / verbose",

"Important Information": "Important Information",

"In PCRE a recursion test {1}, group name {2}, or a relative position {3} can be used as the conditional. Global flag breaks conditionals as the engine does a second pass over an already matched/consumed string.": "In PCRE a recursion test {1}, group name {2}, or a relative position {3} can be used as the conditional. Global flag breaks conditionals as the engine does a second pass over an already matched/consumed string.",

"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.": " 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, not yet finished. Conditional will return false and match `ky` instead.": "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, not yet finished. Conditional will return false and match `ky` instead.",

"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",

"including a single character not present in the list below": "including a single character not present in the list below",

"including a single character present in the list below": "including a single character present in the list below",

"Incomplete group structure": "Incomplete group structure",

"Increase speed": "Increase speed",

"Increase step range": "Increase step range",

"Info": "Info",

"Information about current regular expression": "Information about current regular expression",

"Inline comment, discarded by the engine when matching the regex": "Inline comment, discarded by the engine when matching the regex",

"Inline modifiers": "Inline modifiers",

"Inline modifiers cannot be placed in the root of a conditional due to a bug in the .NET regex engine": "Inline modifiers cannot be placed in the root of a conditional due to a bug in the .NET regex engine",

"Insert a backspace": "Insert a backspace",

"Insert a backspace character.": "Insert a backspace character.",

"Insert a bell": "Insert a bell",

"Insert a bell character.": "Insert a bell character.",

"Insert a carriage return": "Insert a carriage return",

"Insert a carriage return character.": "Insert a carriage return character.",

"Insert a form-feed": "Insert a form-feed",

"Insert a form-feed character.": "Insert a form-feed character.",

"Insert a literal quote": "Insert a literal quote",

"Insert a literal quote in the regex.": "Insert a literal quote in the regex.",

"Insert a newline": "Insert a newline",

"Insert a newline character.": "Insert a newline character.",

"Insert a null": "Insert a null",

"Insert a null character.": "Insert a null character.",

"Insert a personal title": "Insert a personal title",

"Insert a tab": "Insert a tab",

"Insert a tab character.": "Insert a tab character.",

"Insert a vertical tab": "Insert a vertical tab",

"Insert a vertical tab character.": "Insert a vertical tab character.",

"Insert code snippet": "Insert code snippet",

"insert comparison string": "insert comparison string",

"Insert entire input string": "Insert entire input string",

"Insert last captured group": "Insert last captured group",

"Insert link": "Insert link",

"Insert quote": "Insert quote",

"insert test description": "insert test description",

"insert test string": "insert test string",

"Insert the escaped literal": "Insert the escaped literal",

"Insert the escaped literal. Mainly useful if you're trying to insert a character that cannot be typed literally.": "Insert the escaped literal. Mainly useful if you're trying to insert a character that cannot be typed literally.",

"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",

"inserts": "inserts",

"Inserts a dollar sign": "Inserts a dollar sign",

"inserts the character {1} with index {2}{3}": "inserts the character {1} with index {2}{3}",

"inserts the entire input string": "inserts the entire input string",

"inserts the matched substring": "inserts the matched substring",

"inserts the name from the last encountered backtracking control verb on the matching path that has a name": "inserts the name from the last encountered backtracking control verb on the matching path that has a name",

"inserts the portion of the string that follows the matched substring": "inserts the portion of the string that follows the matched substring",

"inserts the portion of the string that precedes the matched substring": "inserts the portion of the string that precedes the matched substring",

"inserts the same text as most recently matched by the {1} capturing group": "inserts the same text as most recently matched by the {1} capturing group",

"inserts the same text as most recently matched by the capturing group named {1}": "inserts the same text as most recently matched by the capturing group named {1}",

"inserts the text from the highest-numbered capture group that matched": "inserts the text from the highest-numbered capture group that matched",

"Internal engine error: {1}": "Internal engine error: {1}",

"Internal hosting for private environments": "Internal hosting for private environments",

"interpolate {1}": "interpolate {1}",

"interpolate {1} {2}": "interpolate {1} {2}",

"Introduction": "Introduction",

"Invalid control character": "Invalid control character",

"Invalid low/high surrogate": "Invalid low/high surrogate",

"Invalid placement of hyphen; there may only be one inside the group": "Invalid placement of hyphen; there may only be one inside the group",

"Invalid unicode escape": "Invalid unicode escape",

"is null": "is null",

"Isolates part of the full match to be later referred to by ID within the regex or the matches array. IDs start at 1.": "Isolates part of the full match to be later referred to by ID within the regex or the matches array. IDs start at 1.",

"It is evaluated with the PCRE2 engine, so it is a practical way to learn useful structures while testing your thinking against real constraints.": "It is evaluated with the PCRE2 engine, so it is a practical way to learn useful structures while testing your thinking against real constraints.",

"JIT Modifier": "JIT Modifier",

"Jitter": "Jitter",

"Join the Discord community!": "Join the Discord community!",

"Jump {1} steps backwards": "Jump {1} steps backwards",

"Jump {1} steps forward": "Jump {1} steps forward",

"Jump straight in and try regex101 without linking anything to an account.": "Jump straight in and try regex101 without linking anything to an account.",

"Keep Editing": "Keep Editing",

"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 {1} 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 {1} flag to limit matches to ASCII characters only. Python 2 requires this flag to turn on unicode support.",

"Keep Regex101 Alive": "Keep Regex101 Alive",

"Keyboard Shortcuts": "Keyboard Shortcuts",

"Language": "Language",

"Latency": "Latency",

"Latency bucket midpoint": "Latency bucket midpoint",

"Latency distribution": "Latency distribution",

"Latest": "Latest",

"Latest sample {1}": "Latest sample {1}",

"lazy": "lazy",

"Lazy quantifier": "Lazy quantifier",

"Learn": "Learn",

"Left sidebar Breakpoint {1} ({2})": "Left sidebar Breakpoint {1} ({2})",

"Letters": "Letters",

"Letters and digits": "Letters and digits",

"Liberal": "Liberal",

"Library Entry Deleted": "Library Entry Deleted",

"Light": "Light",

"Limits matched line terminators to only {1}": "Limits matched line terminators to only {1}",

"Limits the number of recursions the engine is allowed to make to `d` times. This user set limit cannot be increased past the compile time value or the default, however it can be restricted.": "Limits the number of recursions the engine is allowed to make to `d` times. This user set limit cannot be increased past the compile time value or the default, however it can be restricted.",

"Limits the number of times the regex engine is allowed to call `match()` to `x` times. This user set limit cannot be increased past the compile time value or the default, however it can be restricted.": "Limits the number of times the regex engine is allowed to call `match()` to `x` times. This user set limit cannot be increased past the compile time value or the default, however it can be restricted.",

"Line break modifier": "Line break modifier",

"Line Breaks": "Line Breaks",

"Line Feed": "Line Feed",

"Line Separator": "Line Separator",

"Line terminator(s) are: {1} {2}": "Line terminator(s) are: {1} {2}",

"Lines are delimited by: {1} {2}": "Lines are delimited by: {1} {2}",

"List": "List",

"List Substitution": "List Substitution",

"Live Help": "Live Help",

"Load all data": "Load all data",

"Load example in editor": "Load example in editor",

"Load More": "Load More",

"Loading content...": "Loading content...",

"Loading more entries...": "Loading more entries...",

"Loading Supporter List, please wait...": "Loading Supporter List, please wait...",

"Loading, please wait...": "Loading, please wait...",

"Loading...": "Loading...",

"Localized inline modifiers": "Localized inline modifiers",

"Lonely End Quote": "Lonely End Quote",

"Lookahead conditional": "Lookahead conditional",

"Lookbehind conditional": "Lookbehind conditional",

"lowercase": "lowercase",

"Lowercase letters": "Lowercase letters",

"Lowercase Transformation": "Lowercase Transformation",

"Lowest Score": "Lowest Score",

"Make Entry Private": "Make Entry Private",

"Make Entry Public": "Make Entry Public",

"Make escape sequences perform ASCII-only matching": "Make escape sequences perform ASCII-only matching",

"Make long patterns easier to share and maintain": "Make long patterns easier to share and maintain",

"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",

"Makes it so that any unicode newline character or sequence thereof counts as a line break.": "Makes it so that any unicode newline character or sequence thereof counts as a line break.",

"Makes it so that either a carriage return character or a line feed character, or the two in sequence are considered a line break.": "Makes it so that either a carriage return character or a line feed character, or the two in sequence are considered a line break.",

"Makes it so that empty strings will not be allowed to be matched by the pattern at the start of the subject string.": "Makes it so that empty strings will not be allowed to be matched by the pattern at the start of the subject string.",

"Makes it so that empty strings will not be allowed to be matched by the pattern.": "Makes it so that empty strings will not be allowed to be matched by the pattern.",

"Makes it so that only a carriage return character followed by a line feed character is considered a line break. Common in Windows documents.": "Makes it so that only a carriage return character followed by a line feed character is considered a line break. Common in Windows documents.",

"Makes it so that only a carriage return character is considered a line break.": "Makes it so that only a carriage return character is considered a line break.",

"Makes it so that only a line feed character is considered a line break. Common in UNIX documents.": "Makes it so that only a line feed character is considered a line break. Common in UNIX documents.",

"Makes it so that the PCRE engine will no longer use just in time compilation.": "Makes it so that the PCRE engine will no longer use just in time compilation.",

"Malplaced character class intersection operator": "Malplaced character class intersection operator",

"Malplaced character class subtraction operator": "Malplaced character class subtraction operator",

"Malplaced symmetric character class difference operator": "Malplaced symmetric character class difference operator",

"Manage Entry": "Manage Entry",

"Manage Tags": "Manage Tags",

"Manual test execution": "Manual test execution",

"marker verb whose main purpose is to track how a match was arrived at. This position will be marked as {1}": "marker verb whose main purpose is to track how a match was arrived at. This position will be marked as {1}",

"Massive support!": "Massive support!",

"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 (equivalent to {1})": "match any non-word character in any script (equivalent to {1})",

"match any word character in any script (equivalent to {1})": "match any word character in any script (equivalent to {1})",

"Match anything but a newline": "Match anything but a newline",

"Match expression defined in capture group `name`": "Match expression defined in capture group `name`",

"Match expression defined in capture group 1": "Match expression defined in capture group 1",

"Match expression defined in the capture group \"{name}\"": "Match expression defined in the capture group \"{name}\"",

"Match expression defined in the capture group called \"letter\". This is an alternative notation for \"{1}\"": "Match expression defined in the capture group called \"letter\". This is an alternative notation for \"{1}\"",

"Match expression defined in the capture group called `letter`.": "Match expression defined in the capture group called `letter`.",

"Match expression defined in the capture group named \"letter\"": "Match expression defined in the capture group named \"letter\"",

"Match expression defined in the capture group with the given name. It does not require that the capture group be defined beforehand.": "Match expression defined in the capture group with the given name. It does not require that the capture group be defined beforehand.",

"Match expression defined in the first capture group following the current position in the expression. {1} is the second capture group, {2} is the capture group immediately preceding the current position.": "Match expression defined in the first capture group following the current position in the expression. {1} is the second capture group, {2} is the capture group immediately preceding the current position.",

"Match expression defined in the first relative capture group": "Match expression defined in the first relative capture group",

"Match expression defined in the named capture group `letter`": "Match expression defined in the named capture group `letter`",

"Match expression defined in the nth capture group": "Match expression defined in the nth capture group",

"Match expression defined in the nth capture group ahead of the current position of {1}. For example {2} is the second previous capture group.": "Match expression defined in the nth capture group ahead of the current position of {1}. For example {2} is the second previous capture group.",

"Match expression defined in the nth capture group ahead of the current position of {1}. For example, {2} is the second upcoming capture group.": "Match expression defined in the nth capture group ahead of the current position of {1}. For example, {2} is the second upcoming capture group.",

"Match expression defined in the nth capture group.": "Match expression defined in the nth capture group.",

"Match expression defined in the nth capture group. `n` can be positional as well. For example, {1} stands for previous capture group, while {2} would be the third capture group. Equivalent to {3}.": "Match expression defined in the nth capture group. `n` can be positional as well. For example, {1} stands for previous capture group, while {2} would be the third capture group. Equivalent to {3}.",

"Match expression defined in the nth capture group. `n` can be positional as well. For example, {1} stands for the previous capture group, while {2} would be the third next capture group. Equivalent to {3}": "Match expression defined in the nth capture group. `n` can be positional as well. For example, {1} stands for the previous capture group, while {2} would be the third next capture group. Equivalent to {3}",

"Match expression defined in the nth relative upcoming capture group.": "Match expression defined in the nth relative upcoming capture group.",

"Match expression defined in the nth relative upcoming subpattern": "Match expression defined in the nth relative upcoming subpattern",

"Match Information": "Match Information",

"match multi character string literals": "match multi character string literals",

"Match nth subpattern": "Match nth subpattern",

"Match Number": "Match Number",

"Match one data unit": "Match one data unit",

"Match previously-named capture group `letter`": "Match previously-named capture group `letter`",

"Match Step {1}": "Match Step {1}",

"Match Steps": "Match Steps",

"Match subpattern `name`": "Match subpattern `name`",

"Match subpattern number #": "Match subpattern number #",

"Match Text": "Match Text",

"Match text the nth relative previous subpattern matched": "Match text the nth relative previous subpattern matched",

"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",

"matches": "matches",

"Matches": "Matches",

"Matches a carriage return, unicode character U+2185.": "Matches a carriage return, unicode character U+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 (equivalent to {1})": "matches a digit (equivalent 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 (equivalent to {1})": "matches a digit zero through nine in any script except ideographic scripts (equivalent to {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 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 sequence of characters from the same Unicode script": "Matches a sequence of characters from the same Unicode script",

"matches a single character in the list": "matches a single character in the list",

"matches a single character in the range between {1} {2} and {3} {4} {5}": "matches a single character in the range between {1} {2} and {3} {4} {5}",

"matches a special character that is used like a letter": "matches a special character that is used like a letter",

"Matches a string literal inside a character class. This is only available in JavaScript with the /v flag.": "Matches a string literal inside a character class. This is only available in JavaScript with the /v flag.",

"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. Historically, tab stops happen every 8 characters.": "Matches a tab character. Historically, tab stops happen every 8 characters.",

"Matches a unicode character outside of the given property.": "Matches a unicode character outside of the given property.",

"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 that doesn't have any of the given properties. In JavaScript this requires the /u or /v flag.": "Matches a unicode character that doesn't have any of the given properties. In JavaScript this requires the /u or /v flag.",

"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 group of properties or categories. In JavaScript this requires the /u or /v flag.": "Matches a unicode character with the given group of properties or categories. In JavaScript this requires the /u or /v flag.",

"Matches a unicode character with the given property:": "Matches a unicode character with the given property:",

"matches a uppercase letter {1}": "matches a uppercase letter {1}",

"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, excluding line breaks {1}": "matches a whitespace character, excluding line breaks {1}",

"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 alphabetic character {1}": "matches an alphabetic character {1}",

"matches an alphanumeric character {1}": "matches an alphanumeric character {1}",

"matches an alphanumeric character or {1} {2} (also written as {3})": "matches an alphanumeric character or {1} {2} (also written as {3})",

"matches an ASCII {1} or Latin-1 {2} control character": "matches an ASCII {1} or Latin-1 {2} control character",

"matches an empty string (any position)": "matches an empty string (any position)",

"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 {1}. The double square brackets is not a typo, POSIX notation demands it.": "Matches any character in the valid ASCII range. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.",

"Matches any character other than newline (or including line terminators with the {1} flag)": "Matches any character other than newline (or including line terminators with the {1} flag)",

"Matches any character that is not a newline, the opposite of {1}. Not affected by the single line {2} flag.": "Matches any character that is not a newline, the opposite of {1}. Not affected by the single line {2} flag.",

"Matches any character that is not horizontal whitespace {1}.": "Matches any character that is not horizontal whitespace {1}.",

"matches any character that's not a digit (equivalent to {1})": "matches any character that's not a digit (equivalent to {1})",

"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 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 defined in the class, except for any of the characters defined in the nested character class.": "Matches any characters defined in the class, except for any of the characters defined in the nested character class.",

"Matches any characters defined in the class, except for any of the characters defined in the nested character class. In JavaScript this requires the /v flag.": "Matches any characters defined in the class, except for any of the characters defined in the nested character class. In JavaScript this requires the /v flag.",

"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} {2}": "matches any characters in the {1} {2}",

"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 {1}.": "Matches any decimal digit. Equivalent to {1}.",

"matches any horizontal whitespace character (equivalent to {1})": "matches any horizontal whitespace character (equivalent 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 (equivalent to {1})": "matches any kind of invisible character (equivalent to {1})",

"matches any kind of letter from any language": "matches any kind of letter from any language",

"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 (equivalent to {1})": "matches any kind of visible character (equivalent 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 {1}.": "Matches any letter, digit or underscore. Equivalent to {1}.",

"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 (equivalent to {1})": "matches any non-numeric character in any script (equivalent to {1})",

"matches any non-whitespace character (equivalent to {1})": "matches any non-whitespace character (equivalent to {1})",

"matches any non-word character (equivalent to {1})": "matches any non-word character (equivalent 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 sequence": "matches any Unicode newline sequence",

"Matches any Unicode newline sequence. Equivalent to (?>\\r\\n|\\n|\\x0b|\\f|\\r|\\x85).": "Matches any Unicode newline sequence. Equivalent to (?>\\r\\n|\\n|\\x0b|\\f|\\r|\\x85).",

"Matches any valid Unicode sequence, including line breaks. Equivalent to {1}.": "Matches any valid Unicode sequence, including line breaks. Equivalent to {1}.",

"matches any vertical whitespace character": "matches any vertical whitespace character",

"matches any whitespace character (equivalent to {1})": "matches any whitespace character (equivalent to {1})",

"matches any word character (equivalent to {1})": "matches any word character (equivalent to {1})",

"Matches anything not matched by {1}.": "Matches anything not matched by {1}.",

"Matches anything other than a decimal/digit.": "Matches anything other than a decimal/digit.",

"Matches anything other than a letter, digit or underscore. Equivalent to {1}": "Matches anything other than a letter, digit or underscore. Equivalent to {1}",

"Matches anything other than a space, tab or newline.": "Matches anything other than a space, tab or newline.",

"matches anything that {1} does not": "matches anything that {1} does not",

"Matches are still being processed": "Matches are still being processed",

"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: {1} through {2}.": "Matches ASCII characters typically associated with Control+A through Control+Z: {1} through {2}.",

"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 in either class, but not in both (XOR).": "Matches characters that are in either class, but not in both (XOR).",

"Matches characters that are not whitespace, letters or numbers. The double square brackets is not a typo, POSIX notation demands it.": "Matches characters that are not whitespace, letters or numbers. The double square brackets is not a typo, POSIX notation demands it.",

"Matches characters that are often used to control text presentation, including newlines, null characters, tabs and the escape character. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "Matches characters that are often used to control text presentation, including newlines, null characters, tabs and the escape character. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.",

"Matches decimal digits. Equivalent to {1} or {2}. The double square brackets is not a typo, POSIX notation demands it.": "Matches decimal digits. Equivalent to {1} or {2}. The double square brackets is not a typo, POSIX notation demands it.",

"Matches either an a, b or c character": "Matches either an a, b or c character",

"Matches either what is before the {1} or what is after it - in this case `a` or `b`.": "Matches either what is before the {1} or what is after it - in this case `a` or `b`.",

"Matches end of word (POSIX syntax), equivalent to {1}": "Matches end of word (POSIX syntax), equivalent to {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 expression defined in the capture group with the given name.": "Matches expression defined in the capture group with the given name.",

"Matches hexadecimal digits, case insensitive. Equivalent to {1}.": "Matches hexadecimal digits, case insensitive. Equivalent to {1}.",

"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 letters, numbers and underscores. Equivalent to {1} or {2}. The double square brackets is not a typo, POSIX notation demands it.": "Matches letters, numbers and underscores. Equivalent to {1} or {2}. The double square brackets is not a typo, POSIX notation demands it.",

"Matches lowercase letters. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "Matches lowercase letters. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.",

"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 of two alternatives depending on whether capture group {1} matched": "Matches one of two alternatives depending on whether capture group {1} matched",

"Matches one of two alternatives depending on whether the following lookaround matches": "Matches one of two alternatives depending on whether the following lookaround matches",

"Matches one of two branches depending on whether the engine is currently in a recursive call": "Matches one of two branches depending on whether the engine is currently in a recursive call",

"Matches one of two branches depending on whether the engine is currently inside a recursive call to subpattern {1}": "Matches one of two branches depending on whether the engine is currently inside a recursive call to subpattern {1}",

"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. The double square brackets is not a typo, POSIX notation demands it.": "Matches printable characters, part of the basic latin set, such as letters and spaces, without including control characters. The double square brackets is not a typo, POSIX notation demands it.",

"Matches printable, non-whitespace, non-control characters only. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "Matches printable, non-whitespace, non-control characters only. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.",

"Matches spaces and tabs (but not newlines). Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "Matches spaces and tabs (but not newlines). Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.",

"Matches spaces, tabs, non-breaking/mathematical/ideographic spaces, and so on. Works with Unicode.": "Matches spaces, tabs, non-breaking/mathematical/ideographic spaces, and so on. Works with Unicode.",

"Matches start of word (POSIX syntax), equivalent to {1}": "Matches start of word (POSIX syntax), equivalent to {1}",

"Matches text the nth group matched and captured. `n` represents the capture group number and can positionally refer to past capture groups as well.": "Matches text the nth group matched and captured. `n` represents the capture group number and can positionally refer to past capture groups as well.",

"Matches the 8-bit character with the given octal value.": "Matches the 8-bit character with the given octal value.",

"Matches the backspace control character. {1} stands for `word boundary` when outside of a character class {2}.": "Matches the backspace control character. {1} stands for `word boundary` when outside of a character class {2}.",

"matches the character {1} with index {2}{3} literally {4}": "matches the character {1} with index {2}{3} literally {4}",

"Matches the character with the given hex value.": "Matches the character with the given hex value.",

"matches the characters {1} literally {2}": "matches the characters {1} literally {2}",

"matches the control sequence {1} {2}": "matches the control sequence {1} {2}",

"Matches the end of a string only. Unlike {1}, this is not affected by multiline mode, and, in contrast to {2}, will not match before a trailing newline at the end of a string.": "Matches the end of a string only. Unlike {1}, this is not affected by multiline mode, and, in contrast to {2}, will not match before a trailing newline at the end of a string.",

"Matches the end of a string or the position before the line terminator right at the end of the string (if any). Unlike {1}, this is not affected by multiline mode.": "Matches the end of a string or the position before the line terminator right at the end of the string (if any). Unlike {1}, 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 end of any word; defined as any characters that are followed by either {1} or {2}.": "Matches the end of any word; defined as any characters that are followed by either {1} or {2}.",

"Matches the end of any word; defined as any characters that are preceeded by {1} and superseeded by either {2} or {3}.": "Matches the end of any word; defined as any characters that are preceeded by {1} and superseeded by either {2} or {3}.",

"matches the entire pattern": "matches the entire pattern",

"Matches the expression defined in capture group 1.": "Matches the expression defined in capture group 1.",

"matches the expression defined in the {1} capture group": "matches the expression defined in the {1} capture group",

"matches the expression defined in the capture group \"{1}\"": "matches the expression defined in the capture group \"{1}\"",

"Matches the intersection between the two character classes. Useful if you want to white or blacklist certain characters from a broader class.": "Matches the intersection between the two character classes. Useful if you want to white or blacklist certain characters from a broader class.",

"Matches the intersection between two character classes. In JavaScript this requires the /v flag.": "Matches the intersection between two character classes. In JavaScript this requires the /v flag.",

"matches the intersection of the tokens to the left and right of this token": "matches the intersection of the tokens to the left and right of this token",

"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 previous token between {1} and {2} times, {3} {4}": "matches the previous token between {1} and {2} times, {3} {4}",

"matches the previous token exactly {1} {2} {3}": "matches the previous token exactly {1} {2} {3}",

"Matches the relative complement of the two character classes. That is, any token that is in either, but not both.": "Matches the relative complement of the two character classes. That is, any token that is in either, but not both.",

"Matches the same text a capture group called `name` matched and captured. Alternate notations are {1} and {2}.": "Matches the same text a capture group called `name` matched and captured. Alternate notations are {1} and {2}.",

"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 capture group called `letter` matched and captured.": "Matches the same text capture group called `letter` matched and captured.",

"Matches the same text matched and captured by a previously named capture group.": "Matches the same text matched and captured by a previously named capture group.",

"Matches the same text matched by a previously named capture group.": "Matches the same text matched by a previously named capture group.",

"Matches the same text the nth group prior to {1} matched and captured.": "Matches the same text the nth group prior to {1} matched and captured.",

"Matches the start of a string only. Unlike {1}, this is not affected by multiline mode.": "Matches the start of a string only. Unlike {1}, this is not affected by multiline mode.",

"Matches the start of a string without consuming any characters. If {1} multiline mode is used, this will also match immediately after a newline character.": "Matches the start of a string without consuming any characters. If {1} multiline mode is used, this will also match immediately after a newline character.",

"Matches the start of any word; defined as any characters that are preceeded by either {1} or {2} and superseeded by {2}.": "Matches the start of any word; defined as any characters that are preceeded by either {1} or {2} and superseeded by {2}.",

"Matches the start of any word; defined as any characters that are preceeded by either {1} or {2}.": "Matches the start of any word; defined as any characters that are preceeded by either {1} or {2}.",

"Matches the substrings captured by group {1} against the pattern below": "Matches the substrings captured by group {1} against the pattern below",

"matches the symmetric difference between the tokens to the left and right of this": "matches the symmetric difference between the tokens to the left and right of this",

"Matches the text captured by the nth group. n can contain more than one digit, if necessary.": "Matches the text captured by the nth group. n can contain more than one digit, if necessary.",

"matches the tokens to the left of this, minus any of the tokens present on the right": "matches the tokens to the left of this, minus any of the tokens present on the right",

"Matches the unicode character with the given hex value. When using the `/u` flag, 16-bit character (surrogate/supplementary characters included) syntax becomes `\\u{...}`.": "Matches the unicode character with the given hex value. When using the `/u` flag, 16-bit character (surrogate/supplementary characters included) syntax becomes `\\u{...}`.",

"Matches the very end of a string only. Unlike {1}, this is not affected by multiline mode.": "Matches the very end of a string only. Unlike {1}, this is not affected by multiline mode.",

"Matches unicode vertical whitespace, considered a character class by the PCRE engine: {1}.": "Matches unicode vertical whitespace, considered a character class by the PCRE engine: {1}.",

"Matches uppercase letters. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.": "Matches uppercase letters. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.",

"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 {1}. The double square brackets is not a typo, POSIX notation demands it.": "Matches whitespace characters. Equivalent to {1}. The double square brackets is not a typo, POSIX notation demands it.",

"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 {1} or {2}.": "Matches, without consuming any characters, at the position between two characters matched by {1} or {2}.",

"Matches, without consuming any characters, immediately between a character matched by {1} and a character not matched by {1} (in either order). It cannot be used to separate non words from words.": "Matches, without consuming any characters, immediately between a character matched by {1} and a character not matched by {1} (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.",

"Maybe Later": "Maybe Later",

"meaningless quantifier": "meaningless quantifier",

"Measure execution time across your test inputs": "Measure execution time across your test inputs",

"Measured sample sequence": "Measured sample sequence",

"Measured samples": "Measured samples",

"Median score": "Median score",

"Message": "Message",

"Meta Sequences": "Meta Sequences",

"Mind-blowing": "Mind-blowing",

"Modifier": "Modifier",

"Modifier Group": "Modifier Group",

"monthly": "monthly",

"Monthly support": "Monthly support",

"Most common": "Most common",

"Most downvotes": "Most downvotes",

"Most Recent": "Most Recent",

"Most upvotes": "Most upvotes",

"Multi character string literals": "Multi character string literals",

"Multiline": "Multiline",

"My Expressions": "My Expressions",

"My Favorites": "My Favorites",

"My Library Entries": "My Library Entries",

"My Regular Expressions": "My Regular Expressions",

"Name or other identifier of the author": "Name or other identifier of the author",

"Named backreference may not be used before group definition": "Named backreference may not be used before group definition",

"Named Balancing Group": "Named Balancing Group",

"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": "Negation of \\v",

"Negative Lookahead": "Negative Lookahead",

"Negative Lookbehind": "Negative Lookbehind",

"Nested character classes act as boolean OR, equivalent to simply using {1}": "Nested character classes act as boolean OR, equivalent to simply using {1}",

"Newline": "Newline",

"Next page": "Next page",

"Next question": "Next question",

"No data": "No data",

"No data captured during the debug process.": "No data captured during the debug process.",

"no description available": "no description available",

"No flags": "No flags",

"No hex code was specified": "No hex code was specified",

"No Internet Connection": "No Internet Connection",

"No supporter messages yet. Check back soon!": "No supporter messages yet. Check back soon!",

"No tests matched your filter, click {1} to show all.": "No tests matched your filter, click {1} to show all.",

"No warmup phase is skipped before measurement begins.": "No warmup phase is skipped before measurement begins.",

"No warmup phase skipped": "No warmup phase skipped",

"Non-atomic lookaround assertion": "Non-atomic lookaround assertion",

"Non-atomic lookarounds allow the engine to backtrack inside the assertion if the rest of the pattern fails. For lookahead, use {1}, {2}, or {3}.": "Non-atomic lookarounds allow the engine to backtrack inside the assertion if the rest of the pattern fails. For lookahead, use {1}, {2}, or {3}.",

"Non-atomic Positive Lookahead": "Non-atomic Positive Lookahead",

"Non-atomic Positive Lookbehind": "Non-atomic Positive Lookbehind",

"Non-capturing group": "Non-capturing group",

"Non-capturing group that discards backtracking positions once matched.": "Non-capturing group that discards backtracking positions once matched.",

"Non-capturing Group. Matches the tokens contained with the following effective flags: {1}": "Non-capturing Group. Matches the tokens contained with the following effective flags: {1}",

"Non-capturing groups": "Non-capturing groups",

"Non-Participating Groups": "Non-Participating Groups",