@port-labs/jq-node-bindings 0.0.13 → 0.0.15-dev1

package/deps/jq/modules/oniguruma/doc/RE

@@ -1,6 +1,6 @@
-Oniguruma Regular Expressions Version 6.0.0    2016/08/18
+Oniguruma Regular Expressions Version 6.9.9    2023/03/27
 
-syntax: ONIG_SYNTAX_RUBY (default)
+syntax: ONIG_SYNTAX_ONIGURUMA (default syntax)
 
 
 1. Syntax elements
@@ -21,17 +21,28 @@ syntax: ONIG_SYNTAX_RUBY (default)
   \f           form feed              (0x0C)
   \a           bell                   (0x07)
   \e           escape                 (0x1B)
-  \nnn         octal char             (encoded byte value)
-  \xHH         hexadecimal char       (encoded byte value)
-  \x{7HHHHHHH} wide hexadecimal char  (character code point value)
-  \cx          control char           (character code point value)
-  \C-x         control char           (character code point value)
-  \M-x         meta  (x|0x80)         (character code point value)
-  \M-\C-x      meta control char      (character code point value)
+  \nnn         octal char                    (encoded byte value)
+  \xHH         hexadecimal char              (encoded byte value)
+  \x{7HHHHHHH} (1-8 digits) hexadecimal char (code point value)
+  \o{17777777777} (1-11 digits) octal char   (code point value)
+  \uHHHH       hexadecimal char              (code point value)
+  \cx          control char                  (code point value)
+  \C-x         control char                  (code point value)
+  \M-x         meta  (x|0x80)                (code point value)
+  \M-\C-x      meta control char             (code point value)
 
  (* \b as backspace is effective in character class only)
 
 
+2.1 Code point sequences
+
+  Hexadecimal code point  (1-8 digits)
+  \x{7HHHHHHH 7HHHHHHH ... 7HHHHHHH}
+
+  Octal code point  (1-11 digits)
+  \o{17777777777 17777777777 ... 17777777777}
+
+
 3. Character types
 
   .        any character (except newline)
@@ -51,8 +62,8 @@ syntax: ONIG_SYNTAX_RUBY (default)
            Not Unicode:
              \t, \n, \v, \f, \r, \x20
 
-           Unicode:
-             0009, 000A, 000B, 000C, 000D, 0085(NEL),
+           Unicode case:
+             U+0009, U+000A, U+000B, U+000C, U+000D, U+0085(NEL),
              General_Category -- Line_Separator
                               -- Paragraph_Separator
                               -- Space_Separator
@@ -69,6 +80,34 @@ syntax: ONIG_SYNTAX_RUBY (default)
 
   \H       non-hexdigit char
 
+  \R       general newline  (* can't be used in character-class)
+           "\r\n" or \n,\v,\f,\r  (* but doesn't backtrack from \r\n to \r)
+
+           Unicode case:
+             "\r\n" or \n,\v,\f,\r or U+0085, U+2028, U+2029
+
+  \N       negative newline  (?-m:.)
+
+  \O       true anychar      (?m:.)    (* original function)
+
+  \X       Text Segment    \X === (?>\O(?:\Y\O)*)
+
+           The meaning of this operator changes depending on the setting of
+           the option (?y{..}).
+
+           \X doesn't check whether matching start position is boundary or not.
+           Please write as \y\X if you want to ensure it.
+
+           [Extended Grapheme Cluster mode] (default)
+             Unicode case:
+               See [Unicode Standard Annex #29: http://unicode.org/reports/tr29/]
+
+             Not Unicode case:  \X === (?>\r\n|\O)
+
+           [Word mode]
+             Currently, this mode is supported in Unicode only.
+             See [Unicode Standard Annex #29: http://unicode.org/reports/tr29/]
+
 
   Character Property
 
@@ -97,27 +136,35 @@ syntax: ONIG_SYNTAX_RUBY (default)
     ?       1 or 0 times
     *       0 or more times
     +       1 or more times
-    {n,m}   at least n but no more than m times
+    {n,m}   (n <= m)  at least n but no more than m times
     {n,}    at least n times
     {,n}    at least 0 but no more than n times ({0,n})
     {n}     n times
 
+
   reluctant
 
-    ??      1 or 0 times
+    ??      0 or 1 times
     *?      0 or more times
     +?      1 or more times
-    {n,m}?  at least n but not more than m times
+    {n,m}?  (n <= m)  at least n but not more than m times
     {n,}?   at least n times
     {,n}?   at least 0 but not more than n times (== {0,n}?)
 
+      {n}? is reluctant operator in ONIG_SYNTAX_JAVA and ONIG_SYNTAX_PERL only.
+      (In that case, it doesn't make sense to write so.)
+      In default syntax, /a{n}?/ === /(?:a{n})?/
+
+
   possessive (greedy and does not backtrack once match)
 
     ?+      1 or 0 times
     *+      0 or more times
     ++      1 or more times
+    {n,m}   (n > m)  at least m but not more than n times
 
-    ({n,m}+, {n,}+, {n}+ are possessive op. in ONIG_SYNTAX_JAVA only)
+      {n,m}+, {n,}+, {n}+ are possessive operators in ONIG_SYNTAX_JAVA and
+      ONIG_SYNTAX_PERL only.
 
     ex. /a*+/ === /(?>a*)/
 
@@ -128,10 +175,31 @@ syntax: ONIG_SYNTAX_RUBY (default)
   $       end of the line
   \b      word boundary
   \B      non-word boundary
+
   \A      beginning of string
   \Z      end of string, or before newline at the end
   \z      end of string
   \G      where the current search attempt begins
+  \K      keep (keep start position of the result string)
+
+
+  \y      Text Segment boundary
+  \Y      Text Segment non-boundary
+
+          The meaning of these operators(\y, \Y) changes depending on the setting
+          of the option (?y{..}).
+
+          [Extended Grapheme Cluster mode] (default)
+            Unicode case:
+              See [Unicode Standard Annex #29: http://unicode.org/reports/tr29/]
+
+            Not Unicode:
+              All positions except between \r and \n.
+
+          [Word mode]
+            Currently, this mode is supported in Unicode only.
+            See [Unicode Standard Annex #29: http://unicode.org/reports/tr29/]
+
 
 
 6. Character class
@@ -178,13 +246,11 @@ syntax: ONIG_SYNTAX_RUBY (default)
       graph    [[:^space:]] && ^Control && ^Unassigned && ^Surrogate
       lower    Lowercase_Letter
       print    [[:graph:]] | [[:space:]]
-      punct    Connector_Punctuation | Dash_Punctuation | Close_Punctuation |
-               Final_Punctuation | Initial_Punctuation | Other_Punctuation |
-               Open_Punctuation
+      punct    Punctuation | Symbol
       space    Space_Separator | Line_Separator | Paragraph_Separator |
-               0009 | 000A | 000B | 000C | 000D | 0085
+               U+0009 | U+000A | U+000B | U+000C | U+000D | U+0085
       upper    Uppercase_Letter
-      xdigit   0030 - 0039 | 0041 - 0046 | 0061 - 0066
+      xdigit   U+0030 - U+0039 | U+0041 - U+0046 | U+0061 - U+0066
                (0-9, a-f, A-F)
       word     Letter | Mark | Decimal_Number | Connector_Punctuation
 
@@ -194,26 +260,60 @@ syntax: ONIG_SYNTAX_RUBY (default)
 
   (?#...)            comment
 
-  (?imx-imx)         option on/off
-                         i: ignore case
-                         m: multi-line (dot (.) also matches newline)
-                         x: extended form
-  (?imx-imx:subexp)  option on/off for subexp
+  (?imxWDSPy-imxWDSP:subexp)  option on/off for subexp
+
+                           i: ignore case
+                           m: multi-line (dot (.) also matches newline)
+                           x: extended form
+                           W: ASCII only word (\w, \p{Word}, [[:word:]])
+                              ASCII only word bound (\b)
+                           D: ASCII only digit (\d, \p{Digit}, [[:digit:]])
+                           S: ASCII only space (\s, \p{Space}, [[:space:]])
+                           P: ASCII only POSIX properties (includes W,D,S)
+                              (alnum, alpha, blank, cntrl, digit, graph,
+                               lower, print, punct, space, upper, xdigit, word)
+
+                           y{?}: Text Segment mode
+                              This option changes the meaning of \X, \y, \Y.
+                              Currently, this option is supported in Unicode only.
+
+                              y{g}: Extended Grapheme Cluster mode (default)
+                              y{w}: Word mode
+                              See [Unicode Standard Annex #29]
+
+  (?imxWDSPy-imxWDSP)  isolated option
+
+                      * It makes a group to the next ')' or end of the pattern.
+                        /ab(?i)c|def|gh/ == /ab(?i:c|def|gh)/
+
+  * (?i) option has no effect on word types (\w, \p{Word}). However, if the word types are used within a character class, it is valid. But, this would only be a concern when word types are used with the (?W) option.
+
+
+  /(?CIL).../, /(?CIL:...)/   whole option
+
+                            This option must be placed in a position that
+                            affects the entire regular expression.
+
+                            C: ONIG_OPTION_DONT_CAPTURE_GROUP
+                            I: ONIG_OPTION_IGNORECASE_IS_ASCII
+                            L: ONIG_OPTION_FIND_LONGEST
 
   (?:subexp)         non-capturing group
   (subexp)           capturing group
 
   (?=subexp)         look-ahead
   (?!subexp)         negative look-ahead
+
   (?<=subexp)        look-behind
   (?<!subexp)        negative look-behind
 
-                     Subexp of look-behind must be fixed-width.
-                     But top-level alternatives can be of various lengths.
-                     ex. (?<=a|bc) is OK. (?<=aaa(?:b|cd)) is not allowed.
+                     * Cannot use Absent stopper (?~|expr) and Range clear
+                       (?~|) operators in look-behind and negative look-behind.
 
-                     In negative look-behind, capturing group isn't allowed,
-                     but non-capturing group (?:) is allowed.
+                     * In look-behind and negative look-behind, support for
+                       ignore-case option is limited. Only supports conversion
+                       between single characters. (Does not support conversion
+                       of multiple characters in Unicode)
 
   (?>subexp)         atomic group
                      no backtracks in subexp.
@@ -228,6 +328,82 @@ syntax: ONIG_SYNTAX_RUBY (default)
                      Assigning the same name to two or more subexps is allowed.
 
 
+  <Callouts>
+
+  * Callouts of contents
+  (?{...contents...})         callout in progress
+  (?{...contents...}D)        D is a direction flag char
+                              D = 'X': in progress and retraction
+                                  '<': in retraction only
+                                  '>': in progress only
+  (?{...contents...}[tag])    tag assigned
+  (?{...contents...}[tag]D)
+
+                              * Escape characters have no effects in contents.
+                              * contents is not allowed to start with '{'.
+
+  (?{{{...contents...}}})     n times continuations '}' in contents is allowed in
+                              (n+1) times continuations {{{...}}}.
+
+    Allowed tag string characters: _ A-Z a-z 0-9 (* first character: _ A-Z a-z)
+
+
+  * Callouts of name
+  (*name)
+  (*name{args...})            with args
+  (*name[tag])                tag assigned
+  (*name[tag]{args...})
+
+    Allowed name string characters: _ A-Z a-z 0-9 (* first character: _ A-Z a-z)
+    Allowed tag  string characters: _ A-Z a-z 0-9 (* first character: _ A-Z a-z)
+
+
+  <Absent functions>
+
+  (?~absent)         Absent repeater    (* proposed by Tanaka Akira)
+                     This works like .* (more precisely \O*), but it is
+                     limited by the range that does not include the string
+                     match with <absent>.
+                     This is a written abbreviation of (?~|(?:absent)|\O*).
+                     \O* is used as a repeater.
+
+  (?~|absent|exp)    Absent expression  (* original)
+                     This works like "exp", but it is limited by the range
+                     that does not include the string match with <absent>.
+
+                     ex. (?~|345|\d*)  "12345678"  ==> "12", "1", ""
+
+  (?~|absent)        Absent stopper (* original)
+                     After passed this operator, string right range is limited
+                     at the point that does not include the string match with
+                     <absent>.
+
+  (?~|)              Range clear
+                     Clear the effects caused by Absent stoppers.
+
+     * Nested Absent functions are not supported and the behavior
+       is undefined.
+
+
+  <if-then-else>
+
+  (?(condition_exp)then_exp|else_exp)    if-then-else
+  (?(condition_exp)then_exp)             if-then
+
+               condition_exp can be a backreference number/name or a normal
+               regular expression.
+               When condition_exp is a backreference number/name, both then_exp and
+               else_exp can be omitted.
+               Then it works as a backreference validity checker.
+
+  [ Backreference validity checker ]   (* original)
+
+    (?(n)), (?(-n)), (?(+n)), (?(n+level)) ...
+    (?(<n>)), (?('-n')), (?(<+n>)) ...
+    (?(<name>)), (?('name')), (?(<name+level>)) ...
+
+
+
 8. Backreferences
 
   When we say "backreference a group," it actually means, "re-match the same
@@ -236,6 +412,8 @@ syntax: ONIG_SYNTAX_RUBY (default)
   \n  \k<n>     \k'n'     (n >= 1) backreference the nth group in the regexp
       \k<-n>    \k'-n'    (n >= 1) backreference the nth group counting
                           backwards from the referring position
+      \k<+n>    \k'+n'    (n >= 1) backreference the nth group counting
+                          forwards from the referring position
       \k<name>  \k'name'  backreference a group with the specified name
 
   When backreferencing with a name that is assigned to more than one groups,
@@ -279,14 +457,17 @@ syntax: ONIG_SYNTAX_RUBY (default)
       p r.match("<foo>f<bar>bbb</bar>f</foo>").captures
 
 
-9. Subexp calls ("Tanaka Akira special")
+9. Subexp calls ("Tanaka Akira special")   (* original function)
 
   When we say "call a group," it actually means, "re-execute the subexp in
   that group."
 
   \g<n>     \g'n'     (n >= 1) call the nth group
+  \g<0>     \g'0'     call zero (call the total regexp)
   \g<-n>    \g'-n'    (n >= 1) call the nth group counting backwards from
                       the calling position
+  \g<+n>    \g'+n'    (n >= 1) call the nth group counting forwards from
+                      the calling position
   \g<name>  \g'name'  call the group with the specified name
 
   * Left-most recursive calls are not allowed.
@@ -339,7 +520,7 @@ syntax: ONIG_SYNTAX_RUBY (default)
 -----------------------------
 A-1. Syntax-dependent options
 
-   + ONIG_SYNTAX_RUBY
+   + ONIG_SYNTAX_ONIGURUMA
      (?m): dot (.) also matches newline
 
    + ONIG_SYNTAX_PERL and ONIG_SYNTAX_JAVA
@@ -349,19 +530,22 @@ A-1. Syntax-dependent options
 
 A-2. Original extensions
 
-   + hexadecimal digit char type  \h, \H
-   + named group                  (?<name>...), (?'name'...)
-   + named backref                \k<name>
-   + subexp call                  \g<name>, \g<group-num>
+   + hexadecimal digit char type     \h, \H
+   + true anychar                    \O
+   + text segment boundary           \y, \Y
+   + backreference validity checker  (?(...))
+   + named group                     (?<name>...), (?'name'...)
+   + named backref                   \k<name>
+   + subexp call                     \g<name>, \g<group-num>
+   + absent expression               (?~|...|...)
+   + absent stopper                  (?~|...)
 
 
 A-3. Missing features compared with perl 5.8.0
 
    + \N{name}
-   + \l,\u,\L,\U, \X, \C
-   + (?{code})
+   + \l,\u,\L,\U,\C
    + (??{code})
-   + (?(condition)yes-pat|no-pat)
 
    * \Q...\E
      This is effective on ONIG_SYNTAX_PERL and ONIG_SYNTAX_JAVA.
@@ -409,28 +593,4 @@ A-4. Differences with Japanized GNU regex(version 0.12) of Ruby 1.8
      /(?:()|())*\1\2/ =~ ""
      /(?:\1a|())*/ =~ "a"
 
-
-A-5. Features disabled in default syntax
-
-   + capture history
-
-     (?@...) and (?@<name>...)
-
-     ex. /(?@a)*/.match("aaa") ==> [<0-1>, <1-2>, <2-3>]
-
-     see sample/listcap.c file.
-
-
-A-6. Problems
-
-   + Invalid encoding byte sequence is not checked.
-
-     ex. UTF-8
-
-     * Invalid first byte is treated as a character.
-       /./u =~ "\xa3"
-
-     * Incomplete byte sequence is not checked.
-       /\w+/ =~ "a\xf3\x8ec"
-
 // END