.editorconfig

@@ -7,3 +7,7 @@ indent_size = 4
 end_of_line = lf
 insert_final_newline = true
 trim_trailing_whitespace = true
+max_line_length = 100
+
+[*.yml]
+indent_size = 2

.travis.yml

@@ -0,0 +1,3 @@
+language: node_js
+node_js:
+  - node

LICENSE

@@ -1,6 +1,6 @@
 The MIT License
 
-Copyright (c) 2007-2016 Steven Levithan <http://xregexp.com/>
+Copyright (c) 2007-2017 Steven Levithan <http://xregexp.com/>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -1,25 +1,26 @@
-[XRegExp](http://xregexp.com/) 3.1.1
-====================================
+# XRegExp 3.2.0
 
-XRegExp provides augmented (and extensible) JavaScript regular expressions. You get new modern syntax and flags beyond what browsers support natively. XRegExp is also a regex utility belt with tools to make your client-side grepping and parsing easier, while freeing you from worrying about pesky aspects of JavaScript regexes like cross-browser inconsistencies or manually manipulating `lastIndex`.
+[![Build Status](https://travis-ci.org/slevithan/xregexp.svg?branch=master)](https://travis-ci.org/slevithan/xregexp)
 
-XRegExp supports all native ES6 regular expression syntax. It supports Internet Explorer 5.5+, Firefox 1.5+, Chrome, Safari 3+, and Opera 11+. You can also use it with Node.js or as a RequireJS module.
+XRegExp provides augmented (and extensible) JavaScript regular expressions. You get modern syntax and flags beyond what browsers support natively. XRegExp is also a regex utility belt with tools to make your grepping and parsing easier, while freeing you from regex cross-browser inconsistencies and other annoyances.
+
+XRegExp supports all native ES6 regular expression syntax. It supports Internet Explorer 5.5+, Firefox 1.5+, Chrome, Safari 3+, and Opera 11+. You can use it with Node.js or as a RequireJS module.
 
 ## Performance
 
-XRegExp regexes compile to native `RegExp` objects, and therefore perform just as fast as native regular expressions. There is a tiny extra cost when compiling a pattern for the first time.
+XRegExp compiles to native `RegExp` objects. Therefore regexes built with XRegExp perform just as fast as native regular expressions. There is a tiny extra cost when compiling a pattern for the first time.
 
 ## Usage examples
 
 ```js
 // Using named capture and flag x (free-spacing and line comments)
-var date = XRegExp('(?<year>  [0-9]{4} ) -?  # year  \n\
-                    (?<month> [0-9]{2} ) -?  # month \n\
-                    (?<day>   [0-9]{2} )     # day   ', 'x');
+var date = XRegExp(`(?<year>  [0-9]{4} ) -?  # year
+                    (?<month> [0-9]{2} ) -?  # month
+                    (?<day>   [0-9]{2} )     # day`, 'x');
 
 // XRegExp.exec gives you named backreferences on the match result
-var match = XRegExp.exec('2015-02-22', date);
-match.year; // -> '2015'
+var match = XRegExp.exec('2017-02-22', date);
+match.year; // -> '2017'
 
 // It also includes optional pos and sticky arguments
 var pos = 3;
@@ -31,31 +32,31 @@ while (match = XRegExp.exec('<1><2><3><4>5<6>', /<(\d+)>/, pos, 'sticky')) {
 // result -> ['2', '3', '4']
 
 // XRegExp.replace allows named backreferences in replacements
-XRegExp.replace('2015-02-22', date, '${month}/${day}/${year}');
-// -> '02/22/2015'
-XRegExp.replace('2015-02-22', date, function(match) {
+XRegExp.replace('2017-02-22', date, '${month}/${day}/${year}');
+// -> '02/22/2017'
+XRegExp.replace('2017-02-22', date, (match) => {
     return match.month + '/' + match.day + '/' + match.year;
 });
-// -> '02/22/2015'
+// -> '02/22/2017'
 
-// In fact, XRegExps compile to RegExps and work perfectly with native methods
-date.test('2015-02-22');
+// XRegExps compile to RegExps and work perfectly with native methods
+date.test('2017-02-22');
 // -> true
 
 // The only caveat is that named captures must be referenced using numbered
 // backreferences if used with native methods
-'2015-02-22'.replace(date, '$2/$3/$1');
-// -> '02/22/2015'
+'2017-02-22'.replace(date, '$2/$3/$1');
+// -> '02/22/2017'
 
-// Extract every other digit from a string using XRegExp.forEach
+// Use XRegExp.forEach to extract every other digit from a string
 var evens = [];
-XRegExp.forEach('1a2345', /\d/, function(match, i) {
+XRegExp.forEach('1a2345', /\d/, (match, i) => {
     if (i % 2) evens.push(+match[0]);
 });
 // evens -> [2, 4]
 
-// Get numbers within <b> tags using XRegExp.matchChain
-XRegExp.matchChain('1 <b>2</b> 3 <b>4 a 56</b>', [
+// Use XRegExp.matchChain to get numbers within <b> tags
+XRegExp.matchChain('1 <b>2</b> 3 <B>4 \n 56</B>', [
     XRegExp('(?is)<b>.*?</b>'),
     /\d+/
 ]);
@@ -71,11 +72,11 @@ XRegExp.matchChain(html, [
 // -> ['xregexp.com', 'www.google.com']
 
 // Merge strings and regexes into a single pattern with updated backreferences
-XRegExp.union(['a+b*c', /(dog)\1/, /(cat)\1/], 'i');
+XRegExp.union(['a+b*c', /(dog)\1/, /(cat)\1/], 'i', {conjunction: 'or'});
 // -> /a\+b\*c|(dog)\1|(cat)\2/i
 ```
 
-These examples give the flavor of what's possible, but XRegExp has more syntax, flags, methods, options, and browser fixes that aren't shown here. You can even augment XRegExp's regular expression syntax with addons (see below) or write your own. See [xregexp.com](http://xregexp.com/) for details.
+These examples give the flavor of what's possible, but XRegExp has more syntax, flags, methods, options, and browser fixes that aren't shown here. You can also augment XRegExp's regular expression syntax with addons (see below) or write your own. See [xregexp.com](http://xregexp.com/) for details.
 
 ## Addons
 
@@ -99,7 +100,7 @@ XRegExp('^\\p{Hiragana}+$').test('ひらがな'); // -> true
 XRegExp('^[\\p{Latin}\\p{Common}]+$').test('Über Café.'); // -> true
 ```
 
-By default, `\p{…}` and `\P{…}` support the Basic Multilingual Plane (i.e. code points up to `U+FFFF`). You can opt-in to full 21-bit Unicode support (with code points up to `U+10FFFF`) on a per-regex basis by using flag `A`. In XRegExp, this is called *astral mode*. You can automatically add flag `A` for all new regexes by running `XRegExp.install('astral')`. When in astral mode, `\p{…}` and `\P{…}` always match a full code point rather than a code unit, using surrogate pairs for code points above `U+FFFF`.
+By default, `\p{…}` and `\P{…}` support the Basic Multilingual Plane (i.e. code points up to `U+FFFF`). You can opt-in to full 21-bit Unicode support (with code points up to `U+10FFFF`) on a per-regex basis by using flag `A`. This is called *astral mode*. You can automatically add flag `A` for all new regexes by running `XRegExp.install('astral')`. When in astral mode, `\p{…}` and `\P{…}` always match a full code point rather than a code unit, using surrogate pairs for code points above `U+FFFF`.
 
 ```js
 // Using flag A to match astral code points
@@ -116,7 +117,7 @@ XRegExp('^\\pS$').test('💩'); // -> true
 
 Opting in to astral mode disables the use of `\p{…}` and `\P{…}` within character classes. In astral mode, use e.g. `(\pL|[0-9_])+` instead of `[\pL0-9_]+`.
 
-XRegExp uses Unicode 8.0.0.
+XRegExp uses Unicode 9.0.0.
 
 ### XRegExp.build
 
@@ -205,17 +206,15 @@ var XRegExp = require('xregexp');
 In an AMD loader like [RequireJS](http://requirejs.org/):
 
 ```js
-require({paths: {xregexp: 'xregexp-all'}}, ['xregexp'], function(XRegExp) {
+require({paths: {xregexp: 'xregexp-all'}}, ['xregexp'], (XRegExp) => {
     console.log(XRegExp.version);
 });
 ```
 
 ## About
 
-XRegExp copyright 2007-2016 by [Steven Levithan](http://stevenlevithan.com/).
-
-Unicode range generators by [Mathias Bynens](http://mathiasbynens.be/), and adapted from his [unicode-data](https://github.com/mathiasbynens/unicode-data) project. Uses [Jasmine](http://jasmine.github.io/) for unit tests, and [Benchmark.js](http://benchmarkjs.com) for performance tests. `XRegExp.build` inspired by [RegExp.create](http://lea.verou.me/2011/03/create-complex-regexps-more-easily/) by [Lea Verou](http://lea.verou.me/). `XRegExp.union` inspired by [Ruby](http://www.ruby-lang.org/). XRegExp's syntax extensions and flags come from [Perl](http://www.perl.org/), [.NET](http://www.microsoft.com/net), etc.
+XRegExp copyright 2007-2017 by [Steven Levithan](http://stevenlevithan.com/). Unicode data generators by [Mathias Bynens](http://mathiasbynens.be/), adapted from [unicode-data](http://git.io/unicode). XRegExp's syntax extensions and flags come from [Perl](http://www.perl.org/), [.NET](http://www.microsoft.com/net), etc.
 
 All code, including addons, tools, and tests, is released under the terms of the [MIT License](http://mit-license.org/).
 
-Fork me to show support, fix, and extend.
+Learn more at [xregexp.com](http://xregexp.com/).

bower.json

@@ -1,6 +1,6 @@
 {
     "name": "xregexp",
-    "version": "3.1.1",
+    "version": "3.2.0",
     "description": "Extended regular expressions",
     "homepage": "http://xregexp.com/",
     "authors": [

package.json

@@ -1,6 +1,6 @@
 {
   "name": "xregexp",
-  "version": "3.1.1",
+  "version": "3.2.0",
   "description": "Extended regular expressions",
   "homepage": "http://xregexp.com/",
   "author": "Steven Levithan <steves_list@hotmail.com>",
@@ -15,14 +15,19 @@
     "regular expression",
     "unicode"
   ],
-  "main": "./src/index.js",
+  "main": "xregexp-all.js",
   "files": [
-    "src"
+    "src",
+    "xregexp-all.js",
+    "LICENSE"
   ],
   "scripts": {
-    "build": "browserify src/index.js --standalone XRegExp > xregexp-all.js"
+    "build": "browserify src/index.js --standalone XRegExp > xregexp-all.js",
+    "pretest": "npm run build",
+    "test": "jasmine JASMINE_CONFIG_PATH=tests/jasmine.json"
   },
   "devDependencies": {
-    "browserify": "^12.0.1"
+    "browserify": "^12.0.1",
+    "jasmine": "^2.5.3"
   }
 }

src/addons/build.js

@@ -1,28 +1,31 @@
 /*!
- * XRegExp.build 3.1.1
+ * XRegExp.build 3.2.0
  * <xregexp.com>
- * Steven Levithan (c) 2012-2016 MIT License
+ * Steven Levithan (c) 2012-2017 MIT License
  * Inspired by Lea Verou's RegExp.create <lea.verou.me>
  */
 
 module.exports = function(XRegExp) {
     'use strict';
 
     var REGEX_DATA = 'xregexp';
-    var subParts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*]/g;
-    var parts = XRegExp.union([/\({{([\w$]+)}}\)|{{([\w$]+)}}/, subParts], 'g');
+    var subParts = /(\()(?!\?)|\\([1-9]\d*)|\\[\s\S]|\[(?:[^\\\]]|\\[\s\S])*\]/g;
+    var parts = XRegExp.union([/\({{([\w$]+)}}\)|{{([\w$]+)}}/, subParts], 'g', {
+        conjunction: 'or'
+    });
 
     /**
      * Strips a leading `^` and trailing unescaped `$`, if both are present.
      *
+     * @private
      * @param {String} pattern Pattern to process.
      * @returns {String} Pattern with edge anchors removed.
      */
     function deanchor(pattern) {
         // Allow any number of empty noncapturing groups before/after anchors, because regexes
         // built/generated by XRegExp sometimes include them
-        var leadingAnchor = /^(?:\(\?:\))*\^/,
-            trailingAnchor = /\$(?:\(\?:\))*$/;
+        var leadingAnchor = /^(?:\(\?:\))*\^/;
+        var trailingAnchor = /\$(?:\(\?:\))*$/;
 
         if (
             leadingAnchor.test(pattern) &&
@@ -39,26 +42,31 @@ module.exports = function(XRegExp) {
     /**
      * Converts the provided value to an XRegExp. Native RegExp flags are not preserved.
      *
+     * @private
      * @param {String|RegExp} value Value to convert.
+     * @param {Boolean} [addFlagX] Whether to apply the `x` flag in cases when `value` is not
+     *   already a regex generated by XRegExp
      * @returns {RegExp} XRegExp object with XRegExp syntax applied.
      */
-    function asXRegExp(value) {
+    function asXRegExp(value, addFlagX) {
+        var flags = addFlagX ? 'x' : '';
         return XRegExp.isRegExp(value) ?
             (value[REGEX_DATA] && value[REGEX_DATA].captureNames ?
                 // Don't recompile, to preserve capture names
                 value :
                 // Recompile as XRegExp
-                XRegExp(value.source)
+                XRegExp(value.source, flags)
             ) :
             // Compile string as XRegExp
-            XRegExp(value);
+            XRegExp(value, flags);
     }
 
     /**
      * Builds regexes using named subpatterns, for readability and pattern reuse. Backreferences in
      * the outer pattern and provided subpatterns are automatically renumbered to work correctly.
      * Native flags used by provided subpatterns are ignored in favor of the `flags` argument.
      *
+     * @memberOf XRegExp
      * @param {String} pattern XRegExp pattern using `{{name}}` for embedded subpatterns. Allows
      *   `({{name}})` as shorthand for `(?<name>{{name}})`. Patterns cannot be embedded within
      *   character classes.
@@ -79,50 +87,49 @@ module.exports = function(XRegExp) {
      * XRegExp.exec('10:59', time).minutes; // -> '59'
      */
     XRegExp.build = function(pattern, subs, flags) {
-        var inlineFlags = /^\(\?([\w$]+)\)/.exec(pattern),
-            data = {},
-            numCaps = 0, // 'Caps' is short for captures
-            numPriorCaps,
-            numOuterCaps = 0,
-            outerCapsMap = [0],
-            outerCapNames,
-            sub,
-            p;
-
+        flags = flags || '';
+        // Used with `asXRegExp` calls for `pattern` and subpatterns in `subs`, to work around how
+        // some browsers convert `RegExp('\n')` to a regex that contains the literal characters `\`
+        // and `n`. See more details at <https://github.com/slevithan/xregexp/pull/163>.
+        var addFlagX = flags.indexOf('x') > -1;
+        var inlineFlags = /^\(\?([\w$]+)\)/.exec(pattern);
         // Add flags within a leading mode modifier to the overall pattern's flags
         if (inlineFlags) {
-            flags = flags || '';
-            inlineFlags[1].replace(/./g, function(flag) {
-                // Don't add duplicates
-                flags += (flags.indexOf(flag) > -1 ? '' : flag);
-            });
+            flags = XRegExp._clipDuplicates(flags + inlineFlags[1]);
         }
 
-        for (p in subs) {
+        var data = {};
+        for (var p in subs) {
             if (subs.hasOwnProperty(p)) {
                 // Passing to XRegExp enables extended syntax and ensures independent validity,
                 // lest an unescaped `(`, `)`, `[`, or trailing `\` breaks the `(?:)` wrapper. For
                 // subpatterns provided as native regexes, it dies on octals and adds the property
-                // used to hold extended regex instance data, for simplicity
-                sub = asXRegExp(subs[p]);
+                // used to hold extended regex instance data, for simplicity.
+                var sub = asXRegExp(subs[p], addFlagX);
                 data[p] = {
                     // Deanchoring allows embedding independently useful anchored regexes. If you
-                    // really need to keep your anchors, double them (i.e., `^^...$$`)
+                    // really need to keep your anchors, double them (i.e., `^^...$$`).
                     pattern: deanchor(sub.source),
                     names: sub[REGEX_DATA].captureNames || []
                 };
             }
         }
 
         // Passing to XRegExp dies on octals and ensures the outer pattern is independently valid;
-        // helps keep this simple. Named captures will be put back
-        pattern = asXRegExp(pattern);
-        outerCapNames = pattern[REGEX_DATA].captureNames || [];
-        pattern = pattern.source.replace(parts, function($0, $1, $2, $3, $4) {
-            var subName = $1 || $2,
-                capName,
-                intro,
-                localCapIndex;
+        // helps keep this simple. Named captures will be put back.
+        var patternAsRegex = asXRegExp(pattern, addFlagX);
+
+        // 'Caps' is short for 'captures'
+        var numCaps = 0;
+        var numPriorCaps;
+        var numOuterCaps = 0;
+        var outerCapsMap = [0];
+        var outerCapNames = patternAsRegex[REGEX_DATA].captureNames || [];
+        var output = patternAsRegex.source.replace(parts, function($0, $1, $2, $3, $4) {
+            var subName = $1 || $2;
+            var capName;
+            var intro;
+            var localCapIndex;
             // Named subpattern
             if (subName) {
                 if (!data.hasOwnProperty(subName)) {
@@ -180,7 +187,7 @@ module.exports = function(XRegExp) {
             return $0;
         });
 
-        return XRegExp(pattern, flags);
+        return XRegExp(output, flags);
     };
 
 };