{"remainingRequest":"/data/node_modules/babel-loader/lib/index.js!/data/node_modules/ip-address/lib/v6/regular-expressions.js","dependencies":[{"path":"/data/node_modules/ip-address/lib/v6/regular-expressions.js","mtime":1553611387684},{"path":"/data/.babelrc","mtime":1553611371556},{"path":"/data/node_modules/cache-loader/dist/cjs.js","mtime":1553611387012},{"path":"/data/node_modules/babel-loader/lib/index.js","mtime":1553611386992}],"contextDependencies":[],"result":["'use strict';\n\nvar sprintf = require('sprintf-js').sprintf;\n\nvar v6 = require('./constants.js');\n\nfunction groupPossibilities(possibilities) {\n  return sprintf('(%s)', possibilities.join('|'));\n}\n\nfunction padGroup(group) {\n  if (group.length < 4) {\n    return sprintf('0{0,%d}%s', 4 - group.length, group);\n  }\n\n  return group;\n}\n\nfunction simpleRegularExpression(groups) {\n  var zeroIndexes = [];\n\n  groups.forEach(function (group, i) {\n    var groupInteger = parseInt(group, 16);\n\n    if (groupInteger === 0) {\n      zeroIndexes.push(i);\n    }\n  });\n\n  // You can technically elide a single 0, this creates the regular expressions\n  // to match that eventuality\n  var possibilities = zeroIndexes.map(function (zeroIndex) {\n    return groups.map(function (group, i) {\n      if (i === zeroIndex) {\n        var elision = i === 0 || i === v6.GROUPS - 1 ? ':' : '';\n\n        return groupPossibilities([padGroup(group), elision]);\n      }\n\n      return padGroup(group);\n    }).join(':');\n  });\n\n  // The simplest case\n  possibilities.push(groups.map(padGroup).join(':'));\n\n  return groupPossibilities(possibilities);\n}\n\nfunction possibleElisions(elidedGroups, moreLeft, moreRight) {\n  var left = moreLeft ? '' : ':';\n  var right = moreRight ? '' : ':';\n\n  var possibilities = [];\n\n  // 1. elision of everything (::)\n  if (!moreLeft && !moreRight) {\n    possibilities.push('::');\n  }\n\n  // 2. complete elision of the middle\n  if (moreLeft && moreRight) {\n    possibilities.push('');\n  }\n\n  if (moreRight && !moreLeft || !moreRight && moreLeft) {\n    // 3. complete elision of one side\n    possibilities.push(':');\n  }\n\n  // 4. elision from the left side\n  possibilities.push(sprintf('%s(:0{1,4}){1,%d}', left, elidedGroups - 1));\n\n  // 5. elision from the right side\n  possibilities.push(sprintf('(0{1,4}:){1,%d}%s', elidedGroups - 1, right));\n\n  // 6. no elision\n  possibilities.push(sprintf('(0{1,4}:){%d}0{1,4}', elidedGroups - 1));\n\n  // 7. elision (including sloppy elision) from the middle\n  for (var groups = 1; groups < elidedGroups - 1; groups++) {\n    for (var position = 1; position < elidedGroups - groups; position++) {\n      possibilities.push(sprintf('(0{1,4}:){%d}:(0{1,4}:){%d}0{1,4}', position, elidedGroups - position - groups - 1));\n    }\n  }\n\n  return groupPossibilities(possibilities);\n}\n\n/**\n * Generate a regular expression string that can be used to find or validate\n * all variations of this address\n * @memberof Address6\n * @instance\n * @param {string} optionalSubString\n * @returns {string}\n */\nexports.regularExpressionString = function (optionalSubString) {\n  if (optionalSubString === undefined) {\n    optionalSubString = false;\n  }\n\n  var output = [];\n\n  // TODO: revisit why this is necessary\n  var address6 = new this.constructor(this.correctForm());\n\n  if (address6.elidedGroups === 0) {\n    // The simple case\n    output.push(simpleRegularExpression(address6.parsedAddress));\n  } else if (address6.elidedGroups === v6.GROUPS) {\n    // A completely elided address\n    output.push(possibleElisions(v6.GROUPS));\n  } else {\n    // A partially elided address\n    var halves = address6.address.split('::');\n\n    if (halves[0].length) {\n      output.push(simpleRegularExpression(halves[0].split(':')));\n    }\n\n    output.push(possibleElisions(address6.elidedGroups, halves[0].length !== 0, halves[1].length !== 0));\n\n    if (halves[1].length) {\n      output.push(simpleRegularExpression(halves[1].split(':')));\n    }\n\n    output = [output.join(':')];\n  }\n\n  if (!optionalSubString) {\n    output = [].concat('(?=^|\\\\b|[^\\\\w\\\\:])(', output, ')(?=[^\\\\w\\\\:]|\\\\b|$)');\n  }\n\n  return output.join('');\n};\n\n/**\n * Generate a regular expression that can be used to find or validate all\n * variations of this address.\n * @memberof Address6\n * @instance\n * @param {string} optionalSubString\n * @returns {RegExp}\n */\nexports.regularExpression = function (optionalSubstring) {\n  return new RegExp(this.regularExpressionString(optionalSubstring), 'i');\n};",{"version":3,"sources":["node_modules/ip-address/lib/v6/regular-expressions.js"],"names":["sprintf","require","v6","groupPossibilities","possibilities","join","padGroup","group","length","simpleRegularExpression","groups","zeroIndexes","forEach","i","groupInteger","parseInt","push","map","zeroIndex","elision","GROUPS","possibleElisions","elidedGroups","moreLeft","moreRight","left","right","position","exports","regularExpressionString","optionalSubString","undefined","output","address6","constructor","correctForm","parsedAddress","halves","address","split","concat","regularExpression","optionalSubstring","RegExp"],"mappings":"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","file":"regular-expressions.js","sourceRoot":"/data","sourcesContent":["'use strict';\n\nvar sprintf = require('sprintf-js').sprintf;\n\nvar v6 = require('./constants.js');\n\nfunction groupPossibilities(possibilities) {\n  return sprintf('(%s)', possibilities.join('|'));\n}\n\nfunction padGroup(group) {\n  if (group.length < 4) {\n    return sprintf('0{0,%d}%s', 4 - group.length, group);\n  }\n\n  return group;\n}\n\nfunction simpleRegularExpression(groups) {\n  var zeroIndexes = [];\n\n  groups.forEach(function (group, i) {\n    var groupInteger = parseInt(group, 16);\n\n    if (groupInteger === 0) {\n      zeroIndexes.push(i);\n    }\n  });\n\n  // You can technically elide a single 0, this creates the regular expressions\n  // to match that eventuality\n  var possibilities = zeroIndexes.map(function (zeroIndex) {\n    return groups.map(function (group, i) {\n      if (i === zeroIndex) {\n        var elision = (i === 0 || i === v6.GROUPS - 1) ? ':' : '';\n\n        return groupPossibilities([padGroup(group), elision]);\n      }\n\n      return padGroup(group);\n    }).join(':');\n  });\n\n  // The simplest case\n  possibilities.push(groups.map(padGroup).join(':'));\n\n  return groupPossibilities(possibilities);\n}\n\nfunction possibleElisions(elidedGroups, moreLeft, moreRight) {\n  var left = moreLeft ? '' : ':';\n  var right = moreRight ? '' : ':';\n\n  var possibilities = [];\n\n  // 1. elision of everything (::)\n  if (!moreLeft && !moreRight) {\n    possibilities.push('::');\n  }\n\n  // 2. complete elision of the middle\n  if (moreLeft && moreRight) {\n    possibilities.push('');\n  }\n\n  if ((moreRight && !moreLeft) || (!moreRight && moreLeft)) {\n    // 3. complete elision of one side\n    possibilities.push(':');\n  }\n\n  // 4. elision from the left side\n  possibilities.push(sprintf('%s(:0{1,4}){1,%d}', left, elidedGroups - 1));\n\n  // 5. elision from the right side\n  possibilities.push(sprintf('(0{1,4}:){1,%d}%s', elidedGroups - 1, right));\n\n  // 6. no elision\n  possibilities.push(sprintf('(0{1,4}:){%d}0{1,4}', elidedGroups - 1));\n\n  // 7. elision (including sloppy elision) from the middle\n  for (var groups = 1; groups < elidedGroups - 1; groups++) {\n    for (var position = 1; position < elidedGroups - groups; position++) {\n      possibilities.push(sprintf('(0{1,4}:){%d}:(0{1,4}:){%d}0{1,4}',\n                                 position,\n                                 elidedGroups - position - groups - 1));\n    }\n  }\n\n  return groupPossibilities(possibilities);\n}\n\n/**\n * Generate a regular expression string that can be used to find or validate\n * all variations of this address\n * @memberof Address6\n * @instance\n * @param {string} optionalSubString\n * @returns {string}\n */\nexports.regularExpressionString = function (optionalSubString) {\n  if (optionalSubString === undefined) {\n    optionalSubString = false;\n  }\n\n  var output = [];\n\n  // TODO: revisit why this is necessary\n  var address6 = new this.constructor(this.correctForm());\n\n  if (address6.elidedGroups === 0) {\n    // The simple case\n    output.push(simpleRegularExpression(address6.parsedAddress));\n  } else if (address6.elidedGroups === v6.GROUPS) {\n    // A completely elided address\n    output.push(possibleElisions(v6.GROUPS));\n  } else {\n    // A partially elided address\n    var halves = address6.address.split('::');\n\n    if (halves[0].length) {\n      output.push(simpleRegularExpression(halves[0].split(':')));\n    }\n\n    output.push(possibleElisions(address6.elidedGroups,\n                         halves[0].length !== 0,\n                         halves[1].length !== 0));\n\n    if (halves[1].length) {\n      output.push(simpleRegularExpression(halves[1].split(':')));\n    }\n\n    output = [output.join(':')];\n  }\n\n  if (!optionalSubString) {\n    output = [].concat('(?=^|\\\\b|[^\\\\w\\\\:])(', output, ')(?=[^\\\\w\\\\:]|\\\\b|$)');\n  }\n\n  return output.join('');\n};\n\n/**\n * Generate a regular expression that can be used to find or validate all\n * variations of this address.\n * @memberof Address6\n * @instance\n * @param {string} optionalSubString\n * @returns {RegExp}\n */\nexports.regularExpression = function (optionalSubstring) {\n  return new RegExp(this.regularExpressionString(optionalSubstring), 'i');\n};\n"]}]}