regex-to-strings
Advanced tools
Comparing version 2.0.2 to 2.0.3
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
var __read = (this && this.__read) || function (o, n) { | ||
var m = typeof Symbol === "function" && o[Symbol.iterator]; | ||
if (!m) return o; | ||
var i = m.call(o), r, ar = [], e; | ||
try { | ||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); | ||
} | ||
catch (error) { e = { error: error }; } | ||
finally { | ||
try { | ||
if (r && !r.done && (m = i["return"])) m.call(i); | ||
} | ||
finally { if (e) throw e.error; } | ||
} | ||
return ar; | ||
}; | ||
var __spreadArray = (this && this.__spreadArray) || function (to, from) { | ||
for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) | ||
to[j] = from[i]; | ||
return to; | ||
}; | ||
exports.__esModule = true; | ||
exports.Chars = void 0; | ||
const nbsp = String.fromCharCode(160); | ||
const whitespace = ` \t\r\n${nbsp}`.split(''); | ||
const digits = '0123456789'.split(''); | ||
const underscore = '_'; | ||
const basicLowercase = 'abcdefghijklmnopqrstuvwxyz'.split(''); | ||
const basicUppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split(''); | ||
const basicAlpha = [...basicLowercase, ...basicUppercase, underscore]; | ||
const basicSpecial = '~`!@#$%^&*()-=+<,>.?/[]{}|\\:;"\''.split(''); | ||
const extendedLowercase = 'àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ'.split(''); | ||
const extendedUppercase = 'ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞß'.split(''); | ||
const shy = String.fromCharCode(173); | ||
const extendedSpecial = `¡¢£¤¥¦§¨©ª«¬®¯°±²³´µ¶·¸¹º»¼½¾¿×÷${shy}`.split(''); // Special Windows-1252 display characters in the extended ASCII range | ||
var nbsp = String.fromCharCode(160); | ||
var whitespace = (" \t\r\n" + nbsp).split(''); | ||
var digits = '0123456789'.split(''); | ||
var underscore = '_'; | ||
var basicLowercase = 'abcdefghijklmnopqrstuvwxyz'.split(''); | ||
var basicUppercase = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split(''); | ||
var basicAlpha = __spreadArray(__spreadArray(__spreadArray([], __read(basicLowercase)), __read(basicUppercase)), [underscore]); | ||
var basicSpecial = '~`!@#$%^&*()-=+<,>.?/[]{}|\\:;"\''.split(''); | ||
var extendedLowercase = 'àáâãäåæçèéêëìíîïðñòóôõöøùúûüýþÿ'.split(''); | ||
var extendedUppercase = 'ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖØÙÚÛÜÝÞß'.split(''); | ||
var shy = String.fromCharCode(173); | ||
var extendedSpecial = ("\u00A1\u00A2\u00A3\u00A4\u00A5\u00A6\u00A7\u00A8\u00A9\u00AA\u00AB\u00AC\u00AE\u00AF\u00B0\u00B1\u00B2\u00B3\u00B4\u00B5\u00B6\u00B7\u00B8\u00B9\u00BA\u00BB\u00BC\u00BD\u00BE\u00BF\u00D7\u00F7" + shy).split(''); | ||
// Special Windows-1252 display characters in the extended ASCII range | ||
// https://www.ascii-code.com/#extendedASCIIDescription | ||
const windows1252Special = '€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ'.split(''); | ||
const extended = [...extendedLowercase, ...extendedUppercase, ...extendedSpecial, ...windows1252Special]; | ||
const all = [...whitespace, ...digits, ...basicAlpha, ...basicSpecial, ...extended]; | ||
const Chars = { | ||
all, | ||
basicAlpha, | ||
basicSpecial, | ||
digits, | ||
extended, | ||
whitespace | ||
var windows1252Special = '€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ'.split(''); | ||
var extended = __spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(extendedLowercase)), __read(extendedUppercase)), __read(extendedSpecial)), __read(windows1252Special)); | ||
var all = __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(whitespace)), __read(digits)), __read(basicAlpha)), __read(basicSpecial)), __read(extended)); | ||
exports.Chars = { | ||
all: all, | ||
basicAlpha: basicAlpha, | ||
basicSpecial: basicSpecial, | ||
digits: digits, | ||
extended: extended, | ||
whitespace: whitespace | ||
}; | ||
exports.Chars = Chars; | ||
//# sourceMappingURL=index.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); | ||
}) : (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
o[k2] = m[k]; | ||
})); | ||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { | ||
Object.defineProperty(o, "default", { enumerable: true, value: v }); | ||
}) : function(o, v) { | ||
o["default"] = v; | ||
}); | ||
exports.default = void 0; | ||
var _Expansion = _interopRequireDefault(require("./Expansion")); | ||
var _alternativePattern = require("./expanders/alternative-pattern"); | ||
var _charPattern = require("./expanders/char-pattern"); | ||
var _characterClassPattern = require("./expanders/character-class-pattern"); | ||
var _disjunctionPattern = require("./expanders/disjunction-pattern"); | ||
var _groupPattern = require("./expanders/group-pattern"); | ||
var _repetitionPattern = require("./expanders/repetition-pattern"); | ||
var Guards = _interopRequireWildcard(require("./types/regexp-tree-guards")); | ||
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; } | ||
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } | ||
var __importStar = (this && this.__importStar) || function (mod) { | ||
if (mod && mod.__esModule) return mod; | ||
var result = {}; | ||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); | ||
__setModuleDefault(result, mod); | ||
return result; | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
exports.__esModule = true; | ||
var Expansion_1 = __importDefault(require("./Expansion")); | ||
var alternative_pattern_1 = require("./expanders/alternative-pattern"); | ||
var char_pattern_1 = require("./expanders/char-pattern"); | ||
var character_class_pattern_1 = require("./expanders/character-class-pattern"); | ||
var disjunction_pattern_1 = require("./expanders/disjunction-pattern"); | ||
var group_pattern_1 = require("./expanders/group-pattern"); | ||
var repetition_pattern_1 = require("./expanders/repetition-pattern"); | ||
var Guards = __importStar(require("./types/regexp-tree-guards")); | ||
/* istanbul ignore next */ | ||
function assertNever(x) { | ||
throw new Error(`Unexpected node type: ${x}`); | ||
throw new Error("Unexpected node type: " + x); | ||
} | ||
class Expander { | ||
/** | ||
* Create a generator for strings that match regular expression | ||
* patterns parsed by regexp-tree. | ||
* @param flags The regular expression modifier flags | ||
*/ | ||
constructor(flags) { | ||
_defineProperty(this, "expandAlternative", _alternativePattern.expandAlternative); | ||
_defineProperty(this, "expandBackreference", _groupPattern.expandBackreference); | ||
_defineProperty(this, "expandChar", _charPattern.expandChar); | ||
_defineProperty(this, "expandCharacterClass", _characterClassPattern.expandCharacterClass); | ||
_defineProperty(this, "expandDisjunction", _disjunctionPattern.expandDisjunction); | ||
_defineProperty(this, "expandGroup", _groupPattern.expandGroup); | ||
_defineProperty(this, "expandRepetition", _repetitionPattern.expandRepetition); | ||
_defineProperty(this, "flags", void 0); | ||
this.flags = flags; | ||
} | ||
/** | ||
* Identify and expand an expression of any type. | ||
* @param expression The expression to expand | ||
* @returns The Expansion of pattern | ||
*/ | ||
expandExpression(expression) { | ||
if (expression === null) { | ||
return _Expansion.default.Blank; | ||
} else if (Guards.isAlternative(expression)) { | ||
return this.expandAlternative(expression); | ||
} else if (Guards.isAssertion(expression)) { | ||
return _Expansion.default.Blank; | ||
} else if (Guards.isBackreference(expression)) { | ||
return this.expandBackreference(expression); | ||
} else if (Guards.isChar(expression)) { | ||
return this.expandChar(expression); | ||
} else if (Guards.isCharacterClass(expression)) { | ||
return this.expandCharacterClass(expression); | ||
} else if (Guards.isDisjunction(expression)) { | ||
return this.expandDisjunction(expression); | ||
} else if (Guards.isGroup(expression)) { | ||
return this.expandGroup(expression); | ||
} else if (Guards.isRepetition(expression)) { | ||
return this.expandRepetition(expression); | ||
var Expander = /** @class */ (function () { | ||
/** | ||
* Create a generator for strings that match regular expression | ||
* patterns parsed by regexp-tree. | ||
* @param flags The regular expression modifier flags | ||
*/ | ||
function Expander(flags) { | ||
this.expandAlternative = alternative_pattern_1.expandAlternative; | ||
this.expandBackreference = group_pattern_1.expandBackreference; | ||
this.expandChar = char_pattern_1.expandChar; | ||
this.expandCharacterClass = character_class_pattern_1.expandCharacterClass; | ||
this.expandDisjunction = disjunction_pattern_1.expandDisjunction; | ||
this.expandGroup = group_pattern_1.expandGroup; | ||
this.expandRepetition = repetition_pattern_1.expandRepetition; | ||
this.flags = flags; | ||
} | ||
/* istanbul ignore next */ | ||
return assertNever(expression); | ||
} | ||
} | ||
var _default = Expander; | ||
exports.default = _default; | ||
/** | ||
* Identify and expand an expression of any type. | ||
* @param expression The expression to expand | ||
* @returns The Expansion of pattern | ||
*/ | ||
Expander.prototype.expandExpression = function (expression) { | ||
if (expression === null) { | ||
return Expansion_1["default"].Blank; | ||
} | ||
else if (Guards.isAlternative(expression)) { | ||
return this.expandAlternative(expression); | ||
} | ||
else if (Guards.isAssertion(expression)) { | ||
return Expansion_1["default"].Blank; | ||
} | ||
else if (Guards.isBackreference(expression)) { | ||
return this.expandBackreference(expression); | ||
} | ||
else if (Guards.isChar(expression)) { | ||
return this.expandChar(expression); | ||
} | ||
else if (Guards.isCharacterClass(expression)) { | ||
return this.expandCharacterClass(expression); | ||
} | ||
else if (Guards.isDisjunction(expression)) { | ||
return this.expandDisjunction(expression); | ||
} | ||
else if (Guards.isGroup(expression)) { | ||
return this.expandGroup(expression); | ||
} | ||
else if (Guards.isRepetition(expression)) { | ||
return this.expandRepetition(expression); | ||
} | ||
/* istanbul ignore next */ | ||
return assertNever(expression); | ||
}; | ||
return Expander; | ||
}()); | ||
exports["default"] = Expander; | ||
//# sourceMappingURL=Expander.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.expandAlternative = expandAlternative; | ||
var _Expansion = _interopRequireDefault(require("../Expansion")); | ||
var _iterateSorted = require("../helpers/iterate-sorted"); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
exports.__esModule = true; | ||
exports.expandAlternative = void 0; | ||
var Expansion_1 = __importDefault(require("../Expansion")); | ||
var iterate_sorted_1 = require("../helpers/iterate-sorted"); | ||
function traverseTree(tree) { | ||
if (!tree.length) { | ||
return _Expansion.default.Empty; | ||
} | ||
/** | ||
* Recursively expand all expressions in the alternative. Then | ||
* combine all the permutations of the expansions. This is | ||
* necessary to expand deep, complex expressions like [12](3+|\d) | ||
*/ | ||
const firstBranch = this.expandExpression(tree[0]); | ||
const restOfTree = traverseTree.call(this, tree.slice(1)); | ||
if (restOfTree.count <= 0) { | ||
return firstBranch; | ||
} | ||
const iterator = () => (0, _iterateSorted.iteratePermutations)([firstBranch, restOfTree]); | ||
const numPermutations = firstBranch.count * restOfTree.count; | ||
return new _Expansion.default(iterator, numPermutations); | ||
if (!tree.length) { | ||
return Expansion_1["default"].Empty; | ||
} | ||
/** | ||
* Recursively expand all expressions in the alternative. Then | ||
* combine all the permutations of the expansions. This is | ||
* necessary to expand deep, complex expressions like [12](3+|\d) | ||
*/ | ||
var firstBranch = this.expandExpression(tree[0]); | ||
var restOfTree = traverseTree.call(this, tree.slice(1)); | ||
if (restOfTree.count <= 0) { | ||
return firstBranch; | ||
} | ||
var iterator = function () { return iterate_sorted_1.iteratePermutations([firstBranch, restOfTree]); }; | ||
var numPermutations = firstBranch.count * restOfTree.count; | ||
return new Expansion_1["default"](iterator, numPermutations); | ||
} | ||
@@ -43,6 +33,6 @@ /** | ||
*/ | ||
function expandAlternative(node) { | ||
return traverseTree.call(this, node.expressions); | ||
} | ||
return traverseTree.call(this, node.expressions); | ||
} | ||
exports.expandAlternative = expandAlternative; | ||
//# sourceMappingURL=alternative-pattern.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); | ||
}) : (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
o[k2] = m[k]; | ||
})); | ||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { | ||
Object.defineProperty(o, "default", { enumerable: true, value: v }); | ||
}) : function(o, v) { | ||
o["default"] = v; | ||
}); | ||
exports.expandChar = expandChar; | ||
var _Expansion = _interopRequireDefault(require("../Expansion")); | ||
var _fisherYatesRandom = _interopRequireDefault(require("../sorts/fisher-yates-random")); | ||
var Guards = _interopRequireWildcard(require("../types/regexp-tree-guards")); | ||
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; } | ||
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
const alphaOffsetCharCode = 'a'.charCodeAt(0) - 1; | ||
var __importStar = (this && this.__importStar) || function (mod) { | ||
if (mod && mod.__esModule) return mod; | ||
var result = {}; | ||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); | ||
__setModuleDefault(result, mod); | ||
return result; | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
exports.__esModule = true; | ||
exports.expandChar = void 0; | ||
var Expansion_1 = __importDefault(require("../Expansion")); | ||
var fisher_yates_random_1 = __importDefault(require("../sorts/fisher-yates-random")); | ||
var Guards = __importStar(require("../types/regexp-tree-guards")); | ||
var alphaOffsetCharCode = 'a'.charCodeAt(0) - 1; | ||
/* istanbul ignore next */ | ||
function assertNever(x) { | ||
throw new Error(`Unexpected char type: ${x}`); | ||
throw new Error("Unexpected char type: " + x); | ||
} | ||
function expandCharByCodePoint(codePoint, flags) { | ||
const char = String.fromCodePoint(codePoint); | ||
const expanded = flags.includes('i') && char.toUpperCase() !== char.toLowerCase() ? [char.toLowerCase(), char.toUpperCase()] : [char]; | ||
const sortChars = () => (0, _fisherYatesRandom.default)(expanded); | ||
return new _Expansion.default(sortChars, expanded.length); | ||
var char = String.fromCodePoint(codePoint); | ||
var expanded = flags.includes('i') && char.toUpperCase() !== char.toLowerCase() | ||
? [char.toLowerCase(), char.toUpperCase()] | ||
: [char]; | ||
var sortChars = function () { return fisher_yates_random_1["default"](expanded); }; | ||
return new Expansion_1["default"](sortChars, expanded.length); | ||
} | ||
@@ -41,15 +48,13 @@ /** | ||
*/ | ||
function translateEscapedControlChar(escapedControlChar) { | ||
// Get the last character of the sequence, e.g. "J" | ||
const controlChar = escapedControlChar.value.substr(-1); // Normalize the character to lowercase, since control characters are | ||
// case-insensitive, then convert to its decimal value. | ||
const controlCharCodeLower = controlChar.toLowerCase().charCodeAt(0); // Shift the decimal value from the alphanumeric range to the control range. | ||
const controlCharCodeTranslated = controlCharCodeLower - alphaOffsetCharCode; // Convert the shifted decimal char code to a literal character. | ||
const controlCharString = String.fromCharCode(controlCharCodeTranslated); | ||
return new _Expansion.default([controlCharString], 1); | ||
// Get the last character of the sequence, e.g. "J" | ||
var controlChar = escapedControlChar.value.substr(-1); | ||
// Normalize the character to lowercase, since control characters are | ||
// case-insensitive, then convert to its decimal value. | ||
var controlCharCodeLower = controlChar.toLowerCase().charCodeAt(0); | ||
// Shift the decimal value from the alphanumeric range to the control range. | ||
var controlCharCodeTranslated = controlCharCodeLower - alphaOffsetCharCode; | ||
// Convert the shifted decimal char code to a literal character. | ||
var controlCharString = String.fromCharCode(controlCharCodeTranslated); | ||
return new Expansion_1["default"]([controlCharString], 1); | ||
} | ||
@@ -62,29 +67,29 @@ /** | ||
*/ | ||
function expandChar(node) { | ||
const { | ||
flags | ||
} = this; | ||
if (Guards.isSimpleChar(node)) { | ||
return expandCharByCodePoint(node.codePoint, flags); | ||
} else if (['oct', 'hex', 'unicode'].includes(node.kind)) { | ||
return expandCharByCodePoint(node.codePoint, flags); | ||
} else if (node.kind === 'control') { | ||
return translateEscapedControlChar(node); | ||
} else if (node.kind === 'decimal') { | ||
var flags = this.flags; | ||
if (Guards.isSimpleChar(node)) { | ||
return expandCharByCodePoint(node.codePoint, flags); | ||
} | ||
else if (['oct', 'hex', 'unicode'].includes(node.kind)) { | ||
return expandCharByCodePoint(node.codePoint, flags); | ||
} | ||
else if (node.kind === 'control') { | ||
return translateEscapedControlChar(node); | ||
} | ||
else if (node.kind === 'decimal') { | ||
/* istanbul ignore next */ | ||
var m = "\"" + node.value + "\" not removed by decimalCharToOctalCharTransform"; | ||
throw new Error(m); | ||
} | ||
else if (Number.isInteger(node.codePoint)) { | ||
return expandCharByCodePoint(node.codePoint, flags); | ||
} | ||
else if (Guards.isMetaChar(node)) { | ||
/* istanbul ignore next */ | ||
throw new Error("\"" + node.value + "\" not removed by metaToCharClassTransform"); | ||
} | ||
/* istanbul ignore next */ | ||
const m = `"${node.value}" not removed by decimalCharToOctalCharTransform`; | ||
throw new Error(m); | ||
} else if (Number.isInteger(node.codePoint)) { | ||
return expandCharByCodePoint(node.codePoint, flags); | ||
} else if (Guards.isMetaChar(node)) { | ||
/* istanbul ignore next */ | ||
throw new Error(`"${node.value}" not removed by metaToCharClassTransform`); | ||
} | ||
/* istanbul ignore next */ | ||
return assertNever(node); | ||
} | ||
return assertNever(node); | ||
} | ||
exports.expandChar = expandChar; | ||
//# sourceMappingURL=char-pattern.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); | ||
}) : (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
o[k2] = m[k]; | ||
})); | ||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { | ||
Object.defineProperty(o, "default", { enumerable: true, value: v }); | ||
}) : function(o, v) { | ||
o["default"] = v; | ||
}); | ||
exports.expandCharacterClass = expandCharacterClass; | ||
var _constants = require("../constants"); | ||
var _Expansion = _interopRequireDefault(require("../Expansion")); | ||
var _fisherYatesRandom = _interopRequireDefault(require("../sorts/fisher-yates-random")); | ||
var Guards = _interopRequireWildcard(require("../types/regexp-tree-guards")); | ||
var _utils = require("../helpers/utils"); | ||
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; } | ||
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
var __importStar = (this && this.__importStar) || function (mod) { | ||
if (mod && mod.__esModule) return mod; | ||
var result = {}; | ||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); | ||
__setModuleDefault(result, mod); | ||
return result; | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
exports.__esModule = true; | ||
exports.expandCharacterClass = void 0; | ||
var constants_1 = require("../constants"); | ||
var Expansion_1 = __importDefault(require("../Expansion")); | ||
var fisher_yates_random_1 = __importDefault(require("../sorts/fisher-yates-random")); | ||
var Guards = __importStar(require("../types/regexp-tree-guards")); | ||
var utils_1 = require("../helpers/utils"); | ||
function getReferencedCodePoints(expression) { | ||
// A ClassRange encompasses a range of code points | ||
if (Guards.isClassRange(expression)) { | ||
const minCodePoint = expression.from.codePoint; | ||
const maxCodePoint = expression.to.codePoint; | ||
return (0, _utils.fill)(minCodePoint, maxCodePoint); | ||
} | ||
return [expression.codePoint]; | ||
// A ClassRange encompasses a range of code points | ||
if (Guards.isClassRange(expression)) { | ||
var minCodePoint = expression.from.codePoint; | ||
var maxCodePoint = expression.to.codePoint; | ||
return utils_1.fill(minCodePoint, maxCodePoint); | ||
} | ||
return [expression.codePoint]; | ||
} | ||
const allCodePointOptions = _constants.Chars.all.map(char => char.charCodeAt(0)); | ||
var allCodePointOptions = constants_1.Chars.all.map(function (char) { return char.charCodeAt(0); }); | ||
/** | ||
@@ -43,24 +48,25 @@ * Expand an expression which represents a single character from a | ||
*/ | ||
function expandCharacterClass(node) { | ||
const applyCaseInsensitiveFlag = (accumulator, char) => { | ||
if (this.flags.includes('i') && char.toLowerCase() !== char.toUpperCase()) { | ||
return accumulator.concat([char.toLowerCase(), char.toUpperCase()]); | ||
} | ||
return accumulator.concat(char); | ||
}; | ||
const referencedCodePoints = node.expressions.reduce((accumulator, expression) => { | ||
const codePoints = getReferencedCodePoints(expression); | ||
return accumulator.concat(codePoints); | ||
}, []); | ||
const expandedClass = allCodePointOptions // For a whitelist set, discard code points not referenced in the set | ||
.filter(opt => !node.negative || !referencedCodePoints.includes(opt)) // For a blacklist set, discard code points referenced in the set | ||
.filter(opt => node.negative || referencedCodePoints.includes(opt)).map(codePoint => String.fromCodePoint(codePoint)).reduce(applyCaseInsensitiveFlag, []); | ||
const sortChars = () => (0, _fisherYatesRandom.default)(expandedClass); | ||
return new _Expansion.default(sortChars, expandedClass.length); | ||
} | ||
var _this = this; | ||
var applyCaseInsensitiveFlag = function (accumulator, char) { | ||
if (_this.flags.includes('i') && char.toLowerCase() !== char.toUpperCase()) { | ||
return accumulator.concat([char.toLowerCase(), char.toUpperCase()]); | ||
} | ||
return accumulator.concat(char); | ||
}; | ||
var referencedCodePoints = node.expressions.reduce(function (accumulator, expression) { | ||
var codePoints = getReferencedCodePoints(expression); | ||
return accumulator.concat(codePoints); | ||
}, []); | ||
var expandedClass = allCodePointOptions | ||
// For a whitelist set, discard code points not referenced in the set | ||
.filter(function (opt) { return !node.negative || !referencedCodePoints.includes(opt); }) | ||
// For a blacklist set, discard code points referenced in the set | ||
.filter(function (opt) { return node.negative || referencedCodePoints.includes(opt); }) | ||
.map(function (codePoint) { return String.fromCodePoint(codePoint); }) | ||
.reduce(applyCaseInsensitiveFlag, []); | ||
var sortChars = function () { return fisher_yates_random_1["default"](expandedClass); }; | ||
return new Expansion_1["default"](sortChars, expandedClass.length); | ||
} | ||
exports.expandCharacterClass = expandCharacterClass; | ||
//# sourceMappingURL=character-class-pattern.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.expandDisjunction = expandDisjunction; | ||
var _Expansion = _interopRequireDefault(require("../Expansion")); | ||
var _iterateSorted = require("../helpers/iterate-sorted"); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
exports.__esModule = true; | ||
exports.expandDisjunction = void 0; | ||
var Expansion_1 = __importDefault(require("../Expansion")); | ||
var iterate_sorted_1 = require("../helpers/iterate-sorted"); | ||
/** | ||
@@ -23,9 +18,10 @@ * Expand an expression which represents one of two options, like "(a|b}" | ||
function expandDisjunction(node) { | ||
const expressions = [node.left, node.right]; | ||
const expansions = expressions.map(e => this.expandExpression(e)); | ||
const expandBothSides = () => (0, _iterateSorted.iterateWeightedByCount)(expansions); | ||
const iterationsSum = expansions[0].count + expansions[1].count; | ||
return new _Expansion.default(expandBothSides, iterationsSum); | ||
} | ||
var _this = this; | ||
var expressions = [node.left, node.right]; | ||
var expansions = expressions.map(function (e) { return _this.expandExpression(e); }); | ||
var expandBothSides = function () { return iterate_sorted_1.iterateWeightedByCount(expansions); }; | ||
var iterationsSum = expansions[0].count + expansions[1].count; | ||
return new Expansion_1["default"](expandBothSides, iterationsSum); | ||
} | ||
exports.expandDisjunction = expandDisjunction; | ||
//# sourceMappingURL=disjunction-pattern.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); | ||
}) : (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
o[k2] = m[k]; | ||
})); | ||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { | ||
Object.defineProperty(o, "default", { enumerable: true, value: v }); | ||
}) : function(o, v) { | ||
o["default"] = v; | ||
}); | ||
exports.expandBackreference = expandBackreference; | ||
exports.expandGroup = expandGroup; | ||
var _Expansion = _interopRequireDefault(require("../Expansion")); | ||
var Guards = _interopRequireWildcard(require("../types/regexp-tree-guards")); | ||
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; } | ||
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
var __importStar = (this && this.__importStar) || function (mod) { | ||
if (mod && mod.__esModule) return mod; | ||
var result = {}; | ||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); | ||
__setModuleDefault(result, mod); | ||
return result; | ||
}; | ||
var __generator = (this && this.__generator) || function (thisArg, body) { | ||
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; | ||
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; | ||
function verb(n) { return function (v) { return step([n, v]); }; } | ||
function step(op) { | ||
if (f) throw new TypeError("Generator is already executing."); | ||
while (_) try { | ||
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; | ||
if (y = 0, t) op = [op[0] & 2, t.value]; | ||
switch (op[0]) { | ||
case 0: case 1: t = op; break; | ||
case 4: _.label++; return { value: op[1], done: false }; | ||
case 5: _.label++; y = op[1]; op = [0]; continue; | ||
case 7: op = _.ops.pop(); _.trys.pop(); continue; | ||
default: | ||
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } | ||
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } | ||
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } | ||
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } | ||
if (t[2]) _.ops.pop(); | ||
_.trys.pop(); continue; | ||
} | ||
op = body.call(thisArg, _); | ||
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } | ||
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; | ||
} | ||
}; | ||
var __values = (this && this.__values) || function(o) { | ||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; | ||
if (m) return m.call(o); | ||
if (o && typeof o.length === "number") return { | ||
next: function () { | ||
if (o && i >= o.length) o = void 0; | ||
return { value: o && o[i++], done: !o }; | ||
} | ||
}; | ||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
exports.__esModule = true; | ||
exports.expandGroup = exports.expandBackreference = void 0; | ||
var Expansion_1 = __importDefault(require("../Expansion")); | ||
var Guards = __importStar(require("../types/regexp-tree-guards")); | ||
/* istanbul ignore next */ | ||
function assertNever(x) { | ||
throw new Error(`Unexpected backreference: ${x}`); | ||
throw new Error("Unexpected backreference: " + x); | ||
} | ||
const namedGroups = {}; | ||
const numberedGroups = {}; | ||
var namedGroups = {}; | ||
var numberedGroups = {}; | ||
/** | ||
@@ -32,17 +78,17 @@ * Expand an expression which copies a Group elsewhere in | ||
*/ | ||
function expandBackreference(node) { | ||
let lookupBackreference = () => []; | ||
if (Guards.isNamedBackreference(node)) { | ||
lookupBackreference = () => [namedGroups[node.reference]]; | ||
} else if (Guards.isNumericBackreference(node)) { | ||
lookupBackreference = () => [numberedGroups[node.number]]; | ||
} else { | ||
/* istanbul ignore next */ | ||
assertNever(node); | ||
} | ||
return new _Expansion.default(lookupBackreference, 1); | ||
var lookupBackreference = function () { return []; }; | ||
if (Guards.isNamedBackreference(node)) { | ||
lookupBackreference = function () { return [namedGroups[node.reference]]; }; | ||
} | ||
else if (Guards.isNumericBackreference(node)) { | ||
lookupBackreference = function () { return [numberedGroups[node.number]]; }; | ||
} | ||
else { | ||
/* istanbul ignore next */ | ||
assertNever(node); | ||
} | ||
return new Expansion_1["default"](lookupBackreference, 1); | ||
} | ||
exports.expandBackreference = expandBackreference; | ||
/** | ||
@@ -55,28 +101,52 @@ * Expand an expression that wraps another expression, like "(a)" | ||
*/ | ||
function expandGroup(node) { | ||
const generator = this.expandExpression(node.expression); | ||
function expandAndStoreCapture(expression) { | ||
// Store the expansion in case this Group is referenced | ||
// by a Backreference. | ||
if (Guards.isCapturingGroup(node)) { | ||
numberedGroups[node.number] = expression; | ||
if (node.name) { | ||
namedGroups[node.name] = expression; | ||
} | ||
var generator = this.expandExpression(node.expression); | ||
function expandAndStoreCapture(expression) { | ||
// Store the expansion in case this Group is referenced | ||
// by a Backreference. | ||
if (Guards.isCapturingGroup(node)) { | ||
numberedGroups[node.number] = expression; | ||
if (node.name) { | ||
namedGroups[node.name] = expression; | ||
} | ||
} | ||
return expression; | ||
} | ||
return expression; | ||
} | ||
function* expandAndStoreCaptures() { | ||
for (const expression of generator.getIterator()) { | ||
yield expandAndStoreCapture(expression); | ||
function expandAndStoreCaptures() { | ||
var _a, _b, expression, e_1_1; | ||
var e_1, _c; | ||
return __generator(this, function (_d) { | ||
switch (_d.label) { | ||
case 0: | ||
_d.trys.push([0, 5, 6, 7]); | ||
_a = __values(generator.getIterator()), _b = _a.next(); | ||
_d.label = 1; | ||
case 1: | ||
if (!!_b.done) return [3 /*break*/, 4]; | ||
expression = _b.value; | ||
return [4 /*yield*/, expandAndStoreCapture(expression)]; | ||
case 2: | ||
_d.sent(); | ||
_d.label = 3; | ||
case 3: | ||
_b = _a.next(); | ||
return [3 /*break*/, 1]; | ||
case 4: return [3 /*break*/, 7]; | ||
case 5: | ||
e_1_1 = _d.sent(); | ||
e_1 = { error: e_1_1 }; | ||
return [3 /*break*/, 7]; | ||
case 6: | ||
try { | ||
if (_b && !_b.done && (_c = _a["return"])) _c.call(_a); | ||
} | ||
finally { if (e_1) throw e_1.error; } | ||
return [7 /*endfinally*/]; | ||
case 7: return [2 /*return*/]; | ||
} | ||
}); | ||
} | ||
} | ||
return new _Expansion.default(expandAndStoreCaptures, generator.count); | ||
} | ||
return new Expansion_1["default"](expandAndStoreCaptures, generator.count); | ||
} | ||
exports.expandGroup = expandGroup; | ||
//# sourceMappingURL=group-pattern.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); | ||
}) : (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
o[k2] = m[k]; | ||
})); | ||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { | ||
Object.defineProperty(o, "default", { enumerable: true, value: v }); | ||
}) : function(o, v) { | ||
o["default"] = v; | ||
}); | ||
exports.expandRepetition = expandRepetition; | ||
var _Expansion = _interopRequireDefault(require("../Expansion")); | ||
var Guards = _interopRequireWildcard(require("../types/regexp-tree-guards")); | ||
var _iterateSorted = require("../helpers/iterate-sorted"); | ||
var _utils = require("../helpers/utils"); | ||
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; } | ||
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
var __importStar = (this && this.__importStar) || function (mod) { | ||
if (mod && mod.__esModule) return mod; | ||
var result = {}; | ||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); | ||
__setModuleDefault(result, mod); | ||
return result; | ||
}; | ||
var __read = (this && this.__read) || function (o, n) { | ||
var m = typeof Symbol === "function" && o[Symbol.iterator]; | ||
if (!m) return o; | ||
var i = m.call(o), r, ar = [], e; | ||
try { | ||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); | ||
} | ||
catch (error) { e = { error: error }; } | ||
finally { | ||
try { | ||
if (r && !r.done && (m = i["return"])) m.call(i); | ||
} | ||
finally { if (e) throw e.error; } | ||
} | ||
return ar; | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
exports.__esModule = true; | ||
exports.expandRepetition = void 0; | ||
var Expansion_1 = __importDefault(require("../Expansion")); | ||
var Guards = __importStar(require("../types/regexp-tree-guards")); | ||
var iterate_sorted_1 = require("../helpers/iterate-sorted"); | ||
var utils_1 = require("../helpers/utils"); | ||
/* istanbul ignore next */ | ||
function assertNever(x) { | ||
throw new Error(`Unexpected quantifier: ${x}`); | ||
throw new Error("Unexpected quantifier: " + x); | ||
} | ||
function getNumOccurrences(quantifier) { | ||
/* istanbul ignore next */ | ||
if (Guards.isSimpleQuantifier(quantifier)) { | ||
const transformer = 'simpleQuantifierToRangeQuantifierTransform'; | ||
throw new Error(`"${quantifier.kind}" not removed by ${transformer}`); | ||
} else if (!Guards.isRangeQuantifier(quantifier)) { | ||
assertNever(quantifier); | ||
} | ||
const { | ||
from, | ||
to | ||
} = quantifier; // Cap unbounded quantifiers like * and +. | ||
// Otherwise there would be infinite expansions. | ||
return [from, to !== undefined ? to : 100]; | ||
/* istanbul ignore next */ | ||
if (Guards.isSimpleQuantifier(quantifier)) { | ||
var transformer = 'simpleQuantifierToRangeQuantifierTransform'; | ||
throw new Error("\"" + quantifier.kind + "\" not removed by " + transformer); | ||
} | ||
else if (!Guards.isRangeQuantifier(quantifier)) { | ||
assertNever(quantifier); | ||
} | ||
var from = quantifier.from, to = quantifier.to; | ||
// Cap unbounded quantifiers like * and +. | ||
// Otherwise there would be infinite expansions. | ||
return [from, to !== undefined ? to : 100]; | ||
} | ||
@@ -50,24 +70,24 @@ /** | ||
*/ | ||
function expandRepetition(node) { | ||
const [minOccurrences, maxOccurrences] = getNumOccurrences(node.quantifier); | ||
const numOccurrenceOptions = (0, _utils.fill)(minOccurrences, maxOccurrences); | ||
const expansionOnce = this.expandExpression(node.expression); // Calculate the expansions for each quantity of repetition, like "a{1}", | ||
// "a{2}", "a{3}", etc. | ||
const allExpansions = numOccurrenceOptions.map(numOccurrences => { | ||
if (numOccurrences <= 0) { | ||
return _Expansion.default.Blank; | ||
} | ||
const expansionNTimes = new Array(numOccurrences).fill(expansionOnce); | ||
const numPermutationsThisNumOccurrences = expansionOnce.count ** numOccurrences; | ||
return new _Expansion.default(() => (0, _iterateSorted.iteratePermutations)(expansionNTimes), numPermutationsThisNumOccurrences); | ||
}); | ||
const totalNumPermutations = allExpansions.reduce((sum, { | ||
count | ||
}) => sum + count, 0); // Return all of the expansions for all quantities of repetition. | ||
return new _Expansion.default(() => (0, _iterateSorted.iterateWeightedByCount)(allExpansions), totalNumPermutations); | ||
} | ||
var _a = __read(getNumOccurrences(node.quantifier), 2), minOccurrences = _a[0], maxOccurrences = _a[1]; | ||
var numOccurrenceOptions = utils_1.fill(minOccurrences, maxOccurrences); | ||
var expansionOnce = this.expandExpression(node.expression); | ||
// Calculate the expansions for each quantity of repetition, like "a{1}", | ||
// "a{2}", "a{3}", etc. | ||
var allExpansions = numOccurrenceOptions.map(function (numOccurrences) { | ||
if (numOccurrences <= 0) { | ||
return Expansion_1["default"].Blank; | ||
} | ||
var expansionNTimes = new Array(numOccurrences).fill(expansionOnce); | ||
var numPermutationsThisNumOccurrences = Math.pow(expansionOnce.count, numOccurrences); | ||
return new Expansion_1["default"](function () { return iterate_sorted_1.iteratePermutations(expansionNTimes); }, numPermutationsThisNumOccurrences); | ||
}); | ||
var totalNumPermutations = allExpansions.reduce(function (sum, _a) { | ||
var count = _a.count; | ||
return sum + count; | ||
}, 0); | ||
// Return all of the expansions for all quantities of repetition. | ||
return new Expansion_1["default"](function () { return iterate_sorted_1.iterateWeightedByCount(allExpansions); }, totalNumPermutations); | ||
} | ||
exports.expandRepetition = expandRepetition; | ||
//# sourceMappingURL=repetition-pattern.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.default = void 0; | ||
function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; } | ||
var __generator = (this && this.__generator) || function (thisArg, body) { | ||
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; | ||
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; | ||
function verb(n) { return function (v) { return step([n, v]); }; } | ||
function step(op) { | ||
if (f) throw new TypeError("Generator is already executing."); | ||
while (_) try { | ||
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; | ||
if (y = 0, t) op = [op[0] & 2, t.value]; | ||
switch (op[0]) { | ||
case 0: case 1: t = op; break; | ||
case 4: _.label++; return { value: op[1], done: false }; | ||
case 5: _.label++; y = op[1]; op = [0]; continue; | ||
case 7: op = _.ops.pop(); _.trys.pop(); continue; | ||
default: | ||
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } | ||
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } | ||
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } | ||
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } | ||
if (t[2]) _.ops.pop(); | ||
_.trys.pop(); continue; | ||
} | ||
op = body.call(thisArg, _); | ||
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } | ||
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; | ||
} | ||
}; | ||
var __values = (this && this.__values) || function(o) { | ||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; | ||
if (m) return m.call(o); | ||
if (o && typeof o.length === "number") return { | ||
next: function () { | ||
if (o && i >= o.length) o = void 0; | ||
return { value: o && o[i++], done: !o }; | ||
} | ||
}; | ||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); | ||
}; | ||
exports.__esModule = true; | ||
function toIterable(getIterator) { | ||
return function* beginIterating() { | ||
yield* getIterator instanceof Function ? getIterator() : getIterator; | ||
}; | ||
return function beginIterating() { | ||
return __generator(this, function (_a) { | ||
switch (_a.label) { | ||
case 0: return [5 /*yield**/, __values(getIterator instanceof Function ? getIterator() : getIterator)]; | ||
case 1: | ||
_a.sent(); | ||
return [2 /*return*/]; | ||
} | ||
}); | ||
}; | ||
} | ||
class Expansion { | ||
/** | ||
* A single blank string Expansion | ||
*/ | ||
/** | ||
* Zero string expansions | ||
*/ | ||
/** | ||
* Get an iterator that yields strings matched by the pattern | ||
*/ | ||
/** | ||
* The total number of possible expansions of the pattern | ||
*/ | ||
constructor(getIterator, count) { | ||
_defineProperty(this, "getIterator", void 0); | ||
_defineProperty(this, "count", void 0); | ||
this.getIterator = toIterable(getIterator); | ||
this.count = count; | ||
} | ||
} | ||
exports.default = Expansion; | ||
_defineProperty(Expansion, "Blank", new Expansion([''], 1)); | ||
_defineProperty(Expansion, "Empty", new Expansion([], 0)); | ||
var Expansion = /** @class */ (function () { | ||
function Expansion(getIterator, count) { | ||
this.getIterator = toIterable(getIterator); | ||
this.count = count; | ||
} | ||
/** | ||
* A single blank string Expansion | ||
*/ | ||
Expansion.Blank = new Expansion([''], 1); | ||
/** | ||
* Zero string expansions | ||
*/ | ||
Expansion.Empty = new Expansion([], 0); | ||
return Expansion; | ||
}()); | ||
exports["default"] = Expansion; | ||
//# sourceMappingURL=Expansion.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.iterateWeightedByCount = iterateWeightedByCount; | ||
exports.iteratePermutations = iteratePermutations; | ||
var _numberRandom = _interopRequireDefault(require("../sorts/number-random")); | ||
var _weightedRandom = _interopRequireDefault(require("../sorts/weighted-random")); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
var __generator = (this && this.__generator) || function (thisArg, body) { | ||
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g; | ||
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g; | ||
function verb(n) { return function (v) { return step([n, v]); }; } | ||
function step(op) { | ||
if (f) throw new TypeError("Generator is already executing."); | ||
while (_) try { | ||
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t; | ||
if (y = 0, t) op = [op[0] & 2, t.value]; | ||
switch (op[0]) { | ||
case 0: case 1: t = op; break; | ||
case 4: _.label++; return { value: op[1], done: false }; | ||
case 5: _.label++; y = op[1]; op = [0]; continue; | ||
case 7: op = _.ops.pop(); _.trys.pop(); continue; | ||
default: | ||
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; } | ||
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; } | ||
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; } | ||
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; } | ||
if (t[2]) _.ops.pop(); | ||
_.trys.pop(); continue; | ||
} | ||
op = body.call(thisArg, _); | ||
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; } | ||
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true }; | ||
} | ||
}; | ||
var __read = (this && this.__read) || function (o, n) { | ||
var m = typeof Symbol === "function" && o[Symbol.iterator]; | ||
if (!m) return o; | ||
var i = m.call(o), r, ar = [], e; | ||
try { | ||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); | ||
} | ||
catch (error) { e = { error: error }; } | ||
finally { | ||
try { | ||
if (r && !r.done && (m = i["return"])) m.call(i); | ||
} | ||
finally { if (e) throw e.error; } | ||
} | ||
return ar; | ||
}; | ||
var __values = (this && this.__values) || function(o) { | ||
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; | ||
if (m) return m.call(o); | ||
if (o && typeof o.length === "number") return { | ||
next: function () { | ||
if (o && i >= o.length) o = void 0; | ||
return { value: o && o[i++], done: !o }; | ||
} | ||
}; | ||
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
exports.__esModule = true; | ||
exports.iteratePermutations = exports.iterateWeightedByCount = void 0; | ||
var number_random_1 = __importDefault(require("../sorts/number-random")); | ||
var weighted_random_1 = __importDefault(require("../sorts/weighted-random")); | ||
/** | ||
@@ -21,27 +69,32 @@ * Return all strings from a set of expansions. Randomize the order of the returned strings. | ||
*/ | ||
function* iterateWeightedByCount(options) { | ||
const iterators = options.map(option => option.getIterator()); | ||
const weights = options.map(option => option.count); | ||
while (iterators.length > 0) { | ||
// Randomly choose an option, weighted by the size of the expansion. | ||
// For example, \d{3} will be chosen 10x more often than \d{2}. | ||
const iRandom = (0, _weightedRandom.default)(weights); | ||
const { | ||
done, | ||
value | ||
} = iterators[iRandom].next(); | ||
if (done) { | ||
// We've exhausted expansions for this iterator. | ||
// Remove it from the list of options. | ||
iterators.splice(iRandom, 1); | ||
weights.splice(iRandom, 1); | ||
} else { | ||
yield value; // Update weight to reflect the remaining count. | ||
weights[iRandom]--; | ||
} | ||
} | ||
function iterateWeightedByCount(options) { | ||
var iterators, weights, iRandom, _a, done, value; | ||
return __generator(this, function (_b) { | ||
switch (_b.label) { | ||
case 0: | ||
iterators = options.map(function (option) { return option.getIterator(); }); | ||
weights = options.map(function (option) { return option.count; }); | ||
_b.label = 1; | ||
case 1: | ||
if (!(iterators.length > 0)) return [3 /*break*/, 5]; | ||
iRandom = weighted_random_1["default"](weights); | ||
_a = iterators[iRandom].next(), done = _a.done, value = _a.value; | ||
if (!done) return [3 /*break*/, 2]; | ||
// We've exhausted expansions for this iterator. | ||
// Remove it from the list of options. | ||
iterators.splice(iRandom, 1); | ||
weights.splice(iRandom, 1); | ||
return [3 /*break*/, 4]; | ||
case 2: return [4 /*yield*/, value]; | ||
case 3: | ||
_b.sent(); | ||
// Update weight to reflect the remaining count. | ||
weights[iRandom]--; | ||
_b.label = 4; | ||
case 4: return [3 /*break*/, 1]; | ||
case 5: return [2 /*return*/]; | ||
} | ||
}); | ||
} | ||
exports.iterateWeightedByCount = iterateWeightedByCount; | ||
/** | ||
@@ -55,58 +108,86 @@ * Return strings for all permutations of a set of expansions. Randomize the order of the | ||
// eslint-disable-next-line consistent-return | ||
function* iteratePermutations(expansions) { | ||
const [thisExpansion, ...childExpansions] = expansions; | ||
const thisIterator = thisExpansion.getIterator(); | ||
let numCompletedValuesThisIterator = 0; | ||
if (expansions.length <= 1) { | ||
// Reached the end of the recursion, yield all iterations | ||
// of the final expansion. | ||
return yield* thisIterator; | ||
} // Yield all permutations of one value from the current iterator with | ||
// all values from the child expansions. | ||
function* iterateChildPermutations() { | ||
const { | ||
done, | ||
value: thisValue | ||
} = thisIterator.next(); | ||
if (done) { | ||
return; | ||
function iteratePermutations(expansions) { | ||
// Yield all permutations of one value from the current iterator with | ||
// all values from the child expansions. | ||
function iterateChildPermutations() { | ||
var _a, done, thisValue, childIterator, childIterator_1, childIterator_1_1, childValue, e_1_1; | ||
var e_1, _b; | ||
return __generator(this, function (_c) { | ||
switch (_c.label) { | ||
case 0: | ||
_a = thisIterator.next(), done = _a.done, thisValue = _a.value; | ||
if (done) { | ||
return [2 /*return*/]; | ||
} | ||
childIterator = iteratePermutations(childExpansions); | ||
_c.label = 1; | ||
case 1: | ||
_c.trys.push([1, 6, 7, 8]); | ||
childIterator_1 = __values(childIterator), childIterator_1_1 = childIterator_1.next(); | ||
_c.label = 2; | ||
case 2: | ||
if (!!childIterator_1_1.done) return [3 /*break*/, 5]; | ||
childValue = childIterator_1_1.value; | ||
return [4 /*yield*/, "" + thisValue + childValue]; | ||
case 3: | ||
_c.sent(); | ||
_c.label = 4; | ||
case 4: | ||
childIterator_1_1 = childIterator_1.next(); | ||
return [3 /*break*/, 2]; | ||
case 5: return [3 /*break*/, 8]; | ||
case 6: | ||
e_1_1 = _c.sent(); | ||
e_1 = { error: e_1_1 }; | ||
return [3 /*break*/, 8]; | ||
case 7: | ||
try { | ||
if (childIterator_1_1 && !childIterator_1_1.done && (_b = childIterator_1["return"])) _b.call(childIterator_1); | ||
} | ||
finally { if (e_1) throw e_1.error; } | ||
return [7 /*endfinally*/]; | ||
case 8: | ||
numCompletedValuesThisIterator++; | ||
return [2 /*return*/]; | ||
} | ||
}); | ||
} | ||
const childIterator = iteratePermutations(childExpansions); | ||
for (const childValue of childIterator) { | ||
yield `${thisValue}${childValue}`; | ||
} | ||
numCompletedValuesThisIterator++; | ||
} | ||
const inProgressIterators = []; | ||
while (numCompletedValuesThisIterator < thisExpansion.count) { | ||
let iRandom = (0, _numberRandom.default)(0, thisExpansion.count - 1); | ||
if (iRandom > inProgressIterators.length - 1) { | ||
inProgressIterators.push(iterateChildPermutations()); | ||
iRandom = inProgressIterators.length - 1; | ||
} | ||
const { | ||
done, | ||
value | ||
} = inProgressIterators[iRandom].next(); | ||
if (done) { | ||
// We've exhausted permutations for this value of the current iterator. | ||
inProgressIterators.splice(iRandom, 1); | ||
} else { | ||
yield value; | ||
} | ||
} | ||
} | ||
var _a, thisExpansion, childExpansions, thisIterator, numCompletedValuesThisIterator, inProgressIterators, iRandom, _b, done, value; | ||
return __generator(this, function (_c) { | ||
switch (_c.label) { | ||
case 0: | ||
_a = __read(expansions), thisExpansion = _a[0], childExpansions = _a.slice(1); | ||
thisIterator = thisExpansion.getIterator(); | ||
numCompletedValuesThisIterator = 0; | ||
if (!(expansions.length <= 1)) return [3 /*break*/, 2]; | ||
return [5 /*yield**/, __values(thisIterator)]; | ||
case 1: | ||
// Reached the end of the recursion, yield all iterations | ||
// of the final expansion. | ||
return [2 /*return*/, _c.sent()]; | ||
case 2: | ||
inProgressIterators = []; | ||
_c.label = 3; | ||
case 3: | ||
if (!(numCompletedValuesThisIterator < thisExpansion.count)) return [3 /*break*/, 7]; | ||
iRandom = number_random_1["default"](0, thisExpansion.count - 1); | ||
if (iRandom > inProgressIterators.length - 1) { | ||
inProgressIterators.push(iterateChildPermutations()); | ||
iRandom = inProgressIterators.length - 1; | ||
} | ||
_b = inProgressIterators[iRandom].next(), done = _b.done, value = _b.value; | ||
if (!done) return [3 /*break*/, 4]; | ||
// We've exhausted permutations for this value of the current iterator. | ||
inProgressIterators.splice(iRandom, 1); | ||
return [3 /*break*/, 6]; | ||
case 4: return [4 /*yield*/, value]; | ||
case 5: | ||
_c.sent(); | ||
_c.label = 6; | ||
case 6: return [3 /*break*/, 3]; | ||
case 7: return [2 /*return*/]; | ||
} | ||
}); | ||
} | ||
exports.iteratePermutations = iteratePermutations; | ||
//# sourceMappingURL=iterate-sorted.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.fill = fill; | ||
exports.__esModule = true; | ||
exports.fill = void 0; | ||
/** | ||
@@ -15,9 +11,9 @@ * Generate an array full of sequential integers. | ||
function fill(start, end) { | ||
const result = new Array(1 + end - start); | ||
for (let i = start; i <= end; i++) { | ||
result[i - start] = i; | ||
} | ||
return result; | ||
} | ||
var result = new Array(1 + end - start); | ||
for (var i = start; i <= end; i++) { | ||
result[i - start] = i; | ||
} | ||
return result; | ||
} | ||
exports.fill = fill; | ||
//# sourceMappingURL=utils.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
var _pattern = require("./pattern"); | ||
Object.keys(_pattern).forEach(function (key) { | ||
if (key === "default" || key === "__esModule") return; | ||
if (key in exports && exports[key] === _pattern[key]) return; | ||
Object.defineProperty(exports, key, { | ||
enumerable: true, | ||
get: function () { | ||
return _pattern[key]; | ||
} | ||
}); | ||
}); | ||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); | ||
}) : (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
o[k2] = m[k]; | ||
})); | ||
var __exportStar = (this && this.__exportStar) || function(m, exports) { | ||
for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p); | ||
}; | ||
exports.__esModule = true; | ||
__exportStar(require("./pattern"), exports); | ||
//# sourceMappingURL=index.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.count = count; | ||
exports.expand = expand; | ||
exports.expandN = expandN; | ||
exports.expandAll = expandAll; | ||
exports.toRegExp = toRegExp; | ||
var _regexpTree = require("regexp-tree"); | ||
var _Expander = _interopRequireDefault(require("./Expander")); | ||
var _Expansion = _interopRequireDefault(require("./Expansion")); | ||
var _ = require("."); | ||
var _transforms = _interopRequireDefault(require("./transforms")); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
var __read = (this && this.__read) || function (o, n) { | ||
var m = typeof Symbol === "function" && o[Symbol.iterator]; | ||
if (!m) return o; | ||
var i = m.call(o), r, ar = [], e; | ||
try { | ||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); | ||
} | ||
catch (error) { e = { error: error }; } | ||
finally { | ||
try { | ||
if (r && !r.done && (m = i["return"])) m.call(i); | ||
} | ||
finally { if (e) throw e.error; } | ||
} | ||
return ar; | ||
}; | ||
var __spreadArray = (this && this.__spreadArray) || function (to, from) { | ||
for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) | ||
to[j] = from[i]; | ||
return to; | ||
}; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
exports.__esModule = true; | ||
exports.toRegExp = exports.expandAll = exports.expandN = exports.expand = exports.count = void 0; | ||
var regexp_tree_1 = require("regexp-tree"); | ||
var Expander_1 = __importDefault(require("./Expander")); | ||
var Expansion_1 = __importDefault(require("./Expansion")); | ||
// Circular reference for spying/mocking in tests | ||
var _1 = require("."); | ||
var transforms_1 = __importDefault(require("./transforms")); | ||
// From https://triin.net/2011/10/19/Meta_Regular_Expression | ||
const regexAsStringPattern = /^\/([^/\[\\]|\\.|\[([^\]\\]|\\.)*\])*\/[a-z]*$/i; | ||
var regexAsStringPattern = /^\/([^/\[\\]|\\.|\[([^\]\\]|\\.)*\])*\/[a-z]*$/i; | ||
/** | ||
@@ -33,6 +42,6 @@ * Calculate how many strings satisfy the regular expression pattern. | ||
*/ | ||
function count(pattern) { | ||
return (0, _.expand)(pattern).count; | ||
return _1.expand(pattern).count; | ||
} | ||
exports.count = count; | ||
/** | ||
@@ -44,20 +53,19 @@ * Calculate strings that satisfy the regular expression pattern. | ||
*/ | ||
function expand(pattern) { | ||
if (pattern === null) { | ||
return _Expansion.default.Empty; | ||
} else if (!pattern) { | ||
return _Expansion.default.Blank; | ||
} | ||
const patternFormatted = (0, _.toRegExp)(pattern); // Run custom RegEx mutations in /transforms | ||
const transformed = (0, _regexpTree.transform)(patternFormatted, _transforms.default); // Process the RegEx logic into a regexp-tree | ||
const parsed = (0, _regexpTree.parse)(transformed.toString()); // Create an expansion generator with regex-to-strings | ||
const expander = new _Expander.default(parsed.flags); | ||
return expander.expandExpression(parsed.body); | ||
if (pattern === null) { | ||
return Expansion_1["default"].Empty; | ||
} | ||
else if (!pattern) { | ||
return Expansion_1["default"].Blank; | ||
} | ||
var patternFormatted = _1.toRegExp(pattern); | ||
// Run custom RegEx mutations in /transforms | ||
var transformed = regexp_tree_1.transform(patternFormatted, transforms_1["default"]); | ||
// Process the RegEx logic into a regexp-tree | ||
var parsed = regexp_tree_1.parse(transformed.toString()); | ||
// Create an expansion generator with regex-to-strings | ||
var expander = new Expander_1["default"](parsed.flags); | ||
return expander.expandExpression(parsed.body); | ||
} | ||
exports.expand = expand; | ||
/** | ||
@@ -71,16 +79,13 @@ * Calculate up to N strings that satisfy the regular expression pattern. | ||
*/ | ||
function expandN(pattern, maxExpansions) { | ||
const results = []; | ||
const generator = (0, _.expand)(pattern).getIterator(); | ||
let expansion = generator.next(); | ||
while (!expansion.done && results.length < maxExpansions) { | ||
results.push(expansion.value); | ||
expansion = generator.next(); | ||
} | ||
return results; | ||
var results = []; | ||
var generator = _1.expand(pattern).getIterator(); | ||
var expansion = generator.next(); | ||
while (!expansion.done && results.length < maxExpansions) { | ||
results.push(expansion.value); | ||
expansion = generator.next(); | ||
} | ||
return results; | ||
} | ||
exports.expandN = expandN; | ||
/** | ||
@@ -92,7 +97,6 @@ * Calculate all strings that satisfy the regular expression pattern. | ||
*/ | ||
function expandAll(pattern) { | ||
return [...(0, _.expand)(pattern).getIterator()]; | ||
return __spreadArray([], __read(_1.expand(pattern).getIterator())); | ||
} | ||
exports.expandAll = expandAll; | ||
/** | ||
@@ -104,13 +108,15 @@ * Normalize a regular expression pattern to a format that regexp-tree can parse. | ||
*/ | ||
function toRegExp(pattern) { | ||
if (pattern instanceof RegExp) { | ||
return pattern; | ||
} else if (regexAsStringPattern.test(pattern.trim())) { | ||
// The string looks like RegEx, e.g. "/abc/i" | ||
return (0, _regexpTree.compatTranspile)(pattern).toRegExp(); | ||
} else { | ||
return `/${pattern}/`; | ||
} | ||
} | ||
if (pattern instanceof RegExp) { | ||
return pattern; | ||
} | ||
else if (regexAsStringPattern.test(pattern.trim())) { | ||
// The string looks like RegEx, e.g. "/abc/i" | ||
return regexp_tree_1.compatTranspile(pattern).toRegExp(); | ||
} | ||
else { | ||
return "/" + pattern + "/"; | ||
} | ||
} | ||
exports.toRegExp = toRegExp; | ||
//# sourceMappingURL=pattern.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.default = sort; | ||
var _shuffle = _interopRequireDefault(require("pandemonium/shuffle")); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
exports.__esModule = true; | ||
var shuffle_1 = __importDefault(require("pandemonium/shuffle")); | ||
function sort(items) { | ||
return (0, _shuffle.default)(items); | ||
} | ||
return shuffle_1["default"](items); | ||
} | ||
exports["default"] = sort; | ||
//# sourceMappingURL=fisher-yates-random.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.default = chooseRandomInRange; | ||
exports.__esModule = true; | ||
/** | ||
@@ -14,4 +9,6 @@ * @param min The min value to choose from, inclusive | ||
function chooseRandomInRange(min, max) { | ||
// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random | ||
return Math.floor(Math.random() * (max - min + 1)) + min; | ||
} | ||
// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/random | ||
return Math.floor(Math.random() * (max - min + 1)) + min; | ||
} | ||
exports["default"] = chooseRandomInRange; | ||
//# sourceMappingURL=number-random.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.default = chooseRandomWeight; | ||
var _weightedRandomIndex = _interopRequireDefault(require("pandemonium/weighted-random-index")); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
exports.__esModule = true; | ||
var weighted_random_index_1 = __importDefault(require("pandemonium/weighted-random-index")); | ||
/** | ||
@@ -19,3 +14,5 @@ * Randomly choose from a set of options. Weight the choice by the value of each option. | ||
function chooseRandomWeight(weights) { | ||
return (0, _weightedRandomIndex.default)(weights); | ||
} | ||
return weighted_random_index_1["default"](weights); | ||
} | ||
exports["default"] = chooseRandomWeight; | ||
//# sourceMappingURL=weighted-random.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.default = void 0; | ||
var _escapeStringRegexp = _interopRequireDefault(require("escape-string-regexp")); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
exports.__esModule = true; | ||
var escape_string_regexp_1 = __importDefault(require("escape-string-regexp")); | ||
/** | ||
@@ -17,29 +12,24 @@ * Interpret \#, \##, and \### escape sequences as Octal, not Decimal. | ||
*/ | ||
const decimalCharToSimpleCharTransform = { | ||
Char(charPath) { | ||
const { | ||
node: char | ||
} = charPath; | ||
if (char.kind !== 'decimal') { | ||
return; | ||
var decimalCharToSimpleCharTransform = { | ||
Char: function (charPath) { | ||
var char = charPath.node; | ||
if (char.kind !== 'decimal') { | ||
return; | ||
} | ||
var decimalAsOctal = parseInt(char.codePoint.toString(), 8); | ||
var convertedDecimalAsChar = String.fromCodePoint(decimalAsOctal); | ||
var charEscaped = escape_string_regexp_1["default"](convertedDecimalAsChar); | ||
var simpleChar = { | ||
codePoint: char.codePoint, | ||
kind: 'simple', | ||
symbol: charEscaped, | ||
type: 'Char', | ||
// parse() will reevaluate this value, so update it to something | ||
// that will match as a simple char on the next traversal. | ||
value: charEscaped | ||
}; | ||
charPath.replace(simpleChar); | ||
} | ||
const decimalAsOctal = parseInt(char.codePoint.toString(), 8); | ||
const convertedDecimalAsChar = String.fromCodePoint(decimalAsOctal); | ||
const charEscaped = (0, _escapeStringRegexp.default)(convertedDecimalAsChar); | ||
const simpleChar = { | ||
codePoint: char.codePoint, | ||
kind: 'simple', | ||
symbol: charEscaped, | ||
type: 'Char', | ||
// parse() will reevaluate this value, so update it to something | ||
// that will match as a simple char on the next traversal. | ||
value: charEscaped | ||
}; | ||
charPath.replace(simpleChar); | ||
} | ||
}; | ||
var _default = decimalCharToSimpleCharTransform; | ||
exports.default = _default; | ||
exports["default"] = decimalCharToSimpleCharTransform; | ||
//# sourceMappingURL=decimal-char-to-simple-char-transform.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.default = void 0; | ||
var _decimalCharToSimpleCharTransform = _interopRequireDefault(require("./decimal-char-to-simple-char-transform")); | ||
var _metaToCharClassTransform = _interopRequireDefault(require("./meta-to-char-class-transform")); | ||
var _simpleQuantifierToRangeQuantifierTransform = _interopRequireDefault(require("./simple-quantifier-to-range-quantifier-transform")); | ||
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } | ||
const transforms = [_decimalCharToSimpleCharTransform.default, _metaToCharClassTransform.default, _simpleQuantifierToRangeQuantifierTransform.default]; | ||
var _default = transforms; | ||
exports.default = _default; | ||
var __importDefault = (this && this.__importDefault) || function (mod) { | ||
return (mod && mod.__esModule) ? mod : { "default": mod }; | ||
}; | ||
exports.__esModule = true; | ||
var decimal_char_to_simple_char_transform_1 = __importDefault(require("./decimal-char-to-simple-char-transform")); | ||
var meta_to_char_class_transform_1 = __importDefault(require("./meta-to-char-class-transform")); | ||
var simple_quantifier_to_range_quantifier_transform_1 = __importDefault(require("./simple-quantifier-to-range-quantifier-transform")); | ||
var transforms = [ | ||
decimal_char_to_simple_char_transform_1["default"], | ||
meta_to_char_class_transform_1["default"], | ||
simple_quantifier_to_range_quantifier_transform_1["default"], | ||
]; | ||
exports["default"] = transforms; | ||
//# sourceMappingURL=index.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); | ||
}) : (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
o[k2] = m[k]; | ||
})); | ||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { | ||
Object.defineProperty(o, "default", { enumerable: true, value: v }); | ||
}) : function(o, v) { | ||
o["default"] = v; | ||
}); | ||
exports.default = void 0; | ||
var _constants = require("../constants"); | ||
var Guards = _interopRequireWildcard(require("../types/regexp-tree-guards")); | ||
var _utils = require("./utils"); | ||
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; } | ||
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } | ||
/* eslint no-param-reassign: ["error", { "ignorePropertyModificationsFor": ["parentNode"] }] */ | ||
const replacer = { | ||
Alternative: (parentNode, replacement, child) => { | ||
const iChild = parentNode.expressions.indexOf(child); | ||
if (iChild > -1) { | ||
parentNode.expressions[iChild] = replacement; | ||
var __importStar = (this && this.__importStar) || function (mod) { | ||
if (mod && mod.__esModule) return mod; | ||
var result = {}; | ||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); | ||
__setModuleDefault(result, mod); | ||
return result; | ||
}; | ||
var __read = (this && this.__read) || function (o, n) { | ||
var m = typeof Symbol === "function" && o[Symbol.iterator]; | ||
if (!m) return o; | ||
var i = m.call(o), r, ar = [], e; | ||
try { | ||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); | ||
} | ||
}, | ||
CharacterClass: (parentNode, replacement, child) => { | ||
const iChild = parentNode.expressions.indexOf(child); | ||
if (iChild > -1) { | ||
parentNode.expressions.splice(iChild, 1, ...replacement.expressions); | ||
catch (error) { e = { error: error }; } | ||
finally { | ||
try { | ||
if (r && !r.done && (m = i["return"])) m.call(i); | ||
} | ||
finally { if (e) throw e.error; } | ||
} | ||
}, | ||
Disjunction: (parentNode, replacement, child) => { | ||
if (parentNode.left === child) { | ||
parentNode.left = replacement; | ||
} else if (parentNode.right === child) { | ||
parentNode.right = replacement; | ||
return ar; | ||
}; | ||
var __spreadArray = (this && this.__spreadArray) || function (to, from) { | ||
for (var i = 0, il = from.length, j = to.length; i < il; i++, j++) | ||
to[j] = from[i]; | ||
return to; | ||
}; | ||
exports.__esModule = true; | ||
var constants_1 = require("../constants"); | ||
var Guards = __importStar(require("../types/regexp-tree-guards")); | ||
var utils_1 = require("./utils"); | ||
/* eslint no-param-reassign: ["error", { "ignorePropertyModificationsFor": ["parentNode"] }] */ | ||
var replacer = { | ||
Alternative: function (parentNode, replacement, child) { | ||
var iChild = parentNode.expressions.indexOf(child); | ||
if (iChild > -1) { | ||
parentNode.expressions[iChild] = replacement; | ||
} | ||
}, | ||
CharacterClass: function (parentNode, replacement, child) { | ||
var _a; | ||
var iChild = parentNode.expressions.indexOf(child); | ||
if (iChild > -1) { | ||
(_a = parentNode.expressions).splice.apply(_a, __spreadArray([iChild, 1], __read(replacement.expressions))); | ||
} | ||
}, | ||
Disjunction: function (parentNode, replacement, child) { | ||
if (parentNode.left === child) { | ||
parentNode.left = replacement; | ||
} | ||
else if (parentNode.right === child) { | ||
parentNode.right = replacement; | ||
} | ||
}, | ||
Group: function (parentNode, replacement) { | ||
parentNode.expression = replacement; | ||
}, | ||
RegExp: function (parentNode, replacement) { | ||
parentNode.body = replacement; | ||
}, | ||
Repetition: function (parentNode, replacement) { | ||
parentNode.expression = replacement; | ||
} | ||
}, | ||
Group: (parentNode, replacement) => { | ||
parentNode.expression = replacement; | ||
}, | ||
RegExp: (parentNode, replacement) => { | ||
parentNode.body = replacement; | ||
}, | ||
Repetition: (parentNode, replacement) => { | ||
parentNode.expression = replacement; | ||
} | ||
}; | ||
const optionsAlpha = _constants.Chars.basicAlpha.map(_utils.createSimpleChar); | ||
const optionsDigit = _constants.Chars.digits.map(_utils.createSimpleChar); | ||
const optionsWhitespace = _constants.Chars.whitespace.map(_utils.createSimpleChar); | ||
const needEscape = [']', '-', '\\']; | ||
const noEscape = _constants.Chars.basicSpecial.filter(c => !needEscape.includes(c)); | ||
const optionsOther = [...noEscape.map(_utils.createSimpleChar), ...needEscape.map(_utils.createEscapedSimpleChar)]; | ||
const optionsExtended = _constants.Chars.extended.map(_utils.createSimpleChar); | ||
var optionsAlpha = constants_1.Chars.basicAlpha.map(utils_1.createSimpleChar); | ||
var optionsDigit = constants_1.Chars.digits.map(utils_1.createSimpleChar); | ||
var optionsWhitespace = constants_1.Chars.whitespace.map(utils_1.createSimpleChar); | ||
var needEscape = [']', '-', '\\']; | ||
var noEscape = constants_1.Chars.basicSpecial.filter(function (c) { return !needEscape.includes(c); }); | ||
var optionsOther = __spreadArray(__spreadArray([], __read(noEscape.map(utils_1.createSimpleChar))), __read(needEscape.map(utils_1.createEscapedSimpleChar))); | ||
var optionsExtended = constants_1.Chars.extended.map(utils_1.createSimpleChar); | ||
function getMetaCharExpressions(metaChar, regExpFlags) { | ||
switch (metaChar.value) { | ||
case '.': | ||
{ | ||
const optionsNewLine = (0, _utils.createSimpleChar)('\n'); | ||
const optionsDotAll = regExpFlags.includes('s') ? [optionsNewLine] : []; | ||
const whitespaceNoBreaks = _constants.Chars.whitespace.filter(c => !'\r\n'.includes(c)); | ||
const optionsWhitespaceNoBreak = whitespaceNoBreaks.map(_utils.createSimpleChar); | ||
return [...optionsAlpha, ...optionsDigit, ...optionsWhitespaceNoBreak, ...optionsOther, ...optionsExtended, ...optionsDotAll]; | ||
} | ||
case '\\w': | ||
return [...optionsAlpha, ...optionsDigit]; | ||
case '\\W': | ||
return [...optionsWhitespace, ...optionsOther, ...optionsExtended]; | ||
case '\\d': | ||
return optionsDigit; | ||
case '\\D': | ||
return [...optionsAlpha, ...optionsWhitespace, ...optionsOther, ...optionsExtended]; | ||
case '\\s': | ||
return optionsWhitespace; | ||
case '\\S': | ||
return [...optionsAlpha, ...optionsDigit, ...optionsOther, ...optionsExtended]; | ||
default: | ||
return []; | ||
} | ||
switch (metaChar.value) { | ||
case '.': { | ||
var optionsNewLine = utils_1.createSimpleChar('\n'); | ||
var optionsDotAll = regExpFlags.includes('s') ? [optionsNewLine] : []; | ||
var whitespaceNoBreaks = constants_1.Chars.whitespace.filter(function (c) { return !'\r\n'.includes(c); }); | ||
var optionsWhitespaceNoBreak = whitespaceNoBreaks.map(utils_1.createSimpleChar); | ||
return __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(optionsAlpha)), __read(optionsDigit)), __read(optionsWhitespaceNoBreak)), __read(optionsOther)), __read(optionsExtended)), __read(optionsDotAll)); | ||
} | ||
case '\\w': | ||
return __spreadArray(__spreadArray([], __read(optionsAlpha)), __read(optionsDigit)); | ||
case '\\W': | ||
return __spreadArray(__spreadArray(__spreadArray([], __read(optionsWhitespace)), __read(optionsOther)), __read(optionsExtended)); | ||
case '\\d': | ||
return optionsDigit; | ||
case '\\D': | ||
return __spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(optionsAlpha)), __read(optionsWhitespace)), __read(optionsOther)), __read(optionsExtended)); | ||
case '\\s': | ||
return optionsWhitespace; | ||
case '\\S': | ||
return __spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(optionsAlpha)), __read(optionsDigit)), __read(optionsOther)), __read(optionsExtended)); | ||
default: | ||
return []; | ||
} | ||
} | ||
/** | ||
* Convert meta character classes like "\d", "\W", and "." to their ranged character | ||
* set equivalents like "[0-9]" and "[ \t\r\n~`!@#$%^&*()=+<,>.?/[{}|:;"'\]\-\\]". | ||
*/ | ||
const metaToCharClassTransform = { | ||
flags: '', | ||
init(ast) { | ||
this.flags = ast.flags; | ||
}, | ||
Char(charPath) { | ||
const { | ||
node: char, | ||
parent, | ||
parentPath | ||
} = charPath; | ||
if (!parent || !parentPath || !replacer[parent.type]) { | ||
return; | ||
var metaToCharClassTransform = { | ||
flags: '', | ||
init: function (ast) { | ||
this.flags = ast.flags; | ||
}, | ||
Char: function (charPath) { | ||
var char = charPath.node, parent = charPath.parent, parentPath = charPath.parentPath; | ||
if (!parent || !parentPath || !replacer[parent.type]) { | ||
return; | ||
} | ||
if (!Guards.isMetaChar(char)) { | ||
return; | ||
} | ||
var charClassExpressions = getMetaCharExpressions(char, this.flags); | ||
if (!charClassExpressions.length) { | ||
return; | ||
} | ||
var characterClass = { | ||
expressions: charClassExpressions, | ||
type: 'CharacterClass' | ||
}; | ||
var replaceParent = replacer[parent.type]; | ||
replaceParent(parentPath.node, characterClass, char); | ||
} | ||
if (!Guards.isMetaChar(char)) { | ||
return; | ||
} | ||
const charClassExpressions = getMetaCharExpressions(char, this.flags); | ||
if (!charClassExpressions.length) { | ||
return; | ||
} | ||
const characterClass = { | ||
expressions: charClassExpressions, | ||
type: 'CharacterClass' | ||
}; | ||
const replaceParent = replacer[parent.type]; | ||
replaceParent(parentPath.node, characterClass, char); | ||
} | ||
}; | ||
var _default = metaToCharClassTransform; | ||
exports.default = _default; | ||
exports["default"] = metaToCharClassTransform; | ||
//# sourceMappingURL=meta-to-char-class-transform.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } }); | ||
}) : (function(o, m, k, k2) { | ||
if (k2 === undefined) k2 = k; | ||
o[k2] = m[k]; | ||
})); | ||
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { | ||
Object.defineProperty(o, "default", { enumerable: true, value: v }); | ||
}) : function(o, v) { | ||
o["default"] = v; | ||
}); | ||
exports.default = void 0; | ||
var Guards = _interopRequireWildcard(require("../types/regexp-tree-guards")); | ||
function _getRequireWildcardCache() { if (typeof WeakMap !== "function") return null; var cache = new WeakMap(); _getRequireWildcardCache = function () { return cache; }; return cache; } | ||
function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; } | ||
var __importStar = (this && this.__importStar) || function (mod) { | ||
if (mod && mod.__esModule) return mod; | ||
var result = {}; | ||
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); | ||
__setModuleDefault(result, mod); | ||
return result; | ||
}; | ||
var __read = (this && this.__read) || function (o, n) { | ||
var m = typeof Symbol === "function" && o[Symbol.iterator]; | ||
if (!m) return o; | ||
var i = m.call(o), r, ar = [], e; | ||
try { | ||
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value); | ||
} | ||
catch (error) { e = { error: error }; } | ||
finally { | ||
try { | ||
if (r && !r.done && (m = i["return"])) m.call(i); | ||
} | ||
finally { if (e) throw e.error; } | ||
} | ||
return ar; | ||
}; | ||
exports.__esModule = true; | ||
var Guards = __importStar(require("../types/regexp-tree-guards")); | ||
/* istanbul ignore next */ | ||
function assertNever(x) { | ||
throw new Error(`Unexpected quantifier kind: ${x}`); | ||
throw new Error("Unexpected quantifier kind: " + x); | ||
} | ||
function getNumOccurrences(quantifier) { | ||
if (quantifier.kind === '?') { | ||
return [0, 1]; | ||
} else if (quantifier.kind === '+') { | ||
return [1, undefined]; | ||
} else if (quantifier.kind === '*') { | ||
return [0, undefined]; | ||
} | ||
/* istanbul ignore next */ | ||
return assertNever(quantifier.kind); | ||
if (quantifier.kind === '?') { | ||
return [0, 1]; | ||
} | ||
else if (quantifier.kind === '+') { | ||
return [1, undefined]; | ||
} | ||
else if (quantifier.kind === '*') { | ||
return [0, undefined]; | ||
} | ||
/* istanbul ignore next */ | ||
return assertNever(quantifier.kind); | ||
} | ||
@@ -36,27 +60,20 @@ /** | ||
*/ | ||
const simpleQuantifierToRangeQuantifierTransform = { | ||
Quantifier(quantifierPath) { | ||
const { | ||
node: quantifier | ||
} = quantifierPath; | ||
if (!Guards.isSimpleQuantifier(quantifier)) { | ||
return; | ||
var simpleQuantifierToRangeQuantifierTransform = { | ||
Quantifier: function (quantifierPath) { | ||
var quantifier = quantifierPath.node; | ||
if (!Guards.isSimpleQuantifier(quantifier)) { | ||
return; | ||
} | ||
var _a = __read(getNumOccurrences(quantifier), 2), minOccurrences = _a[0], maxOccurrences = _a[1]; | ||
var equivalentRangeQuantifier = { | ||
from: minOccurrences, | ||
greedy: quantifier.greedy, | ||
kind: 'Range', | ||
to: maxOccurrences, | ||
type: 'Quantifier' | ||
}; | ||
quantifierPath.replace(equivalentRangeQuantifier); | ||
} | ||
const [minOccurrences, maxOccurrences] = getNumOccurrences(quantifier); | ||
const equivalentRangeQuantifier = { | ||
from: minOccurrences, | ||
greedy: quantifier.greedy, | ||
kind: 'Range', | ||
to: maxOccurrences, | ||
type: 'Quantifier' | ||
}; | ||
quantifierPath.replace(equivalentRangeQuantifier); | ||
} | ||
}; | ||
var _default = simpleQuantifierToRangeQuantifierTransform; | ||
exports.default = _default; | ||
exports["default"] = simpleQuantifierToRangeQuantifierTransform; | ||
//# sourceMappingURL=simple-quantifier-to-range-quantifier-transform.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.createSimpleChar = createSimpleChar; | ||
exports.createEscapedSimpleChar = createEscapedSimpleChar; | ||
var __assign = (this && this.__assign) || function () { | ||
__assign = Object.assign || function(t) { | ||
for (var s, i = 1, n = arguments.length; i < n; i++) { | ||
s = arguments[i]; | ||
for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) | ||
t[p] = s[p]; | ||
} | ||
return t; | ||
}; | ||
return __assign.apply(this, arguments); | ||
}; | ||
exports.__esModule = true; | ||
exports.createEscapedSimpleChar = exports.createSimpleChar = void 0; | ||
function createSimpleChar(value) { | ||
if (value.length !== 1) throw new Error('value must be a char'); | ||
return { | ||
codePoint: value.codePointAt(0) || 0, | ||
kind: 'simple', | ||
symbol: value, | ||
type: 'Char', | ||
value | ||
}; | ||
if (value.length !== 1) | ||
throw new Error('value must be a char'); | ||
return { | ||
codePoint: value.codePointAt(0) || 0, | ||
kind: 'simple', | ||
symbol: value, | ||
type: 'Char', | ||
value: value | ||
}; | ||
} | ||
exports.createSimpleChar = createSimpleChar; | ||
function createEscapedSimpleChar(value) { | ||
return { ...createSimpleChar(value), | ||
escaped: true | ||
}; | ||
} | ||
return __assign(__assign({}, createSimpleChar(value)), { escaped: true }); | ||
} | ||
exports.createEscapedSimpleChar = createEscapedSimpleChar; | ||
//# sourceMappingURL=utils.js.map |
"use strict"; | ||
Object.defineProperty(exports, "__esModule", { | ||
value: true | ||
}); | ||
exports.isAlternative = isAlternative; | ||
exports.isAssertion = isAssertion; | ||
exports.isBackreference = isBackreference; | ||
exports.isCapturingGroup = isCapturingGroup; | ||
exports.isChar = isChar; | ||
exports.isCharacterClass = isCharacterClass; | ||
exports.isClassRange = isClassRange; | ||
exports.isDisjunction = isDisjunction; | ||
exports.isGroup = isGroup; | ||
exports.isNamedBackreference = isNamedBackreference; | ||
exports.isNumericBackreference = isNumericBackreference; | ||
exports.isMetaChar = isMetaChar; | ||
exports.isRangeQuantifier = isRangeQuantifier; | ||
exports.isRepetition = isRepetition; | ||
exports.isSimpleChar = isSimpleChar; | ||
exports.isSimpleQuantifier = isSimpleQuantifier; | ||
exports.__esModule = true; | ||
exports.isSimpleQuantifier = exports.isSimpleChar = exports.isRepetition = exports.isRangeQuantifier = exports.isMetaChar = exports.isNumericBackreference = exports.isNamedBackreference = exports.isGroup = exports.isDisjunction = exports.isClassRange = exports.isCharacterClass = exports.isChar = exports.isCapturingGroup = exports.isBackreference = exports.isAssertion = exports.isAlternative = void 0; | ||
function isAlternative(node) { | ||
return node.type === 'Alternative'; | ||
return node.type === 'Alternative'; | ||
} | ||
exports.isAlternative = isAlternative; | ||
function isAssertion(node) { | ||
return node.type === 'Assertion'; | ||
return node.type === 'Assertion'; | ||
} | ||
exports.isAssertion = isAssertion; | ||
function isBackreference(node) { | ||
return node.type === 'Backreference'; | ||
return node.type === 'Backreference'; | ||
} | ||
exports.isBackreference = isBackreference; | ||
function isCapturingGroup(node) { | ||
return node.capturing; | ||
return node.capturing; | ||
} | ||
exports.isCapturingGroup = isCapturingGroup; | ||
function isChar(node) { | ||
return node.type === 'Char'; | ||
return node.type === 'Char'; | ||
} | ||
exports.isChar = isChar; | ||
function isCharacterClass(node) { | ||
return node.type === 'CharacterClass'; | ||
return node.type === 'CharacterClass'; | ||
} | ||
exports.isCharacterClass = isCharacterClass; | ||
function isClassRange(node) { | ||
return node.type === 'ClassRange'; | ||
return node.type === 'ClassRange'; | ||
} | ||
exports.isClassRange = isClassRange; | ||
function isDisjunction(node) { | ||
return node.type === 'Disjunction'; | ||
return node.type === 'Disjunction'; | ||
} | ||
exports.isDisjunction = isDisjunction; | ||
function isGroup(node) { | ||
return node.type === 'Group'; | ||
return node.type === 'Group'; | ||
} | ||
exports.isGroup = isGroup; | ||
function isNamedBackreference(node) { | ||
return node.kind === 'name'; | ||
return node.kind === 'name'; | ||
} | ||
exports.isNamedBackreference = isNamedBackreference; | ||
function isNumericBackreference(node) { | ||
return node.kind === 'number'; | ||
return node.kind === 'number'; | ||
} | ||
exports.isNumericBackreference = isNumericBackreference; | ||
function isMetaChar(char) { | ||
return char.kind === 'meta'; | ||
return char.kind === 'meta'; | ||
} | ||
exports.isMetaChar = isMetaChar; | ||
function isRangeQuantifier(quantifier) { | ||
return quantifier.kind === 'Range'; | ||
return quantifier.kind === 'Range'; | ||
} | ||
exports.isRangeQuantifier = isRangeQuantifier; | ||
function isRepetition(node) { | ||
return node.type === 'Repetition'; | ||
return node.type === 'Repetition'; | ||
} | ||
exports.isRepetition = isRepetition; | ||
function isSimpleChar(char) { | ||
return char.kind === 'simple'; | ||
return char.kind === 'simple'; | ||
} | ||
exports.isSimpleChar = isSimpleChar; | ||
function isSimpleQuantifier(quantifier) { | ||
return ['+', '*', '?'].includes(quantifier.kind); | ||
} | ||
return ['+', '*', '?'].includes(quantifier.kind); | ||
} | ||
exports.isSimpleQuantifier = isSimpleQuantifier; | ||
//# sourceMappingURL=regexp-tree-guards.js.map |
{ | ||
"name": "regex-to-strings", | ||
"version": "2.0.2", | ||
"version": "2.0.3", | ||
"repository": { | ||
@@ -8,2 +8,5 @@ "type": "git", | ||
}, | ||
"publishConfig": { | ||
"registry": "https://registry.npmjs.org/" | ||
}, | ||
"bugs": { | ||
@@ -19,3 +22,5 @@ "url": "https://github.com/wimpyprogrammer/regex-to-strings/issues" | ||
"files": [ | ||
"lib/" | ||
"lib/**/*.js", | ||
"lib/**/*.js.map", | ||
"lib/**/*.d.ts" | ||
], | ||
@@ -31,20 +36,11 @@ "sideEffects": [ | ||
"build": "run-s build:*", | ||
"build:src": "babel src -d lib --extensions '.js,.ts' --ignore '**/*.spec.js','**/*.spec.ts' --delete-dir-on-start", | ||
"build:src": "tsc -b --clean && tsc -b", | ||
"build:demo": "wp --config demo/webpack.config.js", | ||
"build:types": "tsc --noEmit false --emitDeclarationOnly", | ||
"format": "prettier --write '{src,demo/src}/**'", | ||
"lint": "tsc -b && eslint . --report-unused-disable-directives", | ||
"lint": "tsc -b ./tsconfig.lint.json && eslint . --report-unused-disable-directives", | ||
"precommit": "pretty-quick --staged", | ||
"prepublish": "npx publish-please guard", | ||
"publish-please": "npx publish-please", | ||
"publish-please-prereqs": "npm run lint && npm run test && npm run build", | ||
"release": "npx release-it", | ||
"test": "jest --coverage" | ||
}, | ||
"devDependencies": { | ||
"@babel/cli": "^7.13.10", | ||
"@babel/core": "^7.13.10", | ||
"@babel/plugin-proposal-class-properties": "^7.13.0", | ||
"@babel/preset-env": "^7.13.10", | ||
"@babel/preset-typescript": "^7.13.0", | ||
"@types/escape-string-regexp": "^2.0.1", | ||
"@types/history": "^4.7.3", | ||
@@ -51,0 +47,0 @@ "@types/jest": "^26.0.10", |
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Major refactor
Supply chain riskPackage has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.
Found 1 instance in 1 package
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
105952
30
68
1660
1