drkthunder02/w4rpservices
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

nav tabs on admin dashboard

Browse Source
This commit is contained in:
drkthunder02
2019-03-07 00:20:34 -06:00
parent f73d6ae228
commit e4f473f376
11661 changed files with 216240 additions and 1544253 deletions
Download Patch File Download Diff File Expand all files Collapse all files
node_modules/regjsgen/LICENSE.txt
Generated Vendored
-20
View File
@@ -1,20 +0,0 @@
Copyright 2014 Benjamin Tan <demoneaux@gmail.com> (https://d10.github.io/)
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
node_modules/regjsgen/README.md
Generated Vendored
+15 -42
View File
@@ -1,6 +1,6 @@
# RegJSGen
# regjsgen [![Build status](https://travis-ci.org/bnjmnt4n/regjsgen.svg?branch=master)](https://travis-ci.org/bnjmnt4n/regjsgen) [![Code coverage status](https://codecov.io/gh/bnjmnt4n/regjsgen/branch/master/graph/badge.svg)](https://codecov.io/gh/bnjmnt4n/regjsgen)
Generate `RegExp`s from [RegJSParser](https://github.com/jviereck/regjsparser)’s AST.
Generate regular expressions from [regjsparser](https://github.com/jviereck/regjsparser)’s AST.
## Installation
@@ -8,53 +8,26 @@ Generate `RegExp`s from [RegJSParser](https://github.com/jviereck/regjsparser)
npm install --save regjsgen
```
## Usage
## API
### `regjsgen.generate(ast)`
This function accepts an abstract syntax tree representing a regular expression, and returns the generated regular expression string.
```js
var regjsgen = require('regjsgen');
// With `regjsparser`
var regjsparser = require('regjsparser');
var regex = '^a$';
var regjsgen = require('regjsgen');
// Generate an AST with `regjsparser`.
var ast = regjsparser.parse(regex);
// Modify AST
// ...
// Regenerate `RegExp`
// …
// Generate `RegExp` string with `regjsgen`.
regex = regjsgen.generate(ast);
```
## See Also
* [RegJSParser](https://github.com/jviereck/regjsparser)
* [RegExp.js](https://github.com/jviereck/regexp.js)
## Testing
Run the command
```bash
npm test
```
To create a new reference file, execute
```bash
node test/update-fixture.js
```
from the repo top directory.
## Support
Tested in Node.js 0.8.26~0.10.30.
## Author
| [![twitter/demoneaux](http://gravatar.com/avatar/029b19dba521584d83398ada3ecf6131?s=70)](https://twitter.com/demoneaux "Follow @demoneaux on Twitter") |
|---|
| [Benjamin Tan](http://d10.github.io/) |
## Contributors
| [![twitter/mathias](http://gravatar.com/avatar/24e08a9ea84deb17ae121074d0f17125?s=70)](https://twitter.com/mathias "Follow @mathias on Twitter") |
|---|
| [Mathias Bynens](http://mathiasbynens.be/) |
Tested in Node.js 0.10, 0.12, 4, 6 and 8.
node_modules/regjsgen/package.json
Generated Vendored
+24 -35
View File
@@ -1,61 +1,48 @@
{
"_from": "regjsgen@^0.2.0",
"_id": "regjsgen@0.2.0",
"_from": "regjsgen@^0.5.0",
"_id": "regjsgen@0.5.0",
"_inBundle": false,
"_integrity": "sha1-bAFq3qxVT3WCP+N6wFuS1aTtsfc=",
"_integrity": "sha512-RnIrLhrXCX5ow/E5/Mh2O4e/oa1/jW0eaBKTSy3LaCj+M3Bqvm97GWDp2yUtzIs4LEn65zR2yiYGFqb2ApnzDA==",
"_location": "/regjsgen",
"_phantomChildren": {},
"_requested": {
"type": "range",
"registry": true,
"raw": "regjsgen@^0.2.0",
"raw": "regjsgen@^0.5.0",
"name": "regjsgen",
"escapedName": "regjsgen",
"rawSpec": "^0.2.0",
"rawSpec": "^0.5.0",
"saveSpec": null,
"fetchSpec": "^0.2.0"
"fetchSpec": "^0.5.0"
},
"_requiredBy": [
"/css-selector-tokenizer/regexpu-core",
"/regexpu-core"
],
"_resolved": "http://registry.npmjs.org/regjsgen/-/regjsgen-0.2.0.tgz",
"_shasum": "6c016adeac554f75823fe37ac05b92d5a4edb1f7",
"_spec": "regjsgen@^0.2.0",
"_resolved": "https://registry.npmjs.org/regjsgen/-/regjsgen-0.5.0.tgz",
"_shasum": "a7634dc08f89209c2049adda3525711fb97265dd",
"_spec": "regjsgen@^0.5.0",
"_where": "C:\\xampp\\htdocs\\w4rpservices\\node_modules\\regexpu-core",
"author": {
"name": "Benjamin Tan",
"email": "demoneaux@gmail.com",
"url": "https://d10.github.io/"
"url": "https://bnjmnt4n.now.sh/"
},
"bugs": {
"url": "https://github.com/d10/regjsgen/issues"
"url": "https://github.com/bnjmnt4n/regjsgen/issues"
},
"bundleDependencies": false,
"contributors": [
{
"name": "Benjamin Tan",
"email": "demoneaux@gmail.com",
"url": "https://d10.github.io/"
},
{
"name": "Mathias Bynens",
"email": "mathias@qiwi.be",
"url": "https://mathiasbynens.be/"
}
],
"deprecated": false,
"description": "Generate `RegExp`s from RegJSParser’s AST",
"description": "Generate regular expressions from regjsparser’s AST.",
"devDependencies": {
"got": "~1.2.0",
"jsesc": "~0.5.0"
"codecov": "^3.1.0",
"istanbul": "~0.4.5",
"regjsparser": "~0.4.0",
"request": "^2.88.0"
},
"files": [
"LICENSE.txt",
"regjsgen.js",
"README.md"
"LICENSE",
"regjsgen.js"
],
"homepage": "https://github.com/d10/regjsgen",
"homepage": "https://github.com/bnjmnt4n/regjsgen",
"keywords": [
"ast",
"generate",
@@ -68,10 +55,12 @@
"name": "regjsgen",
"repository": {
"type": "git",
"url": "git+https://github.com/d10/regjsgen.git"
"url": "git+https://github.com/bnjmnt4n/regjsgen.git"
},
"scripts": {
"test": "node test/test.js"
"coverage": "istanbul cover --report html tests/tests.js",
"test": "node tests/tests.js",
"update-fixtures": "node tests/update-fixtures.js"
},
"version": "0.2.0"
"version": "0.5.0"
}
node_modules/regjsgen/regjsgen.js
Generated Vendored
+157 -164
View File
@@ -1,108 +1,96 @@
/*!
* RegJSGen
* Copyright 2014 Benjamin Tan <https://d10.github.io/>
* Available under MIT license <http://d10.mit-license.org/>
* regjsgen 0.5.0
* Copyright 2014-2018 Benjamin Tan <https://bnjmnt4n.now.sh/>
* Available under MIT license <https://github.com/bnjmnt4n/regjsgen/blob/master/LICENSE>
*/
;(function() {
'use strict';
/** Used to determine if values are of the language type `Object` */
// Used to determine if values are of the language type `Object`.
var objectTypes = {
'function': true,
'object': true
};
/** Used as a reference to the global object */
// Used as a reference to the global object.
var root = (objectTypes[typeof window] && window) || this;
/** Backup possible global object */
var oldRoot = root;
// Detect free variable `exports`.
var freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports;
/** Detect free variable `exports` */
var freeExports = objectTypes[typeof exports] && exports;
// Detect free variable `module`.
var hasFreeModule = objectTypes[typeof module] && module && !module.nodeType;
/** Detect free variable `module` */
var freeModule = objectTypes[typeof module] && module && !module.nodeType && module;
/** Detect free variable `global` from Node.js or Browserified code and use it as `root` */
var freeGlobal = freeExports && freeModule && typeof global == 'object' && global;
// Detect free variable `global` from Node.js or Browserified code and use it as `root`.
var freeGlobal = freeExports && hasFreeModule && typeof global == 'object' && global;
if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal || freeGlobal.self === freeGlobal)) {
root = freeGlobal;
}
// Used to check objects for own properties.
var hasOwnProperty = Object.prototype.hasOwnProperty;
/*--------------------------------------------------------------------------*/
/*! Based on https://mths.be/fromcodepoint v0.2.0 by @mathias */
var stringFromCharCode = String.fromCharCode;
var floor = Math.floor;
// Generates a string based on the given code point.
// Based on https://mths.be/fromcodepoint by @mathias.
function fromCodePoint() {
var MAX_SIZE = 0x4000;
var codeUnits = [];
var highSurrogate;
var lowSurrogate;
var index = -1;
var length = arguments.length;
if (!length) {
return '';
var codePoint = Number(arguments[0]);
if (
!isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
codePoint < 0 || // not a valid Unicode code point
codePoint > 0x10FFFF || // not a valid Unicode code point
Math.floor(codePoint) != codePoint // not an integer
) {
throw RangeError('Invalid code point: ' + codePoint);
}
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;
}
if (codePoint <= 0xFFFF) {
// BMP code point
return String.fromCharCode(codePoint);
} else {
// Astral code point; split in surrogate halves
// http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
codePoint -= 0x10000;
var highSurrogate = (codePoint >> 10) + 0xD800;
var lowSurrogate = (codePoint % 0x400) + 0xDC00;
return String.fromCharCode(highSurrogate, lowSurrogate);
}
return result;
}
/*--------------------------------------------------------------------------*/
// Ensures that nodes have the correct types.
var assertTypeRegexMap = {};
function assertType(type, expected) {
if (expected.indexOf('|') == -1) {
if (type == expected) {
return;
}
throw Error('Invalid node type: ' + type);
throw Error('Invalid node type: ' + type + '; expected type: ' + expected);
}
expected = assertType.hasOwnProperty(expected)
? assertType[expected]
: (assertType[expected] = RegExp('^(?:' + expected + ')$'));
expected = hasOwnProperty.call(assertTypeRegexMap, expected)
? assertTypeRegexMap[expected]
: (assertTypeRegexMap[expected] = RegExp('^(?:' + expected + ')$'));
if (expected.test(type)) {
return;
}
throw Error('Invalid node type: ' + type);
throw Error('Invalid node type: ' + type + '; expected types: ' + expected);
}
/*--------------------------------------------------------------------------*/
// Generates a regular expression string based on an AST.
function generate(node) {
var type = node.type;
if (generate.hasOwnProperty(type) && typeof generate[type] == 'function') {
return generate[type](node);
if (hasOwnProperty.call(generators, type)) {
return generators[type](node);
}
throw Error('Invalid node type: ' + type);
@@ -114,20 +102,15 @@
assertType(node.type, 'alternative');
var terms = node.body,
length = terms ? terms.length : 0;
i = -1,
length = terms.length,
result = '';
if (length == 1) {
return generateTerm(terms[0]);
} else {
var i = -1,
result = '';
while (++i < length) {
result += generateTerm(terms[i]);
}
return result;
while (++i < length) {
result += generateTerm(terms[i]);
}
return result;
}
function generateAnchor(node) {
@@ -157,10 +140,9 @@
assertType(node.type, 'characterClass');
var classRanges = node.body,
length = classRanges ? classRanges.length : 0;
var i = -1,
result = '[';
i = -1,
length = classRanges.length,
result = '';
if (node.negative) {
result += '^';
@@ -170,9 +152,7 @@
result += generateClassAtom(classRanges[i]);
}
result += ']';
return result;
return '[' + result + ']';
}
function generateCharacterClassEscape(node) {
@@ -181,6 +161,12 @@
return '\\' + node.value;
}
function generateUnicodePropertyEscape(node) {
assertType(node.type, 'unicodePropertyEscape');
return '\\' + (node.negative ? 'P' : 'p') + '{' + node.value + '}';
}
function generateCharacterClassRange(node) {
assertType(node.type, 'characterClassRange');
@@ -204,25 +190,18 @@
assertType(node.type, 'disjunction');
var body = node.body,
length = body ? body.length : 0;
i = -1,
length = body.length,
result = '';
if (length == 0) {
throw Error('No body');
} else if (length == 1) {
return generate(body[0]);
} else {
var i = -1,
result = '';
while (++i < length) {
if (i != 0) {
result += '|';
}
result += generate(body[i]);
while (++i < length) {
if (i != 0) {
result += '|';
}
return result;
result += generate(body[i]);
}
return result;
}
function generateDot(node) {
@@ -234,10 +213,13 @@
function generateGroup(node) {
assertType(node.type, 'group');
var result = '(';
var result = '';
switch (node.behavior) {
case 'normal':
if (node.name) {
result += '?<' + generateIdentifier(node.name) + '>';
}
break;
case 'ignore':
result += '?:';
@@ -248,26 +230,31 @@
case 'negativeLookahead':
result += '?!';
break;
case 'lookbehind':
result += '?<=';
break;
case 'negativeLookbehind':
result += '?<!';
break;
default:
throw Error('Invalid behaviour: ' + node.behaviour);
}
var body = node.body,
length = body ? body.length : 0;
i = -1,
length = body.length;
if (length == 1) {
result += generate(body[0]);
} else {
var i = -1;
while (++i < length) {
result += generate(body[i]);
}
while (++i < length) {
result += generate(body[i]);
}
result += ')';
return '(' + result + ')';
}
return result;
function generateIdentifier(node) {
assertType(node.type, 'identifier');
return node.value;
}
function generateQuantifier(node) {
@@ -277,31 +264,20 @@
min = node.min,
max = node.max;
switch (max) {
case undefined:
case null:
switch (min) {
case 0:
quantifier = '*'
break;
case 1:
quantifier = '+';
break;
default:
quantifier = '{' + min + ',}';
break;
}
break;
default:
if (min == max) {
quantifier = '{' + min + '}';
}
else if (min == 0 && max == 1) {
quantifier = '?';
} else {
quantifier = '{' + min + ',' + max + '}';
}
break;
if (max == null) {
if (min == 0) {
quantifier = '*';
} else if (min == 1) {
quantifier = '+';
} else {
quantifier = '{' + min + ',}';
}
} else if (min == max) {
quantifier = '{' + min + '}';
} else if (min == 0 && max == 1) {
quantifier = '?';
} else {
quantifier = '{' + min + ',' + max + '}';
}
if (!node.greedy) {
@@ -314,11 +290,18 @@
function generateReference(node) {
assertType(node.type, 'reference');
return '\\' + node.matchIndex;
if (node.matchIndex) {
return '\\' + node.matchIndex;
}
if (node.name) {
return '\\k<' + generateIdentifier(node.name) + '>';
}
throw new Error('Unknown reference type');
}
function generateTerm(node) {
assertType(node.type, 'anchor|characterClass|characterClassEscape|empty|group|quantifier|reference|value');
assertType(node.type, 'anchor|characterClass|characterClassEscape|empty|group|quantifier|reference|unicodePropertyEscape|value');
return generate(node);
}
@@ -329,6 +312,10 @@
var kind = node.kind,
codePoint = node.codePoint;
if (typeof codePoint != 'number') {
throw new Error('Invalid code point: ' + codePoint);
}
switch (kind) {
case 'controlLetter':
return '\\c' + fromCodePoint(codePoint + 64);
@@ -344,18 +331,18 @@
switch (codePoint) {
case 0x0008:
return '\\b';
case 0x009:
case 0x0009:
return '\\t';
case 0x00A:
case 0x000A:
return '\\n';
case 0x00B:
case 0x000B:
return '\\v';
case 0x00C:
case 0x000C:
return '\\f';
case 0x00D:
case 0x000D:
return '\\r';
default:
throw Error('Invalid codepoint: ' + codePoint);
throw Error('Invalid code point: ' + codePoint);
}
case 'symbol':
return fromCodePoint(codePoint);
@@ -370,39 +357,45 @@
/*--------------------------------------------------------------------------*/
generate.alternative = generateAlternative;
generate.anchor = generateAnchor;
generate.characterClass = generateCharacterClass;
generate.characterClassEscape = generateCharacterClassEscape;
generate.characterClassRange = generateCharacterClassRange;
generate.disjunction = generateDisjunction;
generate.dot = generateDot;
generate.group = generateGroup;
generate.quantifier = generateQuantifier;
generate.reference = generateReference;
generate.value = generateValue;
// Used to generate strings for each node type.
var generators = {
'alternative': generateAlternative,
'anchor': generateAnchor,
'characterClass': generateCharacterClass,
'characterClassEscape': generateCharacterClassEscape,
'characterClassRange': generateCharacterClassRange,
'unicodePropertyEscape': generateUnicodePropertyEscape,
'disjunction': generateDisjunction,
'dot': generateDot,
'group': generateGroup,
'quantifier': generateQuantifier,
'reference': generateReference,
'value': generateValue
};
/*--------------------------------------------------------------------------*/
// export regjsgen
// some AMD build optimizers, like r.js, check for condition patterns like the following:
// Export regjsgen.
var regjsgen = {
'generate': generate
};
// Some AMD build optimizers, like r.js, check for condition patterns like the following:
if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) {
// define as an anonymous module so, through path mapping, it can be aliased
// Define as an anonymous module so it can be aliased through path mapping.
define(function() {
return {
'generate': generate
};
return regjsgen;
});
root.regjsgen = regjsgen;
}
// check for `exports` after `define` in case a build optimizer adds an `exports` object
else if (freeExports && freeModule) {
// in Narwhal, Node.js, Rhino -require, or RingoJS
// Check for `exports` after `define` in case a build optimizer adds an `exports` object.
else if (freeExports && hasFreeModule) {
// Export for CommonJS support.
freeExports.generate = generate;
}
// in a browser or Rhino
else {
root.regjsgen = {
'generate': generate
};
// Export to the global object.
root.regjsgen = regjsgen;
}
}.call(this));