@lcap/nasl-utils 4.4.0-beta.6 → 4.4.0-beta.7

package/out/regex-validator/reference_content.js

@@ -0,0 +1,790 @@
+"use strict";
+/*
+RegExr: Learn, Build, & Test RegEx
+Copyright (C) 2017  gskinner.com, inc.
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+// this is just raw content for the Reference.
+// right now all examples are executed in-browser, so they need to be compatible. Maybe swap to XRegExp at some point.
+// TODO: rewrite to use multiline template literals?
+let reference_content = {}, o = reference_content;
+exports.default = reference_content;
+o.label = "RegEx Reference";
+o.id = "reference";
+o.search = true,
+    o.desc = `Information on all of the tokens available to create regular expressions.
+	<p>Double-click an item in the list to insert it into your Expression.</p>
+	<p>Click the arrow beside an example to load it.</p>`;
+o.kids = [
+    {
+        label: "Character classes",
+        id: "charclasses",
+        desc: "Character classes match a character from a specific set. There are a number of predefined character classes and you can also define your own sets.",
+        kids: [
+            {
+                id: "set",
+                label: "character set",
+                desc: "匹配集合中的任意字符。",
+                example: ["[aeiou]", "glib jocks vex dwarves!"],
+                token: "[ABC]"
+            },
+            {
+                id: "setnot",
+                label: "negated set",
+                desc: "匹配任何不在集合中的字符。",
+                example: ["[^aeiou]", "glib jocks vex dwarves!"],
+                token: "[^ABC]"
+            },
+            {
+                id: "range",
+                tip: "匹配字符在范围 {{getChar(prev)}} 到 {{getChar(next)}} 之间（字符代码 {{prev.code}} 到 {{next.code}}）。{{getInsensitive()}}",
+                example: ["[g-s]", "abcdefghijklmnopqrstuvwxyz"],
+                desc: "匹配字符代码在两个指定字符之间的字符（包括这两个字符）。",
+                token: "[A-Z]"
+            },
+            {
+                id: "posixcharclass",
+                tip: "匹配 '{{value}}' POSIX 类中的任何字符。",
+                label: "POSIX class",
+                desc: "匹配指定 POSIX 类中的任意字符。必须放在字符集内。例如，<code>[[:alnum:]$]</code> 可以匹配字母数字字符和 <code>$</code>。",
+                ext: "<p>有关类的列表，请参阅 <a href='http://www.pcre.org/original/doc/html/pcrepattern.html'>PCRE 规范</a>.</p>",
+                token: "[:alnum:]"
+            },
+            {
+                id: "dot",
+                tip: "匹配任何字符 {{getDotAll()}}。",
+                desc: "匹配除换行符以外的任意字符。",
+                ext: " 等价于 <code>[^\\n\\r]</code>。",
+                example: [".", "glib jocks vex dwarves!"],
+                token: "."
+            },
+            {
+                id: "matchanyset",
+                label: "match any",
+                desc: "一个字符集，可用于在不启用 dotall 标志 (<code>s</code>) 的情况下匹配任意字符，包括换行符" +
+                    "<p>另一种形式是 <code>[^]</code>，但并非所有浏览器都支持。</p>",
+                example: ["[\\s\\S]", "glib jocks vex dwarves!"],
+                token: "[\\s\\S]"
+            },
+            {
+                id: "unicodegrapheme",
+                label: "unicode grapheme",
+                desc: "匹配任意单个 Unicode 字素（即字符）。",
+                ext: " 这包括换行符（无论是否启用 dotall 模式）和作为多个代码点编码的字素。",
+                token: "\\X"
+            },
+            {
+                id: "word",
+                desc: "匹配任意单词字符（字母数字和下划线）。",
+                ext: " 仅匹配低 ASCII 字符（不包括重音或非罗马字符）。等价于 <code>[A-Za-z0-9_]</code>",
+                example: ["\\w", "bonjour, mon frère"],
+                token: "\\w"
+            },
+            {
+                id: "notword",
+                label: "not word",
+                desc: "匹配任意非单词字符（字母数字和下划线）。",
+                ext: " 等价于 <code>[^A-Za-z0-9_]</code>",
+                example: ["\\W", "bonjour, mon frère"],
+                token: "\\W"
+            },
+            {
+                id: "digit",
+                desc: "匹配任意数字字符（0-9）。",
+                ext: " 等价于 <code>[0-9]</code>。",
+                example: ["\\d", "+1-(444)-555-1234"],
+                token: "\\d"
+            },
+            {
+                id: "notdigit",
+                label: "not digit",
+                desc: "匹配任意非数字字符（0-9）。",
+                ext: " 等价于 <code>[^0-9]</code>。",
+                example: ["\\D", "+1-(444)-555-1234"],
+                token: "\\D"
+            },
+            {
+                id: "whitespace",
+                desc: "匹配任意空白字符（空格、制表符、换行符）。",
+                example: ["\\s", "glib jocks vex dwarves!"],
+                token: "\\s"
+            },
+            {
+                id: "notwhitespace",
+                label: "not whitespace",
+                desc: "匹配任意非空白字符（空格、制表符、换行符）。",
+                example: ["\\S", "glib jocks vex dwarves!"],
+                token: "\\S"
+            },
+            {
+                id: "hwhitespace",
+                label: "horizontal whitespace",
+                desc: "匹配任意水平空白字符（空格、制表符）。",
+                token: "\\h"
+            },
+            {
+                id: "nothwhitespace",
+                label: "not horizontal whitespace",
+                desc: "匹配任意非水平空白字符（空格、制表符）。",
+                token: "\\H"
+            },
+            {
+                id: "vwhitespace",
+                label: "vertical whitespace",
+                desc: "匹配任意垂直空白字符（换行符）。",
+                token: "\\v"
+            },
+            {
+                id: "notvwhitespace",
+                label: "not vertical whitespace",
+                desc: "匹配任意非垂直空白字符（换行符）。",
+                token: "\\V"
+            },
+            {
+                id: "linebreak",
+                label: "line break",
+                desc: "匹配任意换行符，包括 CRLF 对及单独的 CR / LF。",
+                token: "\\R"
+            },
+            {
+                id: "notlinebreak",
+                label: "not line break",
+                desc: "匹配任意非换行符字符。",
+                ext: " 类似于点 (<code>.</code>) 但不受 dotall 标志 (<code>s</code>) 的影响。",
+                token: "\\N"
+            },
+            {
+                id: "unicodecat",
+                tip: "匹配 '{{getUniCat()}}' Unicode 类别中的任何字符。",
+                label: "unicode category",
+                desc: "匹配指定 Unicode 类别中的字符。例如，<code>\\p{Ll}</code> 可匹配任意小写字母。",
+                ext: "<p>有关类的列表，请参阅 <a href='http://www.pcre.org/original/doc/html/pcrepattern.html'>PCRE 规范</a>.</p>" +
+                    "<p>此功能有多种语法：</p><p><code>\\p{L}</code> <code>\\pL</code></p>",
+                token: "\\p{L}"
+            },
+            {
+                id: "notunicodecat",
+                tip: "匹配任何不在 '{{getUniCat()}}' Unicode 类别中的字符。",
+                label: "not unicode category",
+                desc: "匹配任何不在指定 Unicode 类别中的字符。",
+                ext: "<p>有关类的列表，请参阅 <a href='http://www.pcre.org/original/doc/html/pcrepattern.html'>PCRE 规范</a>.</p>" +
+                    "<p>此功能有多种语法：</p><p><code>\\P{L}</code> <code>\\p{^L}</code> <code>\\PL</code></p>",
+                token: "\\P{L}"
+            },
+            {
+                id: "unicodescript",
+                tip: "匹配 '{{value}}' Unicode 脚本中的任何字符。",
+                label: "unicode script",
+                desc: "匹配指定 Unicode 脚本中的任何字符。例如，<code>\\p{Arabic}</code> 将匹配阿拉伯脚本中的字符。",
+                ext: "<p>有关脚本的列表，请参阅 <a href='http://www.pcre.org/original/doc/html/pcrepattern.html'>PCRE 规范</a>。</p>",
+                token: "\\p{Han}"
+            },
+            {
+                id: "notunicodescript",
+                tip: "匹配任何不在 '{{value}}' Unicode 脚本中的字符。",
+                label: "not unicode script",
+                desc: "匹配任何不在指定 Unicode 脚本中的字符。",
+                ext: "<p>有关脚本的列表，请参阅 <a href='http://www.pcre.org/original/doc/html/pcrepattern.html'>PCRE 规范</a>。</p>" +
+                    "<p>此功能有多种语法：</p><p><code>\\P{Han}</code> <code>\\p{^Han}</code>",
+                token: "\\P{Han}"
+            }
+        ]
+    },
+    {
+        label: "Anchors",
+        id: "anchors",
+        desc: "锚点的独特之处在于它们匹配字符串中的一个位置，而不是一个字符。",
+        kids: [
+            {
+                id: "bos",
+                label: "beginning of string",
+                desc: "匹配字符串的开头。",
+                ext: " 不像 <code>^</code>，这不受多行标志（<code>m</code>）的影响。它匹配一个位置，而不是一个字符。",
+                token: "\\A"
+            },
+            {
+                id: "eos",
+                label: "end of string",
+                desc: "匹配字符串的结尾。",
+                ext: " 不像 <code>$</code>，这不受多行标志（<code>m</code>）的影响。它匹配一个位置，而不是一个字符。",
+                token: "\\Z"
+            },
+            {
+                id: "abseos",
+                label: "strict end of string",
+                desc: "匹配字符串的结尾。不像 <code>$</code> 或 <code>\\Z</code>，它不允许有尾随的换行符。",
+                ext: " 这不受多行标志（<code>m</code>）的影响。它匹配一个位置，而不是一个字符。",
+                token: "\\z"
+            },
+            {
+                id: "bof",
+                label: "beginning",
+                desc: "匹配字符串的开头，或者在启用多行标志（<code>m</code>）时匹配行的开头。",
+                ext: " 这匹配一个位置，而不是一个字符。",
+                example: ["^\\w+", "she sells seashells"],
+                token: "^"
+            },
+            {
+                id: "eof",
+                label: "end",
+                desc: "匹配字符串的结尾，或者在启用多行标志（<code>m</code>）时匹配行的结尾。",
+                ext: " 这匹配一个位置，而不是一个字符。",
+                example: ["\\w+$", "she sells seashells"],
+                token: "$"
+            },
+            {
+                id: "wordboundary",
+                label: "word boundary",
+                desc: "匹配单词字符和非单词字符之间的位置（开始/结束位置）。",
+                ext: " 更多信息请参阅单词字符类（<code>\w</code>）。",
+                example: ["s\\b", "she sells seashells"],
+                token: "\\b"
+            },
+            {
+                id: "notwordboundary",
+                label: "not word boundary",
+                desc: "匹配任何非单词边界的位置。",
+                ext: " 这匹配一个位置，而不是一个字符。",
+                example: ["s\\B", "she sells seashells"],
+                token: "\\B"
+            },
+            {
+                id: "prevmatchend",
+                label: "previous match end",
+                desc: "匹配上一个匹配的结束位置。",
+                ext: " 这匹配一个位置，而不是一个字符。",
+                token: "\\G"
+            }
+        ]
+    },
+    {
+        label: "Escaped characters",
+        id: "escchars",
+        desc: "转义序列可用于插入保留、特殊和 Unicode 字符。所有转义字符均以 <code>\\</code> 字符开头。",
+        kids: [
+            {
+                id: "reservedchar",
+                label: "reserved characters",
+                desc: "以下字符具有特殊含义，应在前面加上 <code>\\</code>（反斜杠）以表示字面字符：" +
+                    "<p><code>{{getEscChars()}}</code></p>" +
+                    "<p>在字符集中，仅 <code>\\</code>、<code>-</code> 和 <code>]</code> 需要转义。</p>",
+                example: ["\\+", "1 + 1 = 2"],
+                token: "\\+",
+                show: true
+            },
+            {
+                id: "escoctal",
+                label: "octal escape",
+                desc: "八进制转义字符，形式为 <code>\\000</code>。",
+                ext: " 值必须小于 255 (<code>\\377</code>).", // PCRE profile adds to ext.
+                example: ["\\251", "RegExr is \u00A92014"],
+                token: "\\000"
+            },
+            {
+                id: "eschexadecimal",
+                label: "hexadecimal escape",
+                desc: "十六进制转义字符，形式为 <code>\\xFF</code>。",
+                example: ["\\xA9", "RegExr is \u00A92014"],
+                token: "\\xFF"
+            },
+            {
+                id: "escunicodeu",
+                label: "unicode escape",
+                desc: "Unicode转义字符，形式为 <code>\\uFFFF</code>",
+                example: ["\\u00A9", "RegExr is \u00A92014"],
+                token: "\\uFFFF"
+            },
+            {
+                id: "escunicodeub",
+                label: "extended unicode escape",
+                desc: "Unicode转义字符，形式为 <code>\\u{FFFF}</code>。",
+                ext: " 支持任意数量的十六进制数字的完整 Unicode 点转义范围。<p>需要 Unicode 标志（<code>u</code>）。</p>",
+                token: "\\u{FFFF}"
+            },
+            {
+                id: "escunicodexb",
+                label: "unicode escape",
+                desc: "Unicode转义字符，形式为 <code>\\x{FF}</code>。",
+                token: "\\x{FF}"
+            },
+            {
+                id: "esccontrolchar",
+                label: "control character escape",
+                desc: "转义控制字符，形式为 <code>\\cZ</code>。",
+                ext: " 这可以从 <code>\\cA</code>（SOH，字符代码 1）到 <code>\\cZ</code>（SUB，字符代码 26）不等。<h1>示例：</h1><code>\\cI</code> 匹配 TAB（字符代码 9）。",
+                token: "\\cI"
+            },
+            {
+                id: "escsequence",
+                label: "escape sequence",
+                tip: "匹配字面字符串 '{{value}}'.",
+                desc: "所有在 <code>\\Q</code> 和 <code>\\E</code> 之间的字符都被解释为字面字符串。如果省略 <code>\\E</code>，则持续匹配到表达式的末尾。",
+                ext: " 例如，表达式 <code>/\\Q(?.)\\E/</code> 将匹配字符串 <code>(?.)</code>。",
+                token: "\\Q...\\E"
+            }
+        ]
+    },
+    {
+        label: "Groups & References",
+        id: "groups",
+        desc: "分组允许您将一系列标记组合在一起以便一起操作。捕获组可以通过反向引用进行引用，并在结果中单独访问。",
+        kids: [
+            {
+                id: "group",
+                label: "capturing group",
+                desc: "将多个标记组合在一起，并创建一个捕获组以提取子字符串或使用反向引用。",
+                example: ["(ha)+", "hahaha haa hah!"],
+                token: "(ABC)"
+            },
+            {
+                id: "namedgroup",
+                label: "named capturing group",
+                tip: "创建一个名为 '{{name}}' 的捕获组。",
+                desc: "创建一个可以通过指定名称进行引用的捕获组。",
+                ext: "<p>有多种语法可以实现此功能：</p><p><code>(?'name'ABC)</code> <code>(?P&lt;name>ABC)</code> <code>(?&lt;name>ABC)</code></p>",
+                token: "(?<name>ABC)"
+            },
+            {
+                id: "namedref",
+                label: "named reference",
+                tip: "匹配名为 '{{group.name}}' 的捕获组的结果。",
+                desc: "匹配一个命名捕获组的结果。",
+                ext: "<p>有多种语法可以实现此功能：</p><p><code>\\k'name'</code> <code>\\k&lt;name></code> <code>\\k{name}</code> <code>\\g{name}</code> <code>(?P=name)</code></p>",
+                token: "\\k'name'"
+            },
+            {
+                id: "numref",
+                label: "numeric reference",
+                tip: "匹配捕获组 #{{group.num}} 的结果。",
+                desc: "匹配一个捕获组的结果。例如 <code>\\1</code> 匹配第一个捕获组的结果 & <code>\\3</code> 匹配第三个。",
+                // PCRE adds relative and alternate syntaxes in ext
+                example: ["(\\w)a\\1", "hah dad bad dab gag gab"],
+                token: "\\1"
+            },
+            {
+                id: "branchreset",
+                label: "branch reset group",
+                desc: "定义共享相同组号的交替组。",
+                ext: "<p>例如，在 <code>(?|(a)|(b))</code> 中，两个组 (a 和 b) 都将被计算为组 #1。</p>",
+                token: "(?|(a)|(b))"
+            },
+            {
+                id: "noncapgroup",
+                label: "non-capturing group",
+                desc: "将多个标记组合在一起而不创建捕获组。",
+                example: ["(?:ha)+", "hahaha haa hah!"],
+                token: "(?:ABC)"
+            },
+            {
+                id: "atomic",
+                label: "atomic group",
+                desc: "非捕获组，一旦匹配就会丢弃回溯位置。",
+                ext: "<p>例如，<code>/(?>ab|a)b/</code> 将匹配 <code>abb</code> 但不匹配 <code>ab</code>，因为一旦 <code>ab</code> 选项匹配成功，原子组就会阻止回溯以重试 <code>a</code> 选项。</p>",
+                token: "(?>ABC)"
+            },
+            {
+                id: "define",
+                desc: "用于定义命名组，以便用作子例程，而不将其包含在匹配中。",
+                ext: "<p>例如，<code>/A(?(DEFINE)(?'foo'Z))B\\g'foo'/</code> 将匹配 <code>ABZ</code>，因为定义组在匹配中被忽略，除了定义稍后通过 <code>\\g'foo'</code> 引用的 <code>foo</code> 子例程。</p>",
+                token: "(?(DEFINE)(?'foo'ABC))"
+            },
+            {
+                id: "numsubroutine",
+                label: "numeric subroutine",
+                tip: "匹配捕获组 #{{group.num}} 中的表达式。",
+                desc: "匹配一个捕获组中的表达式。与引用相比，引用匹配的是结果。" +
+                    " 例如 <code>/(a|b)\\g'1'/</code> 可以匹配 <code>ab</code>，因为表达式 <code>a|b</code> 会再次被求值。",
+                ext: "<p>有多种语法可以实现此功能： <code>\\g&lt;1></code> <code>\\g'1'</code> <code>(?1)</code>。</p>" +
+                    "<p>相对值可以用 <code>+</code> 或 <code>-</code> 前缀。例如 <code>\\g<-1></code> 将匹配引用前面的组。</p>",
+                token: "\\g'1'"
+            },
+            {
+                id: "namedsubroutine",
+                label: "named subroutine",
+                tip: "匹配名为 '{{group.name}}' 的捕获组中的表达式。",
+                desc: "匹配一个捕获组中的表达式。与引用相比，引用匹配的是结果。",
+                ext: "<p>有多种语法可以实现此功能： <code>\\g&lt;name></code> <code>\\g'name'</code> <code>(?&name)</code> <code>(?P>name)</code>。</p>",
+                token: "\\g'name'"
+            }
+        ]
+    },
+    {
+        label: "Lookaround",
+        id: "lookaround",
+        desc: "环视允许您在主模式之前（后顾）或之后（前瞻）匹配一个组，而不将其包含在结果中。" +
+            "<p>负向环视指定一个组，该组不能在模式之前或之后匹配。</p>",
+        kids: [
+            {
+                id: "poslookahead",
+                label: "positive lookahead",
+                desc: "匹配主表达式后面的组，而不将其包含在结果中。",
+                example: ["\\d(?=px)", "1pt 2px 3em 4px"],
+                token: "(?=ABC)"
+            },
+            {
+                id: "neglookahead",
+                label: "negative lookahead",
+                desc: "指定一个组，该组不能在主表达式之后匹配（如果匹配，则结果被丢弃）。",
+                example: ["\\d(?!px)", "1pt 2px 3em 4px"],
+                token: "(?!ABC)"
+            },
+            {
+                id: "poslookbehind",
+                label: "positive lookbehind",
+                desc: "匹配主表达式前面的组，而不将其包含在结果中。",
+                token: "(?<=ABC)"
+            },
+            {
+                id: "neglookbehind",
+                label: "negative lookbehind",
+                desc: "指定一个组，该组不能在主表达式之前匹配（如果匹配，则结果被丢弃）。",
+                token: "(?<!ABC)"
+            },
+            {
+                id: "keepout",
+                label: "keep out",
+                desc: "将到目前为止匹配的文本排除在返回的匹配结果之外，基本上丢弃到此为止的匹配。",
+                ext: "例如 <code>/o\\Kbar/</code> 将在字符串 <code>foobar</code> 中匹配 <code>bar</code>",
+                token: "\\K"
+            }
+        ]
+    },
+    {
+        label: "Quantifiers & Alternation",
+        id: "quants",
+        desc: "量词指示前面的标记必须匹配一定次数。默认情况下，量词是贪婪的，将尽可能多地匹配字符。" +
+            "<hr/>交替充当布尔 OR，匹配一个序列或另一个。",
+        kids: [
+            {
+                id: "plus",
+                desc: "匹配前一个标记 1 次或多次。",
+                example: ["b\\w+", "b be bee beer beers"],
+                token: "+"
+            },
+            {
+                id: "star",
+                desc: "匹配前一个标记 0 次或多次。",
+                example: ["b\\w*", "b be bee beer beers"],
+                token: "*"
+            },
+            {
+                id: "quant",
+                label: "quantifier",
+                tip: "匹配 {{getQuant()}} 的前一个标记。",
+                desc: "匹配前一个标记的指定数量。 " +
+                    "<code>{1,3}</code> 将匹配 1 到 3 次。 " +
+                    "<code>{3}</code> 将匹配 3 次。 " +
+                    "<code>{3,}</code> 将匹配 3 次或更多。 ",
+                example: ["b\\w{2,3}", "b be bee beer beers"],
+                token: "{1,3}"
+            },
+            {
+                id: "opt",
+                label: "optional",
+                desc: "匹配前一个标记 0 次或 1 次，有效地使其成为可选的。",
+                example: ["colou?r", "color colour"],
+                token: "?"
+            },
+            {
+                id: "lazy",
+                tip: "使前面的量词变为 {{getLazy()}}, 导致它尽可能少地匹配 {{getLazyFew()}} 个字符。",
+                desc: "使前面的量词变为懒惰，导致它尽可能少地匹配字符。",
+                ext: " 默认情况下，量词是贪婪的，将匹配尽可能多的字符。",
+                example: ["b\\w+?", "b be bee beer beers"],
+                token: "?"
+            },
+            {
+                id: "possessive",
+                desc: "Makes the preceding quantifier possessive. It will match as many characters as possible, and will not release them to match subsequent tokens.",
+                ext: "<p>For example <code>/.*a/</code> would match <code>aaa</code>, but <code>/.*+a/</code> would not, because the repeating dot would match and not release the last character to match <code>a</code>.</p>",
+                token: "+"
+            },
+            {
+                id: "alt",
+                label: "alternation",
+                desc: "充当布尔 OR。匹配 <code>|</code> 之前或之后的表达式。",
+                ext: "<p>它可以在组内或整个表达式上操作。模式将按顺序进行测试。</p>",
+                example: ["b(a|e|i)d", "bad bud bod bed bid"],
+                token: "|"
+            }
+        ]
+    },
+    {
+        label: "Special",
+        id: "other",
+        desc: "不在其它类别的标记",
+        kids: [
+            {
+                id: "comment",
+                desc: "允许您在表达式中插入注释，在查找匹配时会被忽略。",
+                token: "(?#foo)"
+            },
+            {
+                id: "conditional",
+                desc: "根据是否匹配到一个环视，有条件地匹配两个选项之一",
+                ext: "<p>例如，<code>/(?(?=a)ab|..)/</code> 将匹配 <code>ab</code> 和 <code>zx</code> 但不匹配 <code>ax</code>，因为如果第一个字符匹配条件 <code>a</code>，则会评估模式 <code>ab</code>。</p>" +
+                    "<p>可以将任何环视用作条件。前瞻将从条件的开始处开始后续匹配，后顾将在其后开始。</p>",
+                token: "(?(?=A)B|C)"
+            },
+            {
+                id: "conditionalgroup",
+                label: "group conditional",
+                desc: "根据组 '{{name}}' 是否匹配，条件性地匹配两个选项之一。",
+                ext: "<p>例如，<code>/(z)?(?(1)a|b)/</code> 将匹配 <code>za</code> 因为第一个捕获组成功匹配 <code>z</code>，这导致条件匹配第一个选项 <code>a</code>。</p>" +
+                    "<p>相同的模式也将单独匹配 <code>b</code>，因为组 1 不匹配，因此它会尝试匹配第二个选项 <code>b</code>。</p>" +
+                    "<p>您可以通过名称、编号或相对位置（例如 <code>-1</code>）引用组。</p>",
+                token: "(?(1)B|C)"
+            },
+            {
+                id: "recursion",
+                desc: "尝试在当前位置再次匹配完整表达式。",
+                ext: "<p>例如，<code>/a(?R)?b/</code> 将匹配任意数量的 <code>a</code> 后跟相同数量的 <code>z</code>：完整文本 <code>az</code> 或 <code>aaaazzzz</code>，但不匹配 <code>azzz</code>。</p>" +
+                    "<p>此功能有多种语法：</p><p><code>(?R)</code> <code>(?0)</code> <code>\\g<0></code> <code>\\g'0'</code></p>",
+                token: "(?R)"
+            },
+            {
+                id: "mode",
+                label: "mode modifier",
+                tip: "{{~getDesc()}}{{~getModes()}}",
+                desc: "启用或禁用剩余表达式的模式。",
+                ext: "匹配模式通常映射到表达式标志。例如 <code>(?i)</code> 将为表达式的其余部分启用不区分大小写。" +
+                    "<p>可以指定多个修饰符，任何跟随 <code>-</code> 的修饰符将被禁用。例如 <code>(?im-s)</code> 将启用不区分大小写和多行模式，并禁用点任意模式。</p>" +
+                    "<p>支持的修饰符有：<code>i</code> - 不区分大小写，<code>s</code> - 点任意，<code>m</code> - 多行，<code>x</code> - 自由间距，<code>J</code> - 允许重复名称，<code>U</code> - 非贪婪。</p>",
+                token: "(?i)"
+            }
+        ]
+    },
+    {
+        label: "Substitution",
+        desc: "这些标记用于替换字符串中以插入匹配的不同部分。",
+        target: "subst",
+        id: "subst",
+        kids: [
+            {
+                id: "subst_$&match",
+                label: "match",
+                desc: "插入匹配的文本。",
+                token: "$&"
+            },
+            {
+                id: "subst_0match",
+                label: "match",
+                desc: "插入匹配的文本。",
+                ext: "<p>此功能有多种语法：</p><p><code>$0</code> <code>\\0</code> <code>\\{0}</code></p>",
+                token: "$0"
+            },
+            {
+                id: "subst_group",
+                label: "capture group",
+                tip: "插入捕获组 #{{group.num}} 的结果。",
+                desc: "插入指定捕获组的结果。例如，<code>$3</code> 将插入第三个捕获组。",
+                // NOTE: javascript profile overrides this:
+                ext: "<p>此功能有多种语法：</p><p><code>$1</code> <code>\\1</code> <code>\\{1}</code></p>",
+                token: "$1"
+            },
+            {
+                id: "subst_$before",
+                label: "before match",
+                desc: "插入匹配之前的源字符串部分。",
+                token: "$`"
+            },
+            {
+                id: "subst_$after",
+                label: "after match",
+                desc: "插入匹配之后的源字符串部分。",
+                token: "$'"
+            },
+            {
+                id: "subst_$esc",
+                label: "escaped $",
+                desc: "插入美元符号字符 ($)。",
+                token: "$$"
+            },
+            {
+                id: "subst_esc",
+                label: "escaped characters",
+                token: "\\n",
+                desc: "出于方便，以下转义字符在 RegExr 的替换字符串中受支持：<code>\\n</code>、<code>\\r</code>、<code>\\t</code>、<code>\\\\</code> 和 Unicode 转义 <code>\\uFFFF</code>。这可能会因您的部署环境而异。"
+            }
+        ]
+    },
+    {
+        id: "flags",
+        label: "Flags",
+        tooltip: "表达式标志改变了表达式的解释方式。单击以编辑。",
+        desc: "表达式标志改变了表达式的解释方式。标志跟随表达式的闭合斜杠（例如 <code>/.+/igm</code>）。",
+        target: "flags",
+        kids: [
+            {
+                id: "caseinsensitive",
+                label: "ignore case",
+                desc: "使整个表达式不区分大小写。",
+                ext: "例如，<code>/aBc/i</code> 将匹配 <code>AbC</code>。",
+                token: "i"
+            },
+            {
+                id: "global",
+                label: "global search",
+                tip: "保留最后一次匹配的索引，允许迭代搜索。",
+                desc: "保留最后一次匹配的索引，允许后续搜索从上一次匹配的末尾开始。" +
+                    "<p>如果没有全局标志，后续搜索将返回相同的匹配。</p><hr/>" +
+                    "RegExr 仅在全局标志禁用时搜索单个匹配，以避免无限匹配错误。",
+                token: "g"
+            },
+            {
+                id: "multiline",
+                tip: "行首/行尾锚点 (<b>^</b>/<b>$</b>) 将匹配行的开始/结束。",
+                desc: "当启用多行标志时，行首和行尾锚点 (<code>^</code> 和 <code>$</code>) 将匹配行的开始和结束，而不是整个字符串的开始和结束。" +
+                    "<p>请注意，诸如 <code>/^[\\s\\S]+$/m</code> 的模式可能会返回跨越多行的匹配，因为锚点将匹配 <b>任何</b> 行的开始/结束。</p>",
+                token: "m"
+            },
+            {
+                id: "unicode",
+                tip: "启用 <code>\\x{FFFFF}</code> Unicode 转义。",
+                desc: "当启用 Unicode 标志时，可以使用扩展的 Unicode 转义形式 <code>\\x{FFFFF}</code>。" +
+                    "<p>这还会使其他转义变得更严格，导致未识别的转义（例如 <code>\\j</code>）抛出错误。</p>",
+                token: "u"
+            },
+            {
+                id: "sticky",
+                desc: "该表达式将仅从其 lastIndex 位置进行匹配，并在设置时忽略全局 (<code>g</code>) 标志。",
+                ext: " 因为 RegExr 中的每个搜索都是离散的，因此此标志对显示结果没有进一步影响。",
+                token: "y"
+            },
+            {
+                id: "dotall",
+                desc: "Dot (<code>.</code>) 将匹配任何字符，包括换行符。",
+                token: "s"
+            },
+            {
+                id: "extended",
+                desc: "字面空格字符被忽略，字符集除外。",
+                token: "x"
+            },
+            {
+                id: "ungreedy",
+                tip: "将量词默认设置为非贪婪（懒惰）。",
+                desc: "将量词默认设置为非贪婪（懒惰）。跟随 <code>?</code> 的量词将变为贪婪。",
+                token: "U"
+            }
+        ]
+    }
+];
+// content that isn't included in the Reference menu item:
+o.misc = {
+    kids: [
+        {
+            id: "ignorews",
+            label: "ignored whitespace",
+            tip: "由于扩展标志或模式，空格字符被忽略。"
+        },
+        {
+            id: "extnumref", // alternative syntaxes.
+            proxy: "numref"
+        },
+        {
+            id: "char",
+            label: "character",
+            tip: "匹配一个 {{getChar()}} 字符 (字符代码 {{code}})。 {{getInsensitive()}}"
+        },
+        {
+            id: "escchar",
+            label: "escaped character",
+            tip: "匹配一个 {{getChar()}} 字符 (字符代码 {{code}})。"
+        },
+        {
+            id: "open",
+            tip: "表示正则表达式的开始。"
+        },
+        {
+            id: "close",
+            tip: "表示正则表达式的结束和表达式标志的开始。"
+        },
+        {
+            id: "condition",
+            tip: "用于解析封闭条件语句的前瞻匹配。有关信息，请参阅参考中的 'conditional'。"
+        },
+        {
+            id: "conditionalelse",
+            label: "conditional else",
+            tip: "分隔条件的 'else' 部分。"
+        },
+        {
+            id: "ERROR",
+            tip: "表达式中的错误以红色下划线标记。悬停以获取更多信息。"
+        },
+        {
+            id: "PREG_INTERNAL_ERROR",
+            tip: "内部 PCRE 错误"
+        },
+        {
+            id: "PREG_BACKTRACK_LIMIT_ERROR",
+            tip: "回溯限制已耗尽。"
+        },
+        {
+            id: "PREG_RECURSION_LIMIT_ERROR",
+            tip: "递归限制已耗尽。"
+        },
+        {
+            id: "PREG_BAD_UTF8_ERROR",
+            tip: "Malformed UTF-8 data"
+        },
+        {
+            id: "PREG_BAD_UTF8_OFFSET_ERROR",
+            tip: "Malformed UTF-8 data"
+        }
+    ]
+};
+o.errors = {
+    groupopen: "未匹配的左括号。",
+    groupclose: "未匹配的右括号。",
+    setopen: "未匹配的左方括号。",
+    rangerev: "范围值反转。起始字符代码大于结束字符代码。",
+    quanttarg: "量词的目标无效。",
+    quantrev: "量词的最小值大于最大值。",
+    esccharopen: "悬空的反斜杠。",
+    esccharbad: "未识别或格式错误的转义字符。",
+    unicodebad: "未识别的 Unicode 类别或脚本。",
+    posixcharclassbad: "未识别的 POSIX 字符类。",
+    posixcharclassnoset: "POSIX 字符类必须在字符集中。",
+    notsupported: "\"{{~getLabel()}}\" 功能在此 RegEx 版本中不受支持。",
+    fwdslash: "未转义的斜杠。如果将此表达式复制/粘贴到代码中，可能会导致问题。",
+    esccharbad: "无效的转义序列。",
+    servercomm: "与服务器通信时发生错误。",
+    extraelse: "条件组中多余的 else。",
+    unmatchedref: "对不存在的组 \"{{name}}\" 的引用。",
+    modebad: "未识别的模式标志 \"<code>{{errmode}}</code>\"。",
+    badname: "组名不能以数字开头。",
+    dupname: "重复的组名。",
+    branchreseterr: "<b>分支重置。</b> 结果将是正确的，但 RegExr 的解析器未正确编号分支重置组。敬请期待！",
+    timeout: "该表达式的执行时间超过 250 毫秒。", // TODO: can we couple this to the help content somehow?
+    // warnings:
+    jsfuture: "\"{{~getLabel()}}\" 功能可能不受所有浏览器支持。",
+    infinite: "该表达式可能会返回空匹配，并且在某些用例中可能会无限匹配。", // TODO: can we couple this to the help content somehow？
+};
+/*
+classes:
+quant
+set
+special
+ref
+esc
+anchor
+charclass
+group
+comment
+ */
+//# sourceMappingURL=reference_content.js.map