regjsparser-0.3.0/000077500000000000000000000000001322400266200140365ustar00rootroot00000000000000regjsparser-0.3.0/.editorconfig000066400000000000000000000002231322400266200165100ustar00rootroot00000000000000root = true [*] indent_style = space indent_size = 2 end_of_line = lf trim_trailing_whitespace = true insert_final_newline = true charset = utf-8 regjsparser-0.3.0/.gitignore000066400000000000000000000000711322400266200160240ustar00rootroot00000000000000*~ local.mk build/ tags .DS_Store Makefile node_modules/ regjsparser-0.3.0/.travis.yml000066400000000000000000000006131322400266200161470ustar00rootroot00000000000000sudo: false language: node_js node_js: - "0.8" - "0.10" - "0.12" - "iojs" script: - "npm test" deploy: provider: npm email: "julian.viereck@gmail.com" api_key: secure: QieqFrJl/NTuVbyt+dBz3GLaH1czdlPKLtgOGwU3S/WF5RxFyGMix8SOA0avw4UbZErzAg9Io59c75lZ6aUOzTDXBzhZ/zbUPznAuFtNIVo0B2gjoUjiNuhLG0ciYnIpM8A8KWf8O3XnPeM/gQVMMaXiO84pGn4bctusOzoVNJE= on: tags: true all_branches: true regjsparser-0.3.0/CHANGELOG000066400000000000000000000007211322400266200152500ustar00rootroot000000000000002014-08-31: Version 0.1.2 * Change the field ref to matchIndex on the type=refernce node (issue #67) 2014-08-30: Version 0.1.1 * Only handled unicode code point escapes if 'u' flag is set (issue #56) * Removed `matchIdx` from the AST * References like /\1/ were broken (issue #57) * Renamed type `ref` to `reference` in the AST * Update regex to match identifier and include script to generate regex 2014-06-29: Version 0.1.0 * first tagged release regjsparser-0.3.0/LICENSE.BSD000066400000000000000000000024241322400266200154540ustar00rootroot00000000000000Copyright (c) Julian Viereck and Contributors, All Rights Reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. regjsparser-0.3.0/README.md000066400000000000000000000013011322400266200153100ustar00rootroot00000000000000# RegJSParser Parsing the JavaScript's RegExp in JavaScript. ## Installation ```bash npm install regjsparser ``` ## Usage ```js var parse = require('regjsparser').parse; var parseTree = parse('^a'); // /^a/ console.log(parseTree); // Toggle on/off additional features: var parseTree = parse('^a', { // SEE: https://github.com/jviereck/regjsparser/pull/78 unicodePropertyEscape: true, // SEE: https://github.com/jviereck/regjsparser/pull/83 namedGroups: true }); console.log(parseTree); ``` ## Testing To run the tests, run the following command: ```bash npm test ``` To create a new reference file, execute… ```bash node test/update-fixtures.js ``` …from the repo top directory. regjsparser-0.3.0/bin/000077500000000000000000000000001322400266200146065ustar00rootroot00000000000000regjsparser-0.3.0/bin/parser000077500000000000000000000033631322400266200160350ustar00rootroot00000000000000#!/usr/bin/env node (function() { var fs = require('fs'); var path = require('path'); var parse = require('../parser').parse; var jsesc = require('jsesc'); var regexes = process.argv.splice(2); var first = regexes[0]; var data; var log = console.log; var flags = ''; var main = function() { if (/^(?:-h|--help|undefined)$/.test(first)) { log([ '\nUsage:\n', '\tregjsparser [regex ...]', '\tregjsparser [-f | --flags] u [regex ...]', '\tregjsparser [-v | --version]', '\tregjsparser [-h | --help]', '\nExamples:\n', '\tregjsparser \'^foo.bar$\'', '\tregjsparser \'[a-zA-Z0-9]\'' ].join('\n')); return process.exit(1); } if (/^(?:-v|--version)$/.test(first)) { log('v%s', require(path.resolve(__dirname, '../package.json')).version); return process.exit(1); } if (/^(?:-f|--flags)$/.test(first)) { flags = regexes[1]; regexes = regexes.slice(2); } regexes.forEach(function(snippet) { try { result = parse(snippet, flags); log(jsesc(result, { 'json': true, 'compact': false, 'indent': '\t' })); } catch(error) { log(error.message + '\n'); log('Error: failed to parse. Make sure the regular expression is valid.'); log('If you think this is a bug in regjsparser, please report it:'); log('\thttps://github.com/jviereck/regjsparser/issues/new'); log('\nStack trace:\n'); log(error.stack); return process.exit(1); } }); // Return with exit status 0 outside of the `forEach` loop, in case // multiple regular expressions were passed in. return process.exit(0); }; main(); }()); regjsparser-0.3.0/demo/000077500000000000000000000000001322400266200147625ustar00rootroot00000000000000regjsparser-0.3.0/demo/main.js000066400000000000000000000041531322400266200162470ustar00rootroot00000000000000(function(window, document) { var inputs = document.getElementsByTagName('input'); var textareas = document.getElementsByTagName('textarea'); var regex = inputs[0]; var flags = inputs[1]; var ast = textareas[0]; var regjsparser = window.regjsparser; var permalink = document.getElementById('permalink'); // https://mathiasbynens.be/notes/localstorage-pattern var storage = (function() { var uid = new Date; var storage; var result; try { (storage = window.localStorage).setItem(uid, uid); result = storage.getItem(uid) == uid; storage.removeItem(uid); return result && storage; } catch (exception) {} }()); function encode(string) { // URL-encode some more characters to avoid issues when using permalink URLs in Markdown return encodeURIComponent(string).replace(/['()_*]/g, function(character) { return '%' + character.charCodeAt().toString(16); }); } function update() { var regexSource = regex.value; var regexFlags = flags.value; var regexAst; var isError = false; try { regexAst = regjsparser.parse(regexSource, regexFlags); } catch (exception) { isError = true; } if (isError) { regex.className = flags.className = ast.className = 'invalid'; ast.value = '// Error during parsing.'; } else { regex.className = flags.className = ast.className = ''; ast.value = JSON.stringify(regexAst, null, 2); } permalink.hash = encode('/' + regexSource + '/' + regexFlags); storage && (storage.regexSource = regexSource) && (storage.regexFlags = regexFlags); }; regex.oninput = flags.oninput = update; if (storage) { storage.regexSource && (regex.value = storage.regexSource) && (flags.value = storage.regexFlags); update(); } window.onhashchange = function() { var value = decodeURIComponent(location.hash.slice(1)); var lastSlashIndex = value.lastIndexOf('/'); regex.value = value.slice(1, lastSlashIndex); flags.value = value.slice(lastSlashIndex + 1); update(); }; if (location.hash) { window.onhashchange(); } }(this, document)); regjsparser-0.3.0/demo/styles.css000066400000000000000000000024711322400266200170230ustar00rootroot00000000000000html, textarea, input { font: .8em/1.6 sans-serif; } body { max-width: 40em; padding: 0 1em; } h1 { text-align: center; font-size: 1.3em; margin: 0 0 .5em; padding-top: 1em; } h2 { font-size: 1em; } a { color: #333; text-decoration: none; border-bottom: 1px solid #aaa; padding: .1em .2em; } a:hover, a:focus { color: #fff; border-color: #036; background: #36c; } textarea, input { font-family: Monaco, Consolas, monospace; } #footer { margin-top: 2em; text-align: center; } textarea, input { border: 3px double green; background: #90ee90; -moz-box-sizing: border-box; -webkit-box-sizing: border-box; box-sizing: border-box; display: inline-block; margin: 0 .5em; padding: .5em; resize: vertical; } textarea { display: block; width: 100%; min-height: 14.5em; margin: 1em 0 .5em; padding: .7em; } code { font-family: Monaco, Consolas, monospace; font-size: .9em; white-space: pre; white-space: pre-wrap; word-wrap: break-word; } .invalid, :invalid { border-color: red; background: #ffb6c1; } @media (min-width: 42em) { html { font-size: 1.2em; background: #c4c4c4; height: 100%; } body { margin: 0 auto; padding: 0 2em; min-height: 100%; background: #fff; border: solid #aaa; border-width: 0 1px; } } regjsparser-0.3.0/index.html000066400000000000000000000016461322400266200160420ustar00rootroot00000000000000 regjsparser demo

regjsparser demo

regjsparser is a parser for JavaScript’s regular expressions syntax.

Regular Expression

//

AST: ()

regjsparser-0.3.0/package.json000066400000000000000000000011331322400266200163220ustar00rootroot00000000000000{ "name": "regjsparser", "version": "0.2.1", "author": "'Julian Viereck' ", "license": "BSD-2-Clause", "main": "./parser", "bin": "bin/parser", "homepage": "https://github.com/jviereck/regjsparser", "repository": { "type": "git", "url": "git@github.com:jviereck/regjsparser.git" }, "scripts": { "test": "node test/index.js" }, "files": [ "bin/", "LICENSE.BSD", "parser.js", "README.md" ], "dependencies": { "jsesc": "~0.5.0" }, "devDependencies": { "regenerate": "~1.0.1", "unicode-7.0.0": "~0.1.5" } } regjsparser-0.3.0/parser.js000066400000000000000000001111101322400266200156630ustar00rootroot00000000000000// regjsparser // // ================================================================== // // See ECMA-262 Standard: 15.10.1 // // NOTE: The ECMA-262 standard uses the term "Assertion" for /^/. Here the // term "Anchor" is used. // // Pattern :: // Disjunction // // Disjunction :: // Alternative // Alternative | Disjunction // // Alternative :: // [empty] // Alternative Term // // Term :: // Anchor // Atom // Atom Quantifier // // Anchor :: // ^ // $ // \ b // \ B // ( ? = Disjunction ) // ( ? ! Disjunction ) // // Quantifier :: // QuantifierPrefix // QuantifierPrefix ? // // QuantifierPrefix :: // * // + // ? // { DecimalDigits } // { DecimalDigits , } // { DecimalDigits , DecimalDigits } // // Atom :: // PatternCharacter // . // \ AtomEscape // CharacterClass // ( GroupSpecifier Disjunction ) // ( ? : Disjunction ) // // PatternCharacter :: // SourceCharacter but not any of: ^ $ \ . * + ? ( ) [ ] { } | // // AtomEscape :: // DecimalEscape // CharacterEscape // CharacterClassEscape // k GroupName // // CharacterEscape[U] :: // ControlEscape // c ControlLetter // HexEscapeSequence // RegExpUnicodeEscapeSequence[?U] (ES6) // IdentityEscape[?U] // // ControlEscape :: // one of f n r t v // ControlLetter :: // one of // a b c d e f g h i j k l m n o p q r s t u v w x y z // A B C D E F G H I J K L M N O P Q R S T U V W X Y Z // // IdentityEscape :: // SourceCharacter but not IdentifierPart // // // // DecimalEscape :: // DecimalIntegerLiteral [lookahead ∉ DecimalDigit] // // CharacterClassEscape :: // one of d D s S w W // // CharacterClass :: // [ [lookahead ∉ {^}] ClassRanges ] // [ ^ ClassRanges ] // // ClassRanges :: // [empty] // NonemptyClassRanges // // NonemptyClassRanges :: // ClassAtom // ClassAtom NonemptyClassRangesNoDash // ClassAtom - ClassAtom ClassRanges // // NonemptyClassRangesNoDash :: // ClassAtom // ClassAtomNoDash NonemptyClassRangesNoDash // ClassAtomNoDash - ClassAtom ClassRanges // // ClassAtom :: // - // ClassAtomNoDash // // ClassAtomNoDash :: // SourceCharacter but not one of \ or ] or - // \ ClassEscape // // ClassEscape :: // DecimalEscape // b // CharacterEscape // CharacterClassEscape // // GroupSpecifier :: // [empty] // ? GroupName // // GroupName :: // < RegExpIdentifierName > // // RegExpIdentifierName :: // RegExpIdentifierStart // RegExpIdentifierName RegExpIdentifierContinue // // RegExpIdentifierStart :: // UnicodeIDStart // $ // _ // \ RegExpUnicodeEscapeSequence // // RegExpIdentifierContinue :: // UnicodeIDContinue // $ // _ // \ RegExpUnicodeEscapeSequence // // (function() { var fromCodePoint = String.fromCodePoint || (function() { // Implementation taken from // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/fromCodePoint var stringFromCharCode = String.fromCharCode; var floor = Math.floor; return function fromCodePoint() { var MAX_SIZE = 0x4000; var codeUnits = []; var highSurrogate; var lowSurrogate; var index = -1; var length = arguments.length; if (!length) { return ''; } var result = ''; while (++index < length) { var codePoint = Number(arguments[index]); if ( !isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity` codePoint < 0 || // not a valid Unicode code point codePoint > 0x10FFFF || // not a valid Unicode code point floor(codePoint) != codePoint // not an integer ) { throw RangeError('Invalid code point: ' + codePoint); } if (codePoint <= 0xFFFF) { // BMP code point codeUnits.push(codePoint); } else { // Astral code point; split in surrogate halves // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae codePoint -= 0x10000; highSurrogate = (codePoint >> 10) + 0xD800; lowSurrogate = (codePoint % 0x400) + 0xDC00; codeUnits.push(highSurrogate, lowSurrogate); } if (index + 1 == length || codeUnits.length > MAX_SIZE) { result += stringFromCharCode.apply(null, codeUnits); codeUnits.length = 0; } } return result; }; }()); function parse(str, flags, features) { if (!features) { features = {}; } function addRaw(node) { node.raw = str.substring(node.range[0], node.range[1]); return node; } function updateRawStart(node, start) { node.range[0] = start; return addRaw(node); } function createAnchor(kind, rawLength) { return addRaw({ type: 'anchor', kind: kind, range: [ pos - rawLength, pos ] }); } function createValue(kind, codePoint, from, to) { return addRaw({ type: 'value', kind: kind, codePoint: codePoint, range: [from, to] }); } function createEscaped(kind, codePoint, value, fromOffset) { fromOffset = fromOffset || 0; return createValue(kind, codePoint, pos - (value.length + fromOffset), pos); } function createCharacter(matches) { var _char = matches[0]; var first = _char.charCodeAt(0); if (hasUnicodeFlag) { var second; if (_char.length === 1 && first >= 0xD800 && first <= 0xDBFF) { second = lookahead().charCodeAt(0); if (second >= 0xDC00 && second <= 0xDFFF) { // Unicode surrogate pair pos++; return createValue( 'symbol', (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000, pos - 2, pos); } } } return createValue('symbol', first, pos - 1, pos); } function createDisjunction(alternatives, from, to) { return addRaw({ type: 'disjunction', body: alternatives, range: [ from, to ] }); } function createDot() { return addRaw({ type: 'dot', range: [ pos - 1, pos ] }); } function createCharacterClassEscape(value) { return addRaw({ type: 'characterClassEscape', value: value, range: [ pos - 2, pos ] }); } function createReference(matchIndex) { return addRaw({ type: 'reference', matchIndex: parseInt(matchIndex, 10), range: [ pos - 1 - matchIndex.length, pos ] }); } function createNamedReference(name) { return addRaw({ type: 'reference', name: name, range: [ name.range[0] - 3, pos ] }); } function createGroup(behavior, disjunction, from, to) { return addRaw({ type: 'group', behavior: behavior, body: disjunction, range: [ from, to ] }); } function createQuantifier(min, max, from, to) { if (to == null) { from = pos - 1; to = pos; } return addRaw({ type: 'quantifier', min: min, max: max, greedy: true, body: null, // set later on range: [ from, to ] }); } function createAlternative(terms, from, to) { return addRaw({ type: 'alternative', body: terms, range: [ from, to ] }); } function createCharacterClass(classRanges, negative, from, to) { return addRaw({ type: 'characterClass', body: classRanges, negative: negative, range: [ from, to ] }); } function createClassRange(min, max, from, to) { // See 15.10.2.15: if (min.codePoint > max.codePoint) { bail('invalid range in character class', min.raw + '-' + max.raw, from, to); } return addRaw({ type: 'characterClassRange', min: min, max: max, range: [ from, to ] }); } function flattenBody(body) { if (body.type === 'alternative') { return body.body; } else { return [body]; } } function isEmpty(obj) { return obj.type === 'empty'; } function incr(amount) { amount = (amount || 1); var res = str.substring(pos, pos + amount); pos += (amount || 1); return res; } function skip(value) { if (!match(value)) { bail('character', value); } } function match(value) { if (str.indexOf(value, pos) === pos) { return incr(value.length); } } function lookahead() { return str[pos]; } function current(value) { return str.indexOf(value, pos) === pos; } function next(value) { return str[pos + 1] === value; } function matchReg(regExp) { var subStr = str.substring(pos); var res = subStr.match(regExp); if (res) { res.range = []; res.range[0] = pos; incr(res[0].length); res.range[1] = pos; } return res; } function parseDisjunction() { // Disjunction :: // Alternative // Alternative | Disjunction var res = [], from = pos; res.push(parseAlternative()); while (match('|')) { res.push(parseAlternative()); } if (res.length === 1) { return res[0]; } return createDisjunction(res, from, pos); } function parseAlternative() { var res = [], from = pos; var term; // Alternative :: // [empty] // Alternative Term while (term = parseTerm()) { res.push(term); } if (res.length === 1) { return res[0]; } return createAlternative(res, from, pos); } function parseTerm() { // Term :: // Anchor // Atom // Atom Quantifier if (pos >= str.length || current('|') || current(')')) { return null; /* Means: The term is empty */ } var anchor = parseAnchor(); if (anchor) { return anchor; } var atom = parseAtom(); if (!atom) { bail('Expected atom'); } var quantifier = parseQuantifier() || false; if (quantifier) { quantifier.body = flattenBody(atom); // The quantifier contains the atom. Therefore, the beginning of the // quantifier range is given by the beginning of the atom. updateRawStart(quantifier, atom.range[0]); return quantifier; } return atom; } function parseGroup(matchA, typeA, matchB, typeB) { var type = null, from = pos; if (match(matchA)) { type = typeA; } else if (match(matchB)) { type = typeB; } else { return false; } return finishGroup(type, from); } function finishGroup(type, from) { var body = parseDisjunction(); if (!body) { bail('Expected disjunction'); } skip(')'); var group = createGroup(type, flattenBody(body), from, pos); if (type == 'normal') { // Keep track of the number of closed groups. This is required for // parseDecimalEscape(). In case the string is parsed a second time the // value already holds the total count and no incrementation is required. if (firstIteration) { closedCaptureCounter++; } } return group; } function parseAnchor() { // Anchor :: // ^ // $ // \ b // \ B // ( ? = Disjunction ) // ( ? ! Disjunction ) var res, from = pos; if (match('^')) { return createAnchor('start', 1 /* rawLength */); } else if (match('$')) { return createAnchor('end', 1 /* rawLength */); } else if (match('\\b')) { return createAnchor('boundary', 2 /* rawLength */); } else if (match('\\B')) { return createAnchor('not-boundary', 2 /* rawLength */); } else { return parseGroup('(?=', 'lookahead', '(?!', 'negativeLookahead'); } } function parseQuantifier() { // Quantifier :: // QuantifierPrefix // QuantifierPrefix ? // // QuantifierPrefix :: // * // + // ? // { DecimalDigits } // { DecimalDigits , } // { DecimalDigits , DecimalDigits } var res, from = pos; var quantifier; var min, max; if (match('*')) { quantifier = createQuantifier(0); } else if (match('+')) { quantifier = createQuantifier(1); } else if (match('?')) { quantifier = createQuantifier(0, 1); } else if (res = matchReg(/^\{([0-9]+)\}/)) { min = parseInt(res[1], 10); quantifier = createQuantifier(min, min, res.range[0], res.range[1]); } else if (res = matchReg(/^\{([0-9]+),\}/)) { min = parseInt(res[1], 10); quantifier = createQuantifier(min, undefined, res.range[0], res.range[1]); } else if (res = matchReg(/^\{([0-9]+),([0-9]+)\}/)) { min = parseInt(res[1], 10); max = parseInt(res[2], 10); if (min > max) { bail('numbers out of order in {} quantifier', '', from, pos); } quantifier = createQuantifier(min, max, res.range[0], res.range[1]); } if (quantifier) { if (match('?')) { quantifier.greedy = false; quantifier.range[1] += 1; } } return quantifier; } function parseAtom() { // Atom :: // PatternCharacter // . // \ AtomEscape // CharacterClass // ( GroupSpecifier Disjunction ) // ( ? : Disjunction ) var res; // jviereck: allow ']', '}' here as well to be compatible with browser's // implementations: ']'.match(/]/); // if (res = matchReg(/^[^^$\\.*+?()[\]{}|]/)) { if (res = matchReg(/^[^^$\\.*+?(){[|]/)) { // PatternCharacter return createCharacter(res); } else if (match('.')) { // . return createDot(); } else if (match('\\')) { // \ AtomEscape res = parseAtomEscape(); if (!res) { bail('atomEscape'); } return res; } else if (res = parseCharacterClass()) { return res; } else if (features.namedGroups && match("(?<")) { var name = parseIdentifier(); skip(">"); var group = finishGroup("normal", name.range[0] - 3); group.name = name; return group; } else { // ( Disjunction ) // ( ? : Disjunction ) return parseGroup('(?:', 'ignore', '(', 'normal'); } } function parseUnicodeSurrogatePairEscape(firstEscape) { if (hasUnicodeFlag) { var first, second; if (firstEscape.kind == 'unicodeEscape' && (first = firstEscape.codePoint) >= 0xD800 && first <= 0xDBFF && current('\\') && next('u') ) { var prevPos = pos; pos++; var secondEscape = parseClassEscape(); if (secondEscape.kind == 'unicodeEscape' && (second = secondEscape.codePoint) >= 0xDC00 && second <= 0xDFFF) { // Unicode surrogate pair firstEscape.range[1] = secondEscape.range[1]; firstEscape.codePoint = (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000; firstEscape.type = 'value'; firstEscape.kind = 'unicodeCodePointEscape'; addRaw(firstEscape); } else { pos = prevPos; } } } return firstEscape; } function parseClassEscape() { return parseAtomEscape(true); } function parseAtomEscape(insideCharacterClass) { // AtomEscape :: // DecimalEscape // CharacterEscape // CharacterClassEscape // k GroupName var res, from = pos; res = parseDecimalEscape() || parseNamedReference(); if (res) { return res; } // For ClassEscape if (insideCharacterClass) { if (match('b')) { // 15.10.2.19 // The production ClassEscape :: b evaluates by returning the // CharSet containing the one character (Unicode value 0008). return createEscaped('singleEscape', 0x0008, '\\b'); } else if (match('B')) { bail('\\B not possible inside of CharacterClass', '', from); } } res = parseCharacterEscape(); return res; } function parseDecimalEscape() { // DecimalEscape :: // DecimalIntegerLiteral [lookahead ∉ DecimalDigit] // CharacterClassEscape :: one of d D s S w W var res, match; if (res = matchReg(/^(?!0)\d+/)) { match = res[0]; var refIdx = parseInt(res[0], 10); if (refIdx <= closedCaptureCounter) { // If the number is smaller than the normal-groups found so // far, then it is a reference... return createReference(res[0]); } else { // ... otherwise it needs to be interpreted as a octal (if the // number is in an octal format). If it is NOT octal format, // then the slash is ignored and the number is matched later // as normal characters. // Recall the negative decision to decide if the input must be parsed // a second time with the total normal-groups. backrefDenied.push(refIdx); // Reset the position again, as maybe only parts of the previous // matched numbers are actual octal numbers. E.g. in '019' only // the '01' should be matched. incr(-res[0].length); if (res = matchReg(/^[0-7]{1,3}/)) { return createEscaped('octal', parseInt(res[0], 8), res[0], 1); } else { // If we end up here, we have a case like /\91/. Then the // first slash is to be ignored and the 9 & 1 to be treated // like ordinary characters. Create a character for the // first number only here - other number-characters // (if available) will be matched later. res = createCharacter(matchReg(/^[89]/)); return updateRawStart(res, res.range[0] - 1); } } } // Only allow octal numbers in the following. All matched numbers start // with a zero (if the do not, the previous if-branch is executed). // If the number is not octal format and starts with zero (e.g. `091`) // then only the zeros `0` is treated here and the `91` are ordinary // characters. // Example: // /\091/.exec('\091')[0].length === 3 else if (res = matchReg(/^[0-7]{1,3}/)) { match = res[0]; if (/^0{1,3}$/.test(match)) { // If they are all zeros, then only take the first one. return createEscaped('null', 0x0000, '0', match.length + 1); } else { return createEscaped('octal', parseInt(match, 8), match, 1); } } else if (res = matchReg(/^[dDsSwW]/)) { return createCharacterClassEscape(res[0]); } return false; } function parseNamedReference() { if (features.namedGroups && matchReg(/^k<(?=.*?>)/)) { var name = parseIdentifier(); skip('>'); return createNamedReference(name); } } function parseRegExpUnicodeEscapeSequence() { var res; if (res = matchReg(/^u([0-9a-fA-F]{4})/)) { // UnicodeEscapeSequence return parseUnicodeSurrogatePairEscape( createEscaped('unicodeEscape', parseInt(res[1], 16), res[1], 2) ); } else if (hasUnicodeFlag && (res = matchReg(/^u\{([0-9a-fA-F]+)\}/))) { // RegExpUnicodeEscapeSequence (ES6 Unicode code point escape) return createEscaped('unicodeCodePointEscape', parseInt(res[1], 16), res[1], 4); } } function parseCharacterEscape() { // CharacterEscape :: // ControlEscape // c ControlLetter // HexEscapeSequence // UnicodeEscapeSequence // IdentityEscape var res; if (res = matchReg(/^[fnrtv]/)) { // ControlEscape var codePoint = 0; switch (res[0]) { case 't': codePoint = 0x009; break; case 'n': codePoint = 0x00A; break; case 'v': codePoint = 0x00B; break; case 'f': codePoint = 0x00C; break; case 'r': codePoint = 0x00D; break; } return createEscaped('singleEscape', codePoint, '\\' + res[0]); } else if (res = matchReg(/^c([a-zA-Z])/)) { // c ControlLetter return createEscaped('controlLetter', res[1].charCodeAt(0) % 32, res[1], 2); } else if (res = matchReg(/^x([0-9a-fA-F]{2})/)) { // HexEscapeSequence return createEscaped('hexadecimalEscape', parseInt(res[1], 16), res[1], 2); } else if (res = parseRegExpUnicodeEscapeSequence()) { return res; } else if (features.unicodePropertyEscape && hasUnicodeFlag && (res = matchReg(/^([pP])\{([^\}]+)\}/))) { // https://github.com/jviereck/regjsparser/issues/77 return addRaw({ type: 'unicodePropertyEscape', negative: res[1] === 'P', value: res[2], range: [res.range[0] - 1, res.range[1]], raw: res[0] }); } else { // IdentityEscape return parseIdentityEscape(); } } function parseIdentifierAtom(check) { var ch = lookahead(); var from = pos; if (!check(ch.charCodeAt(0))) return; incr(); if (ch === '\\') { var esc = parseRegExpUnicodeEscapeSequence(); if (!esc || !check(esc.codePoint)) { bail('Invalid escape sequence', null, from, pos); } return fromCodePoint(esc.codePoint); } return ch; } function parseIdentifier() { // RegExpIdentifierName :: // RegExpIdentifierStart // RegExpIdentifierName RegExpIdentifierContinue // // RegExpIdentifierStart :: // UnicodeIDStart // $ // _ // \ RegExpUnicodeEscapeSequence // // RegExpIdentifierContinue :: // UnicodeIDContinue // $ // _ // \ RegExpUnicodeEscapeSequence // // var start = pos; var res = parseIdentifierAtom(isIdentifierStart); if (!res) { bail('Invalid identifier'); } var ch; while (ch = parseIdentifierAtom(isIdentifierPart)) { res += ch; } return addRaw({ type: 'identifier', value: res, range: [start, pos] }); } function isIdentifierStart(ch) { // Generated by `tools/generate-identifier-regex.js`. var NonAsciiIdentifierStart = /[\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0561-\u0587\u05D0-\u05EA\u05F0-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u08A0-\u08B2\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58\u0C59\u0C60\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D60\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E87\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA\u0EAB\u0EAD-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F4\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16EE-\u16F8\u1700-\u170C\u170E-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1877\u1880-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19C1-\u19C7\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4B\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1CE9-\u1CEC\u1CEE-\u1CF1\u1CF5\u1CF6\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2160-\u2188\u2C00-\u2C2E\u2C30-\u2C5E\u2C60-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312D\u3131-\u318E\u31A0-\u31BA\u31F0-\u31FF\u3400-\u4DB5\u4E00-\u9FCC\uA000-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6EF\uA717-\uA71F\uA722-\uA788\uA78B-\uA78E\uA790-\uA7AD\uA7B0\uA7B1\uA7F7-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB5F\uAB64\uAB65\uABC0-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]/; return (ch === 36) || (ch === 95) || // $ (dollar) and _ (underscore) (ch >= 65 && ch <= 90) || // A..Z (ch >= 97 && ch <= 122) || // a..z (ch >= 48 && ch <= 57) || // 0..9 (ch === 92) || // \ (backslash) ((ch >= 0x80) && NonAsciiIdentifierStart.test(String.fromCharCode(ch))); } // Taken from the Esprima parser. function isIdentifierPart(ch) { // Generated by `tools/generate-identifier-regex.js`. var NonAsciiIdentifierPartOnly = /[\u0300-\u036F\u0483-\u0487\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u0669\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u06F0-\u06F9\u0711\u0730-\u074A\u07A6-\u07B0\u07C0-\u07C9\u07EB-\u07F3\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u08E4-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0966-\u096F\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09E6-\u09EF\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A66-\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AE6-\u0AEF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B56\u0B57\u0B62\u0B63\u0B66-\u0B6F\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0BE6-\u0BEF\u0C00-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C66-\u0C6F\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0CE6-\u0CEF\u0D01-\u0D03\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D66-\u0D6F\u0D82\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DE6-\u0DEF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0E50-\u0E59\u0EB1\u0EB4-\u0EB9\u0EBB\u0EBC\u0EC8-\u0ECD\u0ED0-\u0ED9\u0F18\u0F19\u0F20-\u0F29\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1040-\u1049\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F-\u109D\u135D-\u135F\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u17E0-\u17E9\u180B-\u180D\u1810-\u1819\u18A9\u1920-\u192B\u1930-\u193B\u1946-\u194F\u19B0-\u19C0\u19C8\u19C9\u19D0-\u19D9\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F-\u1A89\u1A90-\u1A99\u1AB0-\u1ABD\u1B00-\u1B04\u1B34-\u1B44\u1B50-\u1B59\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BB0-\u1BB9\u1BE6-\u1BF3\u1C24-\u1C37\u1C40-\u1C49\u1C50-\u1C59\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF2-\u1CF4\u1CF8\u1CF9\u1DC0-\u1DF5\u1DFC-\u1DFF\u200C\u200D\u203F\u2040\u2054\u20D0-\u20DC\u20E1\u20E5-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA620-\uA629\uA66F\uA674-\uA67D\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA880\uA881\uA8B4-\uA8C4\uA8D0-\uA8D9\uA8E0-\uA8F1\uA900-\uA909\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9D0-\uA9D9\uA9E5\uA9F0-\uA9F9\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA50-\uAA59\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uABF0-\uABF9\uFB1E\uFE00-\uFE0F\uFE20-\uFE2D\uFE33\uFE34\uFE4D-\uFE4F\uFF10-\uFF19\uFF3F]/; return isIdentifierStart(ch) || ((ch >= 0x80) && NonAsciiIdentifierPartOnly.test(String.fromCharCode(ch))); } function parseIdentityEscape() { // IdentityEscape :: // SourceCharacter but not IdentifierPart // // var ZWJ = '\u200C'; var ZWNJ = '\u200D'; var tmp; if (!isIdentifierPart(lookahead())) { tmp = incr(); return createEscaped('identifier', tmp.charCodeAt(0), tmp, 1); } if (match(ZWJ)) { // return createEscaped('identifier', 0x200C, ZWJ); } else if (match(ZWNJ)) { // return createEscaped('identifier', 0x200D, ZWNJ); } return null; } function parseCharacterClass() { // CharacterClass :: // [ [lookahead ∉ {^}] ClassRanges ] // [ ^ ClassRanges ] var res, from = pos; if (res = matchReg(/^\[\^/)) { res = parseClassRanges(); skip(']'); return createCharacterClass(res, true, from, pos); } else if (match('[')) { res = parseClassRanges(); skip(']'); return createCharacterClass(res, false, from, pos); } return null; } function parseClassRanges() { // ClassRanges :: // [empty] // NonemptyClassRanges var res; if (current(']')) { // Empty array means nothing insinde of the ClassRange. return []; } else { res = parseNonemptyClassRanges(); if (!res) { bail('nonEmptyClassRanges'); } return res; } } function parseHelperClassRanges(atom) { var from, to, res; if (current('-') && !next(']')) { // ClassAtom - ClassAtom ClassRanges skip('-'); res = parseClassAtom(); if (!res) { bail('classAtom'); } to = pos; var classRanges = parseClassRanges(); if (!classRanges) { bail('classRanges'); } from = atom.range[0]; if (classRanges.type === 'empty') { return [createClassRange(atom, res, from, to)]; } return [createClassRange(atom, res, from, to)].concat(classRanges); } res = parseNonemptyClassRangesNoDash(); if (!res) { bail('nonEmptyClassRangesNoDash'); } return [atom].concat(res); } function parseNonemptyClassRanges() { // NonemptyClassRanges :: // ClassAtom // ClassAtom NonemptyClassRangesNoDash // ClassAtom - ClassAtom ClassRanges var atom = parseClassAtom(); if (!atom) { bail('classAtom'); } if (current(']')) { // ClassAtom return [atom]; } // ClassAtom NonemptyClassRangesNoDash // ClassAtom - ClassAtom ClassRanges return parseHelperClassRanges(atom); } function parseNonemptyClassRangesNoDash() { // NonemptyClassRangesNoDash :: // ClassAtom // ClassAtomNoDash NonemptyClassRangesNoDash // ClassAtomNoDash - ClassAtom ClassRanges var res = parseClassAtom(); if (!res) { bail('classAtom'); } if (current(']')) { // ClassAtom return res; } // ClassAtomNoDash NonemptyClassRangesNoDash // ClassAtomNoDash - ClassAtom ClassRanges return parseHelperClassRanges(res); } function parseClassAtom() { // ClassAtom :: // - // ClassAtomNoDash if (match('-')) { return createCharacter('-'); } else { return parseClassAtomNoDash(); } } function parseClassAtomNoDash() { // ClassAtomNoDash :: // SourceCharacter but not one of \ or ] or - // \ ClassEscape var res; if (res = matchReg(/^[^\\\]-]/)) { return createCharacter(res[0]); } else if (match('\\')) { res = parseClassEscape(); if (!res) { bail('classEscape'); } return parseUnicodeSurrogatePairEscape(res); } } function bail(message, details, from, to) { from = from == null ? pos : from; to = to == null ? from : to; var contextStart = Math.max(0, from - 10); var contextEnd = Math.min(to + 10, str.length); // Output a bit of context and a line pointing to where our error is. // // We are assuming that there are no actual newlines in the content as this is a regular expression. var context = ' ' + str.substring(contextStart, contextEnd); var pointer = ' ' + new Array(from - contextStart + 1).join(' ') + '^'; throw SyntaxError(message + ' at position ' + from + (details ? ': ' + details : '') + '\n' + context + '\n' + pointer); } var backrefDenied = []; var closedCaptureCounter = 0; var firstIteration = true; var hasUnicodeFlag = (flags || "").indexOf("u") !== -1; var pos = 0; // Convert the input to a string and treat the empty string special. str = String(str); if (str === '') { str = '(?:)'; } var result = parseDisjunction(); if (result.range[1] !== str.length) { bail('Could not parse entire input - got stuck', '', result.range[1]); } // The spec requires to interpret the `\2` in `/\2()()/` as backreference. // As the parser collects the number of capture groups as the string is // parsed it is impossible to make these decisions at the point when the // `\2` is handled. In case the local decision turns out to be wrong after // the parsing has finished, the input string is parsed a second time with // the total number of capture groups set. // // SEE: https://github.com/jviereck/regjsparser/issues/70 for (var i = 0; i < backrefDenied.length; i++) { if (backrefDenied[i] <= closedCaptureCounter) { // Parse the input a second time. pos = 0; firstIteration = false; return parseDisjunction(); } } return result; } var regjsparser = { parse: parse }; if (typeof module !== 'undefined' && module.exports) { module.exports = regjsparser; } else { window.regjsparser = regjsparser; } }()); regjsparser-0.3.0/tools/000077500000000000000000000000001322400266200151765ustar00rootroot00000000000000regjsparser-0.3.0/tools/generate-identifier-regex.js000066400000000000000000000032731322400266200225630ustar00rootroot00000000000000// Based on https://gist.github.com/mathiasbynens/6334847 by @mathias var regenerate = require('regenerate'); // Which Unicode version should be used? var version = '7.0.0'; // note: also update `package.json` when this changes // Shorthand function var get = function(what) { return require('unicode-' + version + '/' + what + '/code-points'); }; // Unicode categories needed to construct the ES5 regex var Lu = get('categories/Lu'); var Ll = get('categories/Ll'); var Lt = get('categories/Lt'); var Lm = get('categories/Lm'); var Lo = get('categories/Lo'); var Nl = get('categories/Nl'); var Mn = get('categories/Mn'); var Mc = get('categories/Mc'); var Nd = get('categories/Nd'); var Pc = get('categories/Pc'); var generateES5Regex = function() { // ES 5.1 // http://mathiasbynens.be/notes/javascript-identifiers#valid-identifier-names var identifierStart = regenerate('$', '_') .add(Lu, Ll, Lt, Lm, Lo, Nl) .removeRange(0x010000, 0x10FFFF) // remove astral symbols .removeRange(0x0, 0x7F); // remove ASCII symbols (regjsparser-specific) var identifierPartOnly = regenerate('\u200C', '\u200D') .add(Mn, Mc, Nd, Pc) .removeRange(0x010000, 0x10FFFF) // remove astral symbols .removeRange(0x0, 0x7F); // remove ASCII symbols (regjsparser-specific) return { 'NonAsciiIdentifierStart': identifierStart.toString(), 'NonAsciiIdentifierPartOnly': identifierPartOnly.toString() }; }; var result = generateES5Regex(); console.log( '// ECMAScript 5.1/Unicode v%s NonAsciiIdentifierStart:\n\n%s\n', version, result.NonAsciiIdentifierStart ); console.log( '// ECMAScript 5.1/Unicode v%s NonAsciiIdentifierPartOnly:\n\n%s', version, result.NonAsciiIdentifierPartOnly );