create-packer 1.34.4 → 1.34.6

package/template/lib/react/node_modules/eslint-plugin-import/lib/rules/order.js

@@ -0,0 +1,785 @@
+'use strict';var _slicedToArray = function () {function sliceIterator(arr, i) {var _arr = [];var _n = true;var _d = false;var _e = undefined;try {for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {_arr.push(_s.value);if (i && _arr.length === i) break;}} catch (err) {_d = true;_e = err;} finally {try {if (!_n && _i["return"]) _i["return"]();} finally {if (_d) throw _e;}}return _arr;}return function (arr, i) {if (Array.isArray(arr)) {return arr;} else if (Symbol.iterator in Object(arr)) {return sliceIterator(arr, i);} else {throw new TypeError("Invalid attempt to destructure non-iterable instance");}};}();
+
+var _minimatch = require('minimatch');var _minimatch2 = _interopRequireDefault(_minimatch);
+var _arrayIncludes = require('array-includes');var _arrayIncludes2 = _interopRequireDefault(_arrayIncludes);
+var _object = require('object.groupby');var _object2 = _interopRequireDefault(_object);
+
+var _importType = require('../core/importType');var _importType2 = _interopRequireDefault(_importType);
+var _staticRequire = require('../core/staticRequire');var _staticRequire2 = _interopRequireDefault(_staticRequire);
+var _docsUrl = require('../docsUrl');var _docsUrl2 = _interopRequireDefault(_docsUrl);function _interopRequireDefault(obj) {return obj && obj.__esModule ? obj : { 'default': obj };}
+
+var defaultGroups = ['builtin', 'external', 'parent', 'sibling', 'index'];
+
+// REPORTING AND FIXING
+
+function reverse(array) {
+  return array.map(function (v) {
+    return Object.assign({}, v, { rank: -v.rank });
+  }).reverse();
+}
+
+function getTokensOrCommentsAfter(sourceCode, node, count) {
+  var currentNodeOrToken = node;
+  var result = [];
+  for (var i = 0; i < count; i++) {
+    currentNodeOrToken = sourceCode.getTokenOrCommentAfter(currentNodeOrToken);
+    if (currentNodeOrToken == null) {
+      break;
+    }
+    result.push(currentNodeOrToken);
+  }
+  return result;
+}
+
+function getTokensOrCommentsBefore(sourceCode, node, count) {
+  var currentNodeOrToken = node;
+  var result = [];
+  for (var i = 0; i < count; i++) {
+    currentNodeOrToken = sourceCode.getTokenOrCommentBefore(currentNodeOrToken);
+    if (currentNodeOrToken == null) {
+      break;
+    }
+    result.push(currentNodeOrToken);
+  }
+  return result.reverse();
+}
+
+function takeTokensAfterWhile(sourceCode, node, condition) {
+  var tokens = getTokensOrCommentsAfter(sourceCode, node, 100);
+  var result = [];
+  for (var i = 0; i < tokens.length; i++) {
+    if (condition(tokens[i])) {
+      result.push(tokens[i]);
+    } else {
+      break;
+    }
+  }
+  return result;
+}
+
+function takeTokensBeforeWhile(sourceCode, node, condition) {
+  var tokens = getTokensOrCommentsBefore(sourceCode, node, 100);
+  var result = [];
+  for (var i = tokens.length - 1; i >= 0; i--) {
+    if (condition(tokens[i])) {
+      result.push(tokens[i]);
+    } else {
+      break;
+    }
+  }
+  return result.reverse();
+}
+
+function findOutOfOrder(imported) {
+  if (imported.length === 0) {
+    return [];
+  }
+  var maxSeenRankNode = imported[0];
+  return imported.filter(function (importedModule) {
+    var res = importedModule.rank < maxSeenRankNode.rank;
+    if (maxSeenRankNode.rank < importedModule.rank) {
+      maxSeenRankNode = importedModule;
+    }
+    return res;
+  });
+}
+
+function findRootNode(node) {
+  var parent = node;
+  while (parent.parent != null && parent.parent.body == null) {
+    parent = parent.parent;
+  }
+  return parent;
+}
+
+function findEndOfLineWithComments(sourceCode, node) {
+  var tokensToEndOfLine = takeTokensAfterWhile(sourceCode, node, commentOnSameLineAs(node));
+  var endOfTokens = tokensToEndOfLine.length > 0 ?
+  tokensToEndOfLine[tokensToEndOfLine.length - 1].range[1] :
+  node.range[1];
+  var result = endOfTokens;
+  for (var i = endOfTokens; i < sourceCode.text.length; i++) {
+    if (sourceCode.text[i] === '\n') {
+      result = i + 1;
+      break;
+    }
+    if (sourceCode.text[i] !== ' ' && sourceCode.text[i] !== '\t' && sourceCode.text[i] !== '\r') {
+      break;
+    }
+    result = i + 1;
+  }
+  return result;
+}
+
+function commentOnSameLineAs(node) {
+  return function (token) {return (token.type === 'Block' || token.type === 'Line') &&
+    token.loc.start.line === token.loc.end.line &&
+    token.loc.end.line === node.loc.end.line;};
+}
+
+function findStartOfLineWithComments(sourceCode, node) {
+  var tokensToEndOfLine = takeTokensBeforeWhile(sourceCode, node, commentOnSameLineAs(node));
+  var startOfTokens = tokensToEndOfLine.length > 0 ? tokensToEndOfLine[0].range[0] : node.range[0];
+  var result = startOfTokens;
+  for (var i = startOfTokens - 1; i > 0; i--) {
+    if (sourceCode.text[i] !== ' ' && sourceCode.text[i] !== '\t') {
+      break;
+    }
+    result = i;
+  }
+  return result;
+}
+
+function isRequireExpression(expr) {
+  return expr != null &&
+  expr.type === 'CallExpression' &&
+  expr.callee != null &&
+  expr.callee.name === 'require' &&
+  expr.arguments != null &&
+  expr.arguments.length === 1 &&
+  expr.arguments[0].type === 'Literal';
+}
+
+function isSupportedRequireModule(node) {
+  if (node.type !== 'VariableDeclaration') {
+    return false;
+  }
+  if (node.declarations.length !== 1) {
+    return false;
+  }
+  var decl = node.declarations[0];
+  var isPlainRequire = decl.id && (
+  decl.id.type === 'Identifier' || decl.id.type === 'ObjectPattern') &&
+  isRequireExpression(decl.init);
+  var isRequireWithMemberExpression = decl.id && (
+  decl.id.type === 'Identifier' || decl.id.type === 'ObjectPattern') &&
+  decl.init != null &&
+  decl.init.type === 'CallExpression' &&
+  decl.init.callee != null &&
+  decl.init.callee.type === 'MemberExpression' &&
+  isRequireExpression(decl.init.callee.object);
+  return isPlainRequire || isRequireWithMemberExpression;
+}
+
+function isPlainImportModule(node) {
+  return node.type === 'ImportDeclaration' && node.specifiers != null && node.specifiers.length > 0;
+}
+
+function isPlainImportEquals(node) {
+  return node.type === 'TSImportEqualsDeclaration' && node.moduleReference.expression;
+}
+
+function canCrossNodeWhileReorder(node) {
+  return isSupportedRequireModule(node) || isPlainImportModule(node) || isPlainImportEquals(node);
+}
+
+function canReorderItems(firstNode, secondNode) {
+  var parent = firstNode.parent;var _sort =
+  [
+  parent.body.indexOf(firstNode),
+  parent.body.indexOf(secondNode)].
+  sort(),_sort2 = _slicedToArray(_sort, 2),firstIndex = _sort2[0],secondIndex = _sort2[1];
+  var nodesBetween = parent.body.slice(firstIndex, secondIndex + 1);var _iteratorNormalCompletion = true;var _didIteratorError = false;var _iteratorError = undefined;try {
+    for (var _iterator = nodesBetween[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {var nodeBetween = _step.value;
+      if (!canCrossNodeWhileReorder(nodeBetween)) {
+        return false;
+      }
+    }} catch (err) {_didIteratorError = true;_iteratorError = err;} finally {try {if (!_iteratorNormalCompletion && _iterator['return']) {_iterator['return']();}} finally {if (_didIteratorError) {throw _iteratorError;}}}
+  return true;
+}
+
+function makeImportDescription(node) {
+  if (node.node.importKind === 'type') {
+    return 'type import';
+  }
+  if (node.node.importKind === 'typeof') {
+    return 'typeof import';
+  }
+  return 'import';
+}
+
+function fixOutOfOrder(context, firstNode, secondNode, order) {
+  var sourceCode = context.getSourceCode();
+
+  var firstRoot = findRootNode(firstNode.node);
+  var firstRootStart = findStartOfLineWithComments(sourceCode, firstRoot);
+  var firstRootEnd = findEndOfLineWithComments(sourceCode, firstRoot);
+
+  var secondRoot = findRootNode(secondNode.node);
+  var secondRootStart = findStartOfLineWithComments(sourceCode, secondRoot);
+  var secondRootEnd = findEndOfLineWithComments(sourceCode, secondRoot);
+  var canFix = canReorderItems(firstRoot, secondRoot);
+
+  var newCode = sourceCode.text.substring(secondRootStart, secondRootEnd);
+  if (newCode[newCode.length - 1] !== '\n') {
+    newCode = String(newCode) + '\n';
+  }
+
+  var firstImport = String(makeImportDescription(firstNode)) + ' of `' + String(firstNode.displayName) + '`';
+  var secondImport = '`' + String(secondNode.displayName) + '` ' + String(makeImportDescription(secondNode));
+  var message = secondImport + ' should occur ' + String(order) + ' ' + firstImport;
+
+  if (order === 'before') {
+    context.report({
+      node: secondNode.node,
+      message: message,
+      fix: canFix && function (fixer) {return fixer.replaceTextRange(
+        [firstRootStart, secondRootEnd],
+        newCode + sourceCode.text.substring(firstRootStart, secondRootStart));} });
+
+
+  } else if (order === 'after') {
+    context.report({
+      node: secondNode.node,
+      message: message,
+      fix: canFix && function (fixer) {return fixer.replaceTextRange(
+        [secondRootStart, firstRootEnd],
+        sourceCode.text.substring(secondRootEnd, firstRootEnd) + newCode);} });
+
+
+  }
+}
+
+function reportOutOfOrder(context, imported, outOfOrder, order) {
+  outOfOrder.forEach(function (imp) {
+    var found = imported.find(function () {function hasHigherRank(importedItem) {
+        return importedItem.rank > imp.rank;
+      }return hasHigherRank;}());
+    fixOutOfOrder(context, found, imp, order);
+  });
+}
+
+function makeOutOfOrderReport(context, imported) {
+  var outOfOrder = findOutOfOrder(imported);
+  if (!outOfOrder.length) {
+    return;
+  }
+
+  // There are things to report. Try to minimize the number of reported errors.
+  var reversedImported = reverse(imported);
+  var reversedOrder = findOutOfOrder(reversedImported);
+  if (reversedOrder.length < outOfOrder.length) {
+    reportOutOfOrder(context, reversedImported, reversedOrder, 'after');
+    return;
+  }
+  reportOutOfOrder(context, imported, outOfOrder, 'before');
+}
+
+var compareString = function compareString(a, b) {
+  if (a < b) {
+    return -1;
+  }
+  if (a > b) {
+    return 1;
+  }
+  return 0;
+};
+
+/** Some parsers (languages without types) don't provide ImportKind */
+var DEAFULT_IMPORT_KIND = 'value';
+var getNormalizedValue = function getNormalizedValue(node, toLowerCase) {
+  var value = node.value;
+  return toLowerCase ? String(value).toLowerCase() : value;
+};
+
+function getSorter(alphabetizeOptions) {
+  var multiplier = alphabetizeOptions.order === 'asc' ? 1 : -1;
+  var orderImportKind = alphabetizeOptions.orderImportKind;
+  var multiplierImportKind = orderImportKind !== 'ignore' && (
+  alphabetizeOptions.orderImportKind === 'asc' ? 1 : -1);
+
+  return function () {function importsSorter(nodeA, nodeB) {
+      var importA = getNormalizedValue(nodeA, alphabetizeOptions.caseInsensitive);
+      var importB = getNormalizedValue(nodeB, alphabetizeOptions.caseInsensitive);
+      var result = 0;
+
+      if (!(0, _arrayIncludes2['default'])(importA, '/') && !(0, _arrayIncludes2['default'])(importB, '/')) {
+        result = compareString(importA, importB);
+      } else {
+        var A = importA.split('/');
+        var B = importB.split('/');
+        var a = A.length;
+        var b = B.length;
+
+        for (var i = 0; i < Math.min(a, b); i++) {
+          result = compareString(A[i], B[i]);
+          if (result) {break;}
+        }
+
+        if (!result && a !== b) {
+          result = a < b ? -1 : 1;
+        }
+      }
+
+      result = result * multiplier;
+
+      // In case the paths are equal (result === 0), sort them by importKind
+      if (!result && multiplierImportKind) {
+        result = multiplierImportKind * compareString(
+        nodeA.node.importKind || DEAFULT_IMPORT_KIND,
+        nodeB.node.importKind || DEAFULT_IMPORT_KIND);
+
+      }
+
+      return result;
+    }return importsSorter;}();
+}
+
+function mutateRanksToAlphabetize(imported, alphabetizeOptions) {
+  var groupedByRanks = (0, _object2['default'])(imported, function (item) {return item.rank;});
+
+  var sorterFn = getSorter(alphabetizeOptions);
+
+  // sort group keys so that they can be iterated on in order
+  var groupRanks = Object.keys(groupedByRanks).sort(function (a, b) {
+    return a - b;
+  });
+
+  // sort imports locally within their group
+  groupRanks.forEach(function (groupRank) {
+    groupedByRanks[groupRank].sort(sorterFn);
+  });
+
+  // assign globally unique rank to each import
+  var newRank = 0;
+  var alphabetizedRanks = groupRanks.reduce(function (acc, groupRank) {
+    groupedByRanks[groupRank].forEach(function (importedItem) {
+      acc[String(importedItem.value) + '|' + String(importedItem.node.importKind)] = parseInt(groupRank, 10) + newRank;
+      newRank += 1;
+    });
+    return acc;
+  }, {});
+
+  // mutate the original group-rank with alphabetized-rank
+  imported.forEach(function (importedItem) {
+    importedItem.rank = alphabetizedRanks[String(importedItem.value) + '|' + String(importedItem.node.importKind)];
+  });
+}
+
+// DETECTING
+
+function computePathRank(ranks, pathGroups, path, maxPosition) {
+  for (var i = 0, l = pathGroups.length; i < l; i++) {var _pathGroups$i =
+    pathGroups[i],pattern = _pathGroups$i.pattern,patternOptions = _pathGroups$i.patternOptions,group = _pathGroups$i.group,_pathGroups$i$positio = _pathGroups$i.position,position = _pathGroups$i$positio === undefined ? 1 : _pathGroups$i$positio;
+    if ((0, _minimatch2['default'])(path, pattern, patternOptions || { nocomment: true })) {
+      return ranks[group] + position / maxPosition;
+    }
+  }
+}
+
+function computeRank(context, ranks, importEntry, excludedImportTypes) {
+  var impType = void 0;
+  var rank = void 0;
+  if (importEntry.type === 'import:object') {
+    impType = 'object';
+  } else if (importEntry.node.importKind === 'type' && ranks.omittedTypes.indexOf('type') === -1) {
+    impType = 'type';
+  } else {
+    impType = (0, _importType2['default'])(importEntry.value, context);
+  }
+  if (!excludedImportTypes.has(impType)) {
+    rank = computePathRank(ranks.groups, ranks.pathGroups, importEntry.value, ranks.maxPosition);
+  }
+  if (typeof rank === 'undefined') {
+    rank = ranks.groups[impType];
+  }
+  if (importEntry.type !== 'import' && !importEntry.type.startsWith('import:')) {
+    rank += 100;
+  }
+
+  return rank;
+}
+
+function registerNode(context, importEntry, ranks, imported, excludedImportTypes) {
+  var rank = computeRank(context, ranks, importEntry, excludedImportTypes);
+  if (rank !== -1) {
+    imported.push(Object.assign({}, importEntry, { rank: rank }));
+  }
+}
+
+function getRequireBlock(node) {
+  var n = node;
+  // Handle cases like `const baz = require('foo').bar.baz`
+  // and `const foo = require('foo')()`
+  while (
+  n.parent.type === 'MemberExpression' && n.parent.object === n ||
+  n.parent.type === 'CallExpression' && n.parent.callee === n)
+  {
+    n = n.parent;
+  }
+  if (
+  n.parent.type === 'VariableDeclarator' &&
+  n.parent.parent.type === 'VariableDeclaration' &&
+  n.parent.parent.parent.type === 'Program')
+  {
+    return n.parent.parent.parent;
+  }
+}
+
+var types = ['builtin', 'external', 'internal', 'unknown', 'parent', 'sibling', 'index', 'object', 'type'];
+
+// Creates an object with type-rank pairs.
+// Example: { index: 0, sibling: 1, parent: 1, external: 1, builtin: 2, internal: 2 }
+// Will throw an error if it contains a type that does not exist, or has a duplicate
+function convertGroupsToRanks(groups) {
+  var rankObject = groups.reduce(function (res, group, index) {
+    [].concat(group).forEach(function (groupItem) {
+      if (types.indexOf(groupItem) === -1) {
+        throw new Error('Incorrect configuration of the rule: Unknown type `' + String(JSON.stringify(groupItem)) + '`');
+      }
+      if (res[groupItem] !== undefined) {
+        throw new Error('Incorrect configuration of the rule: `' + String(groupItem) + '` is duplicated');
+      }
+      res[groupItem] = index * 2;
+    });
+    return res;
+  }, {});
+
+  var omittedTypes = types.filter(function (type) {
+    return typeof rankObject[type] === 'undefined';
+  });
+
+  var ranks = omittedTypes.reduce(function (res, type) {
+    res[type] = groups.length * 2;
+    return res;
+  }, rankObject);
+
+  return { groups: ranks, omittedTypes: omittedTypes };
+}
+
+function convertPathGroupsForRanks(pathGroups) {
+  var after = {};
+  var before = {};
+
+  var transformed = pathGroups.map(function (pathGroup, index) {var
+    group = pathGroup.group,positionString = pathGroup.position;
+    var position = 0;
+    if (positionString === 'after') {
+      if (!after[group]) {
+        after[group] = 1;
+      }
+      position = after[group]++;
+    } else if (positionString === 'before') {
+      if (!before[group]) {
+        before[group] = [];
+      }
+      before[group].push(index);
+    }
+
+    return Object.assign({}, pathGroup, { position: position });
+  });
+
+  var maxPosition = 1;
+
+  Object.keys(before).forEach(function (group) {
+    var groupLength = before[group].length;
+    before[group].forEach(function (groupIndex, index) {
+      transformed[groupIndex].position = -1 * (groupLength - index);
+    });
+    maxPosition = Math.max(maxPosition, groupLength);
+  });
+
+  Object.keys(after).forEach(function (key) {
+    var groupNextPosition = after[key];
+    maxPosition = Math.max(maxPosition, groupNextPosition - 1);
+  });
+
+  return {
+    pathGroups: transformed,
+    maxPosition: maxPosition > 10 ? Math.pow(10, Math.ceil(Math.log10(maxPosition))) : 10 };
+
+}
+
+function fixNewLineAfterImport(context, previousImport) {
+  var prevRoot = findRootNode(previousImport.node);
+  var tokensToEndOfLine = takeTokensAfterWhile(
+  context.getSourceCode(), prevRoot, commentOnSameLineAs(prevRoot));
+
+  var endOfLine = prevRoot.range[1];
+  if (tokensToEndOfLine.length > 0) {
+    endOfLine = tokensToEndOfLine[tokensToEndOfLine.length - 1].range[1];
+  }
+  return function (fixer) {return fixer.insertTextAfterRange([prevRoot.range[0], endOfLine], '\n');};
+}
+
+function removeNewLineAfterImport(context, currentImport, previousImport) {
+  var sourceCode = context.getSourceCode();
+  var prevRoot = findRootNode(previousImport.node);
+  var currRoot = findRootNode(currentImport.node);
+  var rangeToRemove = [
+  findEndOfLineWithComments(sourceCode, prevRoot),
+  findStartOfLineWithComments(sourceCode, currRoot)];
+
+  if (/^\s*$/.test(sourceCode.text.substring(rangeToRemove[0], rangeToRemove[1]))) {
+    return function (fixer) {return fixer.removeRange(rangeToRemove);};
+  }
+  return undefined;
+}
+
+function makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, distinctGroup) {
+  var getNumberOfEmptyLinesBetween = function getNumberOfEmptyLinesBetween(currentImport, previousImport) {
+    var linesBetweenImports = context.getSourceCode().lines.slice(
+    previousImport.node.loc.end.line,
+    currentImport.node.loc.start.line - 1);
+
+
+    return linesBetweenImports.filter(function (line) {return !line.trim().length;}).length;
+  };
+  var getIsStartOfDistinctGroup = function getIsStartOfDistinctGroup(currentImport, previousImport) {return currentImport.rank - 1 >= previousImport.rank;};
+  var previousImport = imported[0];
+
+  imported.slice(1).forEach(function (currentImport) {
+    var emptyLinesBetween = getNumberOfEmptyLinesBetween(currentImport, previousImport);
+    var isStartOfDistinctGroup = getIsStartOfDistinctGroup(currentImport, previousImport);
+
+    if (newlinesBetweenImports === 'always' ||
+    newlinesBetweenImports === 'always-and-inside-groups') {
+      if (currentImport.rank !== previousImport.rank && emptyLinesBetween === 0) {
+        if (distinctGroup || !distinctGroup && isStartOfDistinctGroup) {
+          context.report({
+            node: previousImport.node,
+            message: 'There should be at least one empty line between import groups',
+            fix: fixNewLineAfterImport(context, previousImport) });
+
+        }
+      } else if (emptyLinesBetween > 0 &&
+      newlinesBetweenImports !== 'always-and-inside-groups') {
+        if (distinctGroup && currentImport.rank === previousImport.rank || !distinctGroup && !isStartOfDistinctGroup) {
+          context.report({
+            node: previousImport.node,
+            message: 'There should be no empty line within import group',
+            fix: removeNewLineAfterImport(context, currentImport, previousImport) });
+
+        }
+      }
+    } else if (emptyLinesBetween > 0) {
+      context.report({
+        node: previousImport.node,
+        message: 'There should be no empty line between import groups',
+        fix: removeNewLineAfterImport(context, currentImport, previousImport) });
+
+    }
+
+    previousImport = currentImport;
+  });
+}
+
+function getAlphabetizeConfig(options) {
+  var alphabetize = options.alphabetize || {};
+  var order = alphabetize.order || 'ignore';
+  var orderImportKind = alphabetize.orderImportKind || 'ignore';
+  var caseInsensitive = alphabetize.caseInsensitive || false;
+
+  return { order: order, orderImportKind: orderImportKind, caseInsensitive: caseInsensitive };
+}
+
+// TODO, semver-major: Change the default of "distinctGroup" from true to false
+var defaultDistinctGroup = true;
+
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      category: 'Style guide',
+      description: 'Enforce a convention in module import order.',
+      url: (0, _docsUrl2['default'])('order') },
+
+
+    fixable: 'code',
+    schema: [
+    {
+      type: 'object',
+      properties: {
+        groups: {
+          type: 'array' },
+
+        pathGroupsExcludedImportTypes: {
+          type: 'array' },
+
+        distinctGroup: {
+          type: 'boolean',
+          'default': defaultDistinctGroup },
+
+        pathGroups: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              pattern: {
+                type: 'string' },
+
+              patternOptions: {
+                type: 'object' },
+
+              group: {
+                type: 'string',
+                'enum': types },
+
+              position: {
+                type: 'string',
+                'enum': ['after', 'before'] } },
+
+
+            additionalProperties: false,
+            required: ['pattern', 'group'] } },
+
+
+        'newlines-between': {
+          'enum': [
+          'ignore',
+          'always',
+          'always-and-inside-groups',
+          'never'] },
+
+
+        alphabetize: {
+          type: 'object',
+          properties: {
+            caseInsensitive: {
+              type: 'boolean',
+              'default': false },
+
+            order: {
+              'enum': ['ignore', 'asc', 'desc'],
+              'default': 'ignore' },
+
+            orderImportKind: {
+              'enum': ['ignore', 'asc', 'desc'],
+              'default': 'ignore' } },
+
+
+          additionalProperties: false },
+
+        warnOnUnassignedImports: {
+          type: 'boolean',
+          'default': false } },
+
+
+      additionalProperties: false }] },
+
+
+
+
+  create: function () {function importOrderRule(context) {
+      var options = context.options[0] || {};
+      var newlinesBetweenImports = options['newlines-between'] || 'ignore';
+      var pathGroupsExcludedImportTypes = new Set(options.pathGroupsExcludedImportTypes || ['builtin', 'external', 'object']);
+      var alphabetize = getAlphabetizeConfig(options);
+      var distinctGroup = options.distinctGroup == null ? defaultDistinctGroup : !!options.distinctGroup;
+      var ranks = void 0;
+
+      try {var _convertPathGroupsFor =
+        convertPathGroupsForRanks(options.pathGroups || []),pathGroups = _convertPathGroupsFor.pathGroups,maxPosition = _convertPathGroupsFor.maxPosition;var _convertGroupsToRanks =
+        convertGroupsToRanks(options.groups || defaultGroups),groups = _convertGroupsToRanks.groups,omittedTypes = _convertGroupsToRanks.omittedTypes;
+        ranks = {
+          groups: groups,
+          omittedTypes: omittedTypes,
+          pathGroups: pathGroups,
+          maxPosition: maxPosition };
+
+      } catch (error) {
+        // Malformed configuration
+        return {
+          Program: function () {function Program(node) {
+              context.report(node, error.message);
+            }return Program;}() };
+
+      }
+      var importMap = new Map();
+
+      function getBlockImports(node) {
+        if (!importMap.has(node)) {
+          importMap.set(node, []);
+        }
+        return importMap.get(node);
+      }
+
+      return {
+        ImportDeclaration: function () {function handleImports(node) {
+            // Ignoring unassigned imports unless warnOnUnassignedImports is set
+            if (node.specifiers.length || options.warnOnUnassignedImports) {
+              var name = node.source.value;
+              registerNode(
+              context,
+              {
+                node: node,
+                value: name,
+                displayName: name,
+                type: 'import' },
+
+              ranks,
+              getBlockImports(node.parent),
+              pathGroupsExcludedImportTypes);
+
+            }
+          }return handleImports;}(),
+        TSImportEqualsDeclaration: function () {function handleImports(node) {
+            var displayName = void 0;
+            var value = void 0;
+            var type = void 0;
+            // skip "export import"s
+            if (node.isExport) {
+              return;
+            }
+            if (node.moduleReference.type === 'TSExternalModuleReference') {
+              value = node.moduleReference.expression.value;
+              displayName = value;
+              type = 'import';
+            } else {
+              value = '';
+              displayName = context.getSourceCode().getText(node.moduleReference);
+              type = 'import:object';
+            }
+            registerNode(
+            context,
+            {
+              node: node,
+              value: value,
+              displayName: displayName,
+              type: type },
+
+            ranks,
+            getBlockImports(node.parent),
+            pathGroupsExcludedImportTypes);
+
+          }return handleImports;}(),
+        CallExpression: function () {function handleRequires(node) {
+            if (!(0, _staticRequire2['default'])(node)) {
+              return;
+            }
+            var block = getRequireBlock(node);
+            if (!block) {
+              return;
+            }
+            var name = node.arguments[0].value;
+            registerNode(
+            context,
+            {
+              node: node,
+              value: name,
+              displayName: name,
+              type: 'require' },
+
+            ranks,
+            getBlockImports(block),
+            pathGroupsExcludedImportTypes);
+
+          }return handleRequires;}(),
+        'Program:exit': function () {function reportAndReset() {
+            importMap.forEach(function (imported) {
+              if (newlinesBetweenImports !== 'ignore') {
+                makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, distinctGroup);
+              }
+
+              if (alphabetize.order !== 'ignore') {
+                mutateRanksToAlphabetize(imported, alphabetize);
+              }
+
+              makeOutOfOrderReport(context, imported);
+            });
+
+            importMap.clear();
+          }return reportAndReset;}() };
+
+    }return importOrderRule;}() };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/rules/order.js"],"names":["defaultGroups","reverse","array","map","v","rank","getTokensOrCommentsAfter","sourceCode","node","count","currentNodeOrToken","result","i","getTokenOrCommentAfter","push","getTokensOrCommentsBefore","getTokenOrCommentBefore","takeTokensAfterWhile","condition","tokens","length","takeTokensBeforeWhile","findOutOfOrder","imported","maxSeenRankNode","filter","importedModule","res","findRootNode","parent","body","findEndOfLineWithComments","tokensToEndOfLine","commentOnSameLineAs","endOfTokens","range","text","token","type","loc","start","line","end","findStartOfLineWithComments","startOfTokens","isRequireExpression","expr","callee","name","arguments","isSupportedRequireModule","declarations","decl","isPlainRequire","id","init","isRequireWithMemberExpression","object","isPlainImportModule","specifiers","isPlainImportEquals","moduleReference","expression","canCrossNodeWhileReorder","canReorderItems","firstNode","secondNode","indexOf","sort","firstIndex","secondIndex","nodesBetween","slice","nodeBetween","makeImportDescription","importKind","fixOutOfOrder","context","order","getSourceCode","firstRoot","firstRootStart","firstRootEnd","secondRoot","secondRootStart","secondRootEnd","canFix","newCode","substring","firstImport","displayName","secondImport","message","report","fix","fixer","replaceTextRange","reportOutOfOrder","outOfOrder","forEach","imp","found","find","hasHigherRank","importedItem","makeOutOfOrderReport","reversedImported","reversedOrder","compareString","a","b","DEAFULT_IMPORT_KIND","getNormalizedValue","toLowerCase","value","String","getSorter","alphabetizeOptions","multiplier","orderImportKind","multiplierImportKind","importsSorter","nodeA","nodeB","importA","caseInsensitive","importB","A","split","B","Math","min","mutateRanksToAlphabetize","groupedByRanks","item","sorterFn","groupRanks","Object","keys","groupRank","newRank","alphabetizedRanks","reduce","acc","parseInt","computePathRank","ranks","pathGroups","path","maxPosition","l","pattern","patternOptions","group","position","nocomment","computeRank","importEntry","excludedImportTypes","impType","omittedTypes","has","groups","startsWith","registerNode","getRequireBlock","n","types","convertGroupsToRanks","rankObject","index","concat","groupItem","Error","JSON","stringify","undefined","convertPathGroupsForRanks","after","before","transformed","pathGroup","positionString","groupLength","groupIndex","max","key","groupNextPosition","pow","ceil","log10","fixNewLineAfterImport","previousImport","prevRoot","endOfLine","insertTextAfterRange","removeNewLineAfterImport","currentImport","currRoot","rangeToRemove","test","removeRange","makeNewlinesBetweenReport","newlinesBetweenImports","distinctGroup","getNumberOfEmptyLinesBetween","linesBetweenImports","lines","trim","getIsStartOfDistinctGroup","emptyLinesBetween","isStartOfDistinctGroup","getAlphabetizeConfig","options","alphabetize","defaultDistinctGroup","module","exports","meta","docs","category","description","url","fixable","schema","properties","pathGroupsExcludedImportTypes","items","additionalProperties","required","warnOnUnassignedImports","create","importOrderRule","Set","error","Program","importMap","Map","getBlockImports","set","get","ImportDeclaration","handleImports","source","TSImportEqualsDeclaration","isExport","getText","CallExpression","handleRequires","block","reportAndReset","clear"],"mappings":"AAAA,a;;AAEA,sC;AACA,+C;AACA,wC;;AAEA,gD;AACA,sD;AACA,qC;;AAEA,IAAMA,gBAAgB,CAAC,SAAD,EAAY,UAAZ,EAAwB,QAAxB,EAAkC,SAAlC,EAA6C,OAA7C,CAAtB;;AAEA;;AAEA,SAASC,OAAT,CAAiBC,KAAjB,EAAwB;AACtB,SAAOA,MAAMC,GAAN,CAAU,UAAUC,CAAV,EAAa;AAC5B,6BAAYA,CAAZ,IAAeC,MAAM,CAACD,EAAEC,IAAxB;AACD,GAFM,EAEJJ,OAFI,EAAP;AAGD;;AAED,SAASK,wBAAT,CAAkCC,UAAlC,EAA8CC,IAA9C,EAAoDC,KAApD,EAA2D;AACzD,MAAIC,qBAAqBF,IAAzB;AACA,MAAMG,SAAS,EAAf;AACA,OAAK,IAAIC,IAAI,CAAb,EAAgBA,IAAIH,KAApB,EAA2BG,GAA3B,EAAgC;AAC9BF,yBAAqBH,WAAWM,sBAAX,CAAkCH,kBAAlC,CAArB;AACA,QAAIA,sBAAsB,IAA1B,EAAgC;AAC9B;AACD;AACDC,WAAOG,IAAP,CAAYJ,kBAAZ;AACD;AACD,SAAOC,MAAP;AACD;;AAED,SAASI,yBAAT,CAAmCR,UAAnC,EAA+CC,IAA/C,EAAqDC,KAArD,EAA4D;AAC1D,MAAIC,qBAAqBF,IAAzB;AACA,MAAMG,SAAS,EAAf;AACA,OAAK,IAAIC,IAAI,CAAb,EAAgBA,IAAIH,KAApB,EAA2BG,GAA3B,EAAgC;AAC9BF,yBAAqBH,WAAWS,uBAAX,CAAmCN,kBAAnC,CAArB;AACA,QAAIA,sBAAsB,IAA1B,EAAgC;AAC9B;AACD;AACDC,WAAOG,IAAP,CAAYJ,kBAAZ;AACD;AACD,SAAOC,OAAOV,OAAP,EAAP;AACD;;AAED,SAASgB,oBAAT,CAA8BV,UAA9B,EAA0CC,IAA1C,EAAgDU,SAAhD,EAA2D;AACzD,MAAMC,SAASb,yBAAyBC,UAAzB,EAAqCC,IAArC,EAA2C,GAA3C,CAAf;AACA,MAAMG,SAAS,EAAf;AACA,OAAK,IAAIC,IAAI,CAAb,EAAgBA,IAAIO,OAAOC,MAA3B,EAAmCR,GAAnC,EAAwC;AACtC,QAAIM,UAAUC,OAAOP,CAAP,CAAV,CAAJ,EAA0B;AACxBD,aAAOG,IAAP,CAAYK,OAAOP,CAAP,CAAZ;AACD,KAFD,MAEO;AACL;AACD;AACF;AACD,SAAOD,MAAP;AACD;;AAED,SAASU,qBAAT,CAA+Bd,UAA/B,EAA2CC,IAA3C,EAAiDU,SAAjD,EAA4D;AAC1D,MAAMC,SAASJ,0BAA0BR,UAA1B,EAAsCC,IAAtC,EAA4C,GAA5C,CAAf;AACA,MAAMG,SAAS,EAAf;AACA,OAAK,IAAIC,IAAIO,OAAOC,MAAP,GAAgB,CAA7B,EAAgCR,KAAK,CAArC,EAAwCA,GAAxC,EAA6C;AAC3C,QAAIM,UAAUC,OAAOP,CAAP,CAAV,CAAJ,EAA0B;AACxBD,aAAOG,IAAP,CAAYK,OAAOP,CAAP,CAAZ;AACD,KAFD,MAEO;AACL;AACD;AACF;AACD,SAAOD,OAAOV,OAAP,EAAP;AACD;;AAED,SAASqB,cAAT,CAAwBC,QAAxB,EAAkC;AAChC,MAAIA,SAASH,MAAT,KAAoB,CAAxB,EAA2B;AACzB,WAAO,EAAP;AACD;AACD,MAAII,kBAAkBD,SAAS,CAAT,CAAtB;AACA,SAAOA,SAASE,MAAT,CAAgB,UAAUC,cAAV,EAA0B;AAC/C,QAAMC,MAAMD,eAAerB,IAAf,GAAsBmB,gBAAgBnB,IAAlD;AACA,QAAImB,gBAAgBnB,IAAhB,GAAuBqB,eAAerB,IAA1C,EAAgD;AAC9CmB,wBAAkBE,cAAlB;AACD;AACD,WAAOC,GAAP;AACD,GANM,CAAP;AAOD;;AAED,SAASC,YAAT,CAAsBpB,IAAtB,EAA4B;AAC1B,MAAIqB,SAASrB,IAAb;AACA,SAAOqB,OAAOA,MAAP,IAAiB,IAAjB,IAAyBA,OAAOA,MAAP,CAAcC,IAAd,IAAsB,IAAtD,EAA4D;AAC1DD,aAASA,OAAOA,MAAhB;AACD;AACD,SAAOA,MAAP;AACD;;AAED,SAASE,yBAAT,CAAmCxB,UAAnC,EAA+CC,IAA/C,EAAqD;AACnD,MAAMwB,oBAAoBf,qBAAqBV,UAArB,EAAiCC,IAAjC,EAAuCyB,oBAAoBzB,IAApB,CAAvC,CAA1B;AACA,MAAM0B,cAAcF,kBAAkBZ,MAAlB,GAA2B,CAA3B;AAChBY,oBAAkBA,kBAAkBZ,MAAlB,GAA2B,CAA7C,EAAgDe,KAAhD,CAAsD,CAAtD,CADgB;AAEhB3B,OAAK2B,KAAL,CAAW,CAAX,CAFJ;AAGA,MAAIxB,SAASuB,WAAb;AACA,OAAK,IAAItB,IAAIsB,WAAb,EAA0BtB,IAAIL,WAAW6B,IAAX,CAAgBhB,MAA9C,EAAsDR,GAAtD,EAA2D;AACzD,QAAIL,WAAW6B,IAAX,CAAgBxB,CAAhB,MAAuB,IAA3B,EAAiC;AAC/BD,eAASC,IAAI,CAAb;AACA;AACD;AACD,QAAIL,WAAW6B,IAAX,CAAgBxB,CAAhB,MAAuB,GAAvB,IAA8BL,WAAW6B,IAAX,CAAgBxB,CAAhB,MAAuB,IAArD,IAA6DL,WAAW6B,IAAX,CAAgBxB,CAAhB,MAAuB,IAAxF,EAA8F;AAC5F;AACD;AACDD,aAASC,IAAI,CAAb;AACD;AACD,SAAOD,MAAP;AACD;;AAED,SAASsB,mBAAT,CAA6BzB,IAA7B,EAAmC;AACjC,SAAO,UAAC6B,KAAD,UAAW,CAACA,MAAMC,IAAN,KAAe,OAAf,IAA2BD,MAAMC,IAAN,KAAe,MAA3C;AACXD,UAAME,GAAN,CAAUC,KAAV,CAAgBC,IAAhB,KAAyBJ,MAAME,GAAN,CAAUG,GAAV,CAAcD,IAD5B;AAEXJ,UAAME,GAAN,CAAUG,GAAV,CAAcD,IAAd,KAAuBjC,KAAK+B,GAAL,CAASG,GAAT,CAAaD,IAFpC,EAAP;AAGD;;AAED,SAASE,2BAAT,CAAqCpC,UAArC,EAAiDC,IAAjD,EAAuD;AACrD,MAAMwB,oBAAoBX,sBAAsBd,UAAtB,EAAkCC,IAAlC,EAAwCyB,oBAAoBzB,IAApB,CAAxC,CAA1B;AACA,MAAMoC,gBAAgBZ,kBAAkBZ,MAAlB,GAA2B,CAA3B,GAA+BY,kBAAkB,CAAlB,EAAqBG,KAArB,CAA2B,CAA3B,CAA/B,GAA+D3B,KAAK2B,KAAL,CAAW,CAAX,CAArF;AACA,MAAIxB,SAASiC,aAAb;AACA,OAAK,IAAIhC,IAAIgC,gBAAgB,CAA7B,EAAgChC,IAAI,CAApC,EAAuCA,GAAvC,EAA4C;AAC1C,QAAIL,WAAW6B,IAAX,CAAgBxB,CAAhB,MAAuB,GAAvB,IAA8BL,WAAW6B,IAAX,CAAgBxB,CAAhB,MAAuB,IAAzD,EAA+D;AAC7D;AACD;AACDD,aAASC,CAAT;AACD;AACD,SAAOD,MAAP;AACD;;AAED,SAASkC,mBAAT,CAA6BC,IAA7B,EAAmC;AACjC,SAAOA,QAAQ,IAAR;AACFA,OAAKR,IAAL,KAAc,gBADZ;AAEFQ,OAAKC,MAAL,IAAe,IAFb;AAGFD,OAAKC,MAAL,CAAYC,IAAZ,KAAqB,SAHnB;AAIFF,OAAKG,SAAL,IAAkB,IAJhB;AAKFH,OAAKG,SAAL,CAAe7B,MAAf,KAA0B,CALxB;AAMF0B,OAAKG,SAAL,CAAe,CAAf,EAAkBX,IAAlB,KAA2B,SANhC;AAOD;;AAED,SAASY,wBAAT,CAAkC1C,IAAlC,EAAwC;AACtC,MAAIA,KAAK8B,IAAL,KAAc,qBAAlB,EAAyC;AACvC,WAAO,KAAP;AACD;AACD,MAAI9B,KAAK2C,YAAL,CAAkB/B,MAAlB,KAA6B,CAAjC,EAAoC;AAClC,WAAO,KAAP;AACD;AACD,MAAMgC,OAAO5C,KAAK2C,YAAL,CAAkB,CAAlB,CAAb;AACA,MAAME,iBAAiBD,KAAKE,EAAL;AACjBF,OAAKE,EAAL,CAAQhB,IAAR,KAAiB,YAAjB,IAAiCc,KAAKE,EAAL,CAAQhB,IAAR,KAAiB,eADjC;AAElBO,sBAAoBO,KAAKG,IAAzB,CAFL;AAGA,MAAMC,gCAAgCJ,KAAKE,EAAL;AAChCF,OAAKE,EAAL,CAAQhB,IAAR,KAAiB,YAAjB,IAAiCc,KAAKE,EAAL,CAAQhB,IAAR,KAAiB,eADlB;AAEjCc,OAAKG,IAAL,IAAa,IAFoB;AAGjCH,OAAKG,IAAL,CAAUjB,IAAV,KAAmB,gBAHc;AAIjCc,OAAKG,IAAL,CAAUR,MAAV,IAAoB,IAJa;AAKjCK,OAAKG,IAAL,CAAUR,MAAV,CAAiBT,IAAjB,KAA0B,kBALO;AAMjCO,sBAAoBO,KAAKG,IAAL,CAAUR,MAAV,CAAiBU,MAArC,CANL;AAOA,SAAOJ,kBAAkBG,6BAAzB;AACD;;AAED,SAASE,mBAAT,CAA6BlD,IAA7B,EAAmC;AACjC,SAAOA,KAAK8B,IAAL,KAAc,mBAAd,IAAqC9B,KAAKmD,UAAL,IAAmB,IAAxD,IAAgEnD,KAAKmD,UAAL,CAAgBvC,MAAhB,GAAyB,CAAhG;AACD;;AAED,SAASwC,mBAAT,CAA6BpD,IAA7B,EAAmC;AACjC,SAAOA,KAAK8B,IAAL,KAAc,2BAAd,IAA6C9B,KAAKqD,eAAL,CAAqBC,UAAzE;AACD;;AAED,SAASC,wBAAT,CAAkCvD,IAAlC,EAAwC;AACtC,SAAO0C,yBAAyB1C,IAAzB,KAAkCkD,oBAAoBlD,IAApB,CAAlC,IAA+DoD,oBAAoBpD,IAApB,CAAtE;AACD;;AAED,SAASwD,eAAT,CAAyBC,SAAzB,EAAoCC,UAApC,EAAgD;AAC9C,MAAMrC,SAASoC,UAAUpC,MAAzB,CAD8C;AAEZ;AAChCA,SAAOC,IAAP,CAAYqC,OAAZ,CAAoBF,SAApB,CADgC;AAEhCpC,SAAOC,IAAP,CAAYqC,OAAZ,CAAoBD,UAApB,CAFgC;AAGhCE,MAHgC,EAFY,mCAEvCC,UAFuC,aAE3BC,WAF2B;AAM9C,MAAMC,eAAe1C,OAAOC,IAAP,CAAY0C,KAAZ,CAAkBH,UAAlB,EAA8BC,cAAc,CAA5C,CAArB,CAN8C;AAO9C,yBAA0BC,YAA1B,8HAAwC,KAA7BE,WAA6B;AACtC,UAAI,CAACV,yBAAyBU,WAAzB,CAAL,EAA4C;AAC1C,eAAO,KAAP;AACD;AACF,KAX6C;AAY9C,SAAO,IAAP;AACD;;AAED,SAASC,qBAAT,CAA+BlE,IAA/B,EAAqC;AACnC,MAAIA,KAAKA,IAAL,CAAUmE,UAAV,KAAyB,MAA7B,EAAqC;AACnC,WAAO,aAAP;AACD;AACD,MAAInE,KAAKA,IAAL,CAAUmE,UAAV,KAAyB,QAA7B,EAAuC;AACrC,WAAO,eAAP;AACD;AACD,SAAO,QAAP;AACD;;AAED,SAASC,aAAT,CAAuBC,OAAvB,EAAgCZ,SAAhC,EAA2CC,UAA3C,EAAuDY,KAAvD,EAA8D;AAC5D,MAAMvE,aAAasE,QAAQE,aAAR,EAAnB;;AAEA,MAAMC,YAAYpD,aAAaqC,UAAUzD,IAAvB,CAAlB;AACA,MAAMyE,iBAAiBtC,4BAA4BpC,UAA5B,EAAwCyE,SAAxC,CAAvB;AACA,MAAME,eAAenD,0BAA0BxB,UAA1B,EAAsCyE,SAAtC,CAArB;;AAEA,MAAMG,aAAavD,aAAasC,WAAW1D,IAAxB,CAAnB;AACA,MAAM4E,kBAAkBzC,4BAA4BpC,UAA5B,EAAwC4E,UAAxC,CAAxB;AACA,MAAME,gBAAgBtD,0BAA0BxB,UAA1B,EAAsC4E,UAAtC,CAAtB;AACA,MAAMG,SAAStB,gBAAgBgB,SAAhB,EAA2BG,UAA3B,CAAf;;AAEA,MAAII,UAAUhF,WAAW6B,IAAX,CAAgBoD,SAAhB,CAA0BJ,eAA1B,EAA2CC,aAA3C,CAAd;AACA,MAAIE,QAAQA,QAAQnE,MAAR,GAAiB,CAAzB,MAAgC,IAApC,EAA0C;AACxCmE,qBAAaA,OAAb;AACD;;AAED,MAAME,qBAAiBf,sBAAsBT,SAAtB,CAAjB,qBAA0DA,UAAUyB,WAApE,OAAN;AACA,MAAMC,4BAAoBzB,WAAWwB,WAA/B,kBAAgDhB,sBAAsBR,UAAtB,CAAhD,CAAN;AACA,MAAM0B,UAAaD,YAAb,6BAA0Cb,KAA1C,UAAmDW,WAAzD;;AAEA,MAAIX,UAAU,QAAd,EAAwB;AACtBD,YAAQgB,MAAR,CAAe;AACbrF,YAAM0D,WAAW1D,IADJ;AAEboF,sBAFa;AAGbE,WAAKR,UAAW,UAACS,KAAD,UAAWA,MAAMC,gBAAN;AACzB,SAACf,cAAD,EAAiBI,aAAjB,CADyB;AAEzBE,kBAAUhF,WAAW6B,IAAX,CAAgBoD,SAAhB,CAA0BP,cAA1B,EAA0CG,eAA1C,CAFe,CAAX,EAHH,EAAf;;;AAQD,GATD,MASO,IAAIN,UAAU,OAAd,EAAuB;AAC5BD,YAAQgB,MAAR,CAAe;AACbrF,YAAM0D,WAAW1D,IADJ;AAEboF,sBAFa;AAGbE,WAAKR,UAAW,UAACS,KAAD,UAAWA,MAAMC,gBAAN;AACzB,SAACZ,eAAD,EAAkBF,YAAlB,CADyB;AAEzB3E,mBAAW6B,IAAX,CAAgBoD,SAAhB,CAA0BH,aAA1B,EAAyCH,YAAzC,IAAyDK,OAFhC,CAAX,EAHH,EAAf;;;AAQD;AACF;;AAED,SAASU,gBAAT,CAA0BpB,OAA1B,EAAmCtD,QAAnC,EAA6C2E,UAA7C,EAAyDpB,KAAzD,EAAgE;AAC9DoB,aAAWC,OAAX,CAAmB,UAAUC,GAAV,EAAe;AAChC,QAAMC,QAAQ9E,SAAS+E,IAAT,cAAc,SAASC,aAAT,CAAuBC,YAAvB,EAAqC;AAC/D,eAAOA,aAAanG,IAAb,GAAoB+F,IAAI/F,IAA/B;AACD,OAFa,OAAuBkG,aAAvB,KAAd;AAGA3B,kBAAcC,OAAd,EAAuBwB,KAAvB,EAA8BD,GAA9B,EAAmCtB,KAAnC;AACD,GALD;AAMD;;AAED,SAAS2B,oBAAT,CAA8B5B,OAA9B,EAAuCtD,QAAvC,EAAiD;AAC/C,MAAM2E,aAAa5E,eAAeC,QAAf,CAAnB;AACA,MAAI,CAAC2E,WAAW9E,MAAhB,EAAwB;AACtB;AACD;;AAED;AACA,MAAMsF,mBAAmBzG,QAAQsB,QAAR,CAAzB;AACA,MAAMoF,gBAAgBrF,eAAeoF,gBAAf,CAAtB;AACA,MAAIC,cAAcvF,MAAd,GAAuB8E,WAAW9E,MAAtC,EAA8C;AAC5C6E,qBAAiBpB,OAAjB,EAA0B6B,gBAA1B,EAA4CC,aAA5C,EAA2D,OAA3D;AACA;AACD;AACDV,mBAAiBpB,OAAjB,EAA0BtD,QAA1B,EAAoC2E,UAApC,EAAgD,QAAhD;AACD;;AAED,IAAMU,gBAAgB,SAAhBA,aAAgB,CAACC,CAAD,EAAIC,CAAJ,EAAU;AAC9B,MAAID,IAAIC,CAAR,EAAW;AACT,WAAO,CAAC,CAAR;AACD;AACD,MAAID,IAAIC,CAAR,EAAW;AACT,WAAO,CAAP;AACD;AACD,SAAO,CAAP;AACD,CARD;;AAUA;AACA,IAAMC,sBAAsB,OAA5B;AACA,IAAMC,qBAAqB,SAArBA,kBAAqB,CAACxG,IAAD,EAAOyG,WAAP,EAAuB;AAChD,MAAMC,QAAQ1G,KAAK0G,KAAnB;AACA,SAAOD,cAAcE,OAAOD,KAAP,EAAcD,WAAd,EAAd,GAA4CC,KAAnD;AACD,CAHD;;AAKA,SAASE,SAAT,CAAmBC,kBAAnB,EAAuC;AACrC,MAAMC,aAAaD,mBAAmBvC,KAAnB,KAA6B,KAA7B,GAAqC,CAArC,GAAyC,CAAC,CAA7D;AACA,MAAMyC,kBAAkBF,mBAAmBE,eAA3C;AACA,MAAMC,uBAAuBD,oBAAoB,QAApB;AACvBF,qBAAmBE,eAAnB,KAAuC,KAAvC,GAA+C,CAA/C,GAAmD,CAAC,CAD7B,CAA7B;;AAGA,sBAAO,SAASE,aAAT,CAAuBC,KAAvB,EAA8BC,KAA9B,EAAqC;AAC1C,UAAMC,UAAUZ,mBAAmBU,KAAnB,EAA0BL,mBAAmBQ,eAA7C,CAAhB;AACA,UAAMC,UAAUd,mBAAmBW,KAAnB,EAA0BN,mBAAmBQ,eAA7C,CAAhB;AACA,UAAIlH,SAAS,CAAb;;AAEA,UAAI,CAAC,gCAASiH,OAAT,EAAkB,GAAlB,CAAD,IAA2B,CAAC,gCAASE,OAAT,EAAkB,GAAlB,CAAhC,EAAwD;AACtDnH,iBAASiG,cAAcgB,OAAd,EAAuBE,OAAvB,CAAT;AACD,OAFD,MAEO;AACL,YAAMC,IAAIH,QAAQI,KAAR,CAAc,GAAd,CAAV;AACA,YAAMC,IAAIH,QAAQE,KAAR,CAAc,GAAd,CAAV;AACA,YAAMnB,IAAIkB,EAAE3G,MAAZ;AACA,YAAM0F,IAAImB,EAAE7G,MAAZ;;AAEA,aAAK,IAAIR,IAAI,CAAb,EAAgBA,IAAIsH,KAAKC,GAAL,CAAStB,CAAT,EAAYC,CAAZ,CAApB,EAAoClG,GAApC,EAAyC;AACvCD,mBAASiG,cAAcmB,EAAEnH,CAAF,CAAd,EAAoBqH,EAAErH,CAAF,CAApB,CAAT;AACA,cAAID,MAAJ,EAAY,CAAE,MAAQ;AACvB;;AAED,YAAI,CAACA,MAAD,IAAWkG,MAAMC,CAArB,EAAwB;AACtBnG,mBAASkG,IAAIC,CAAJ,GAAQ,CAAC,CAAT,GAAa,CAAtB;AACD;AACF;;AAEDnG,eAASA,SAAS2G,UAAlB;;AAEA;AACA,UAAI,CAAC3G,MAAD,IAAW6G,oBAAf,EAAqC;AACnC7G,iBAAS6G,uBAAuBZ;AAC9Bc,cAAMlH,IAAN,CAAWmE,UAAX,IAAyBoC,mBADK;AAE9BY,cAAMnH,IAAN,CAAWmE,UAAX,IAAyBoC,mBAFK,CAAhC;;AAID;;AAED,aAAOpG,MAAP;AACD,KAlCD,OAAgB8G,aAAhB;AAmCD;;AAED,SAASW,wBAAT,CAAkC7G,QAAlC,EAA4C8F,kBAA5C,EAAgE;AAC9D,MAAMgB,iBAAiB,yBAAQ9G,QAAR,EAAkB,UAAC+G,IAAD,UAAUA,KAAKjI,IAAf,EAAlB,CAAvB;;AAEA,MAAMkI,WAAWnB,UAAUC,kBAAV,CAAjB;;AAEA;AACA,MAAMmB,aAAaC,OAAOC,IAAP,CAAYL,cAAZ,EAA4BjE,IAA5B,CAAiC,UAAUyC,CAAV,EAAaC,CAAb,EAAgB;AAClE,WAAOD,IAAIC,CAAX;AACD,GAFkB,CAAnB;;AAIA;AACA0B,aAAWrC,OAAX,CAAmB,UAAUwC,SAAV,EAAqB;AACtCN,mBAAeM,SAAf,EAA0BvE,IAA1B,CAA+BmE,QAA/B;AACD,GAFD;;AAIA;AACA,MAAIK,UAAU,CAAd;AACA,MAAMC,oBAAoBL,WAAWM,MAAX,CAAkB,UAAUC,GAAV,EAAeJ,SAAf,EAA0B;AACpEN,mBAAeM,SAAf,EAA0BxC,OAA1B,CAAkC,UAAUK,YAAV,EAAwB;AACxDuC,iBAAOvC,aAAaU,KAApB,iBAA6BV,aAAahG,IAAb,CAAkBmE,UAA/C,KAA+DqE,SAASL,SAAT,EAAoB,EAApB,IAA0BC,OAAzF;AACAA,iBAAW,CAAX;AACD,KAHD;AAIA,WAAOG,GAAP;AACD,GANyB,EAMvB,EANuB,CAA1B;;AAQA;AACAxH,WAAS4E,OAAT,CAAiB,UAAUK,YAAV,EAAwB;AACvCA,iBAAanG,IAAb,GAAoBwI,yBAAqBrC,aAAaU,KAAlC,iBAA2CV,aAAahG,IAAb,CAAkBmE,UAA7D,EAApB;AACD,GAFD;AAGD;;AAED;;AAEA,SAASsE,eAAT,CAAyBC,KAAzB,EAAgCC,UAAhC,EAA4CC,IAA5C,EAAkDC,WAAlD,EAA+D;AAC7D,OAAK,IAAIzI,IAAI,CAAR,EAAW0I,IAAIH,WAAW/H,MAA/B,EAAuCR,IAAI0I,CAA3C,EAA8C1I,GAA9C,EAAmD;AACQuI,eAAWvI,CAAX,CADR,CACzC2I,OADyC,iBACzCA,OADyC,CAChCC,cADgC,iBAChCA,cADgC,CAChBC,KADgB,iBAChBA,KADgB,uCACTC,QADS,CACTA,QADS,yCACE,CADF;AAEjD,QAAI,4BAAUN,IAAV,EAAgBG,OAAhB,EAAyBC,kBAAkB,EAAEG,WAAW,IAAb,EAA3C,CAAJ,EAAqE;AACnE,aAAOT,MAAMO,KAAN,IAAeC,WAAWL,WAAjC;AACD;AACF;AACF;;AAED,SAASO,WAAT,CAAqB/E,OAArB,EAA8BqE,KAA9B,EAAqCW,WAArC,EAAkDC,mBAAlD,EAAuE;AACrE,MAAIC,gBAAJ;AACA,MAAI1J,aAAJ;AACA,MAAIwJ,YAAYvH,IAAZ,KAAqB,eAAzB,EAA0C;AACxCyH,cAAU,QAAV;AACD,GAFD,MAEO,IAAIF,YAAYrJ,IAAZ,CAAiBmE,UAAjB,KAAgC,MAAhC,IAA0CuE,MAAMc,YAAN,CAAmB7F,OAAnB,CAA2B,MAA3B,MAAuC,CAAC,CAAtF,EAAyF;AAC9F4F,cAAU,MAAV;AACD,GAFM,MAEA;AACLA,cAAU,6BAAWF,YAAY3C,KAAvB,EAA8BrC,OAA9B,CAAV;AACD;AACD,MAAI,CAACiF,oBAAoBG,GAApB,CAAwBF,OAAxB,CAAL,EAAuC;AACrC1J,WAAO4I,gBAAgBC,MAAMgB,MAAtB,EAA8BhB,MAAMC,UAApC,EAAgDU,YAAY3C,KAA5D,EAAmEgC,MAAMG,WAAzE,CAAP;AACD;AACD,MAAI,OAAOhJ,IAAP,KAAgB,WAApB,EAAiC;AAC/BA,WAAO6I,MAAMgB,MAAN,CAAaH,OAAb,CAAP;AACD;AACD,MAAIF,YAAYvH,IAAZ,KAAqB,QAArB,IAAiC,CAACuH,YAAYvH,IAAZ,CAAiB6H,UAAjB,CAA4B,SAA5B,CAAtC,EAA8E;AAC5E9J,YAAQ,GAAR;AACD;;AAED,SAAOA,IAAP;AACD;;AAED,SAAS+J,YAAT,CAAsBvF,OAAtB,EAA+BgF,WAA/B,EAA4CX,KAA5C,EAAmD3H,QAAnD,EAA6DuI,mBAA7D,EAAkF;AAChF,MAAMzJ,OAAOuJ,YAAY/E,OAAZ,EAAqBqE,KAArB,EAA4BW,WAA5B,EAAyCC,mBAAzC,CAAb;AACA,MAAIzJ,SAAS,CAAC,CAAd,EAAiB;AACfkB,aAAST,IAAT,mBAAmB+I,WAAnB,IAAgCxJ,UAAhC;AACD;AACF;;AAED,SAASgK,eAAT,CAAyB7J,IAAzB,EAA+B;AAC7B,MAAI8J,IAAI9J,IAAR;AACA;AACA;AACA;AACE8J,IAAEzI,MAAF,CAASS,IAAT,KAAkB,kBAAlB,IAAwCgI,EAAEzI,MAAF,CAAS4B,MAAT,KAAoB6G,CAA5D;AACGA,IAAEzI,MAAF,CAASS,IAAT,KAAkB,gBAAlB,IAAsCgI,EAAEzI,MAAF,CAASkB,MAAT,KAAoBuH,CAF/D;AAGE;AACAA,QAAIA,EAAEzI,MAAN;AACD;AACD;AACEyI,IAAEzI,MAAF,CAASS,IAAT,KAAkB,oBAAlB;AACGgI,IAAEzI,MAAF,CAASA,MAAT,CAAgBS,IAAhB,KAAyB,qBAD5B;AAEGgI,IAAEzI,MAAF,CAASA,MAAT,CAAgBA,MAAhB,CAAuBS,IAAvB,KAAgC,SAHrC;AAIE;AACA,WAAOgI,EAAEzI,MAAF,CAASA,MAAT,CAAgBA,MAAvB;AACD;AACF;;AAED,IAAM0I,QAAQ,CAAC,SAAD,EAAY,UAAZ,EAAwB,UAAxB,EAAoC,SAApC,EAA+C,QAA/C,EAAyD,SAAzD,EAAoE,OAApE,EAA6E,QAA7E,EAAuF,MAAvF,CAAd;;AAEA;AACA;AACA;AACA,SAASC,oBAAT,CAA8BN,MAA9B,EAAsC;AACpC,MAAMO,aAAaP,OAAOpB,MAAP,CAAc,UAAUnH,GAAV,EAAe8H,KAAf,EAAsBiB,KAAtB,EAA6B;AAC5D,OAAGC,MAAH,CAAUlB,KAAV,EAAiBtD,OAAjB,CAAyB,UAAUyE,SAAV,EAAqB;AAC5C,UAAIL,MAAMpG,OAAN,CAAcyG,SAAd,MAA6B,CAAC,CAAlC,EAAqC;AACnC,cAAM,IAAIC,KAAJ,gEAAiEC,KAAKC,SAAL,CAAeH,SAAf,CAAjE,QAAN;AACD;AACD,UAAIjJ,IAAIiJ,SAAJ,MAAmBI,SAAvB,EAAkC;AAChC,cAAM,IAAIH,KAAJ,mDAAoDD,SAApD,sBAAN;AACD;AACDjJ,UAAIiJ,SAAJ,IAAiBF,QAAQ,CAAzB;AACD,KARD;AASA,WAAO/I,GAAP;AACD,GAXkB,EAWhB,EAXgB,CAAnB;;AAaA,MAAMqI,eAAeO,MAAM9I,MAAN,CAAa,UAAUa,IAAV,EAAgB;AAChD,WAAO,OAAOmI,WAAWnI,IAAX,CAAP,KAA4B,WAAnC;AACD,GAFoB,CAArB;;AAIA,MAAM4G,QAAQc,aAAalB,MAAb,CAAoB,UAAUnH,GAAV,EAAeW,IAAf,EAAqB;AACrDX,QAAIW,IAAJ,IAAY4H,OAAO9I,MAAP,GAAgB,CAA5B;AACA,WAAOO,GAAP;AACD,GAHa,EAGX8I,UAHW,CAAd;;AAKA,SAAO,EAAEP,QAAQhB,KAAV,EAAiBc,0BAAjB,EAAP;AACD;;AAED,SAASiB,yBAAT,CAAmC9B,UAAnC,EAA+C;AAC7C,MAAM+B,QAAQ,EAAd;AACA,MAAMC,SAAS,EAAf;;AAEA,MAAMC,cAAcjC,WAAWhJ,GAAX,CAAe,UAACkL,SAAD,EAAYX,KAAZ,EAAsB;AAC/CjB,SAD+C,GACX4B,SADW,CAC/C5B,KAD+C,CAC9B6B,cAD8B,GACXD,SADW,CACxC3B,QADwC;AAEvD,QAAIA,WAAW,CAAf;AACA,QAAI4B,mBAAmB,OAAvB,EAAgC;AAC9B,UAAI,CAACJ,MAAMzB,KAAN,CAAL,EAAmB;AACjByB,cAAMzB,KAAN,IAAe,CAAf;AACD;AACDC,iBAAWwB,MAAMzB,KAAN,GAAX;AACD,KALD,MAKO,IAAI6B,mBAAmB,QAAvB,EAAiC;AACtC,UAAI,CAACH,OAAO1B,KAAP,CAAL,EAAoB;AAClB0B,eAAO1B,KAAP,IAAgB,EAAhB;AACD;AACD0B,aAAO1B,KAAP,EAAc3I,IAAd,CAAmB4J,KAAnB;AACD;;AAED,6BAAYW,SAAZ,IAAuB3B,kBAAvB;AACD,GAhBmB,CAApB;;AAkBA,MAAIL,cAAc,CAAlB;;AAEAZ,SAAOC,IAAP,CAAYyC,MAAZ,EAAoBhF,OAApB,CAA4B,UAACsD,KAAD,EAAW;AACrC,QAAM8B,cAAcJ,OAAO1B,KAAP,EAAcrI,MAAlC;AACA+J,WAAO1B,KAAP,EAActD,OAAd,CAAsB,UAACqF,UAAD,EAAad,KAAb,EAAuB;AAC3CU,kBAAYI,UAAZ,EAAwB9B,QAAxB,GAAmC,CAAC,CAAD,IAAM6B,cAAcb,KAApB,CAAnC;AACD,KAFD;AAGArB,kBAAcnB,KAAKuD,GAAL,CAASpC,WAAT,EAAsBkC,WAAtB,CAAd;AACD,GAND;;AAQA9C,SAAOC,IAAP,CAAYwC,KAAZ,EAAmB/E,OAAnB,CAA2B,UAACuF,GAAD,EAAS;AAClC,QAAMC,oBAAoBT,MAAMQ,GAAN,CAA1B;AACArC,kBAAcnB,KAAKuD,GAAL,CAASpC,WAAT,EAAsBsC,oBAAoB,CAA1C,CAAd;AACD,GAHD;;AAKA,SAAO;AACLxC,gBAAYiC,WADP;AAEL/B,iBAAaA,cAAc,EAAd,GAAmBnB,KAAK0D,GAAL,CAAS,EAAT,EAAa1D,KAAK2D,IAAL,CAAU3D,KAAK4D,KAAL,CAAWzC,WAAX,CAAV,CAAb,CAAnB,GAAsE,EAF9E,EAAP;;AAID;;AAED,SAAS0C,qBAAT,CAA+BlH,OAA/B,EAAwCmH,cAAxC,EAAwD;AACtD,MAAMC,WAAWrK,aAAaoK,eAAexL,IAA5B,CAAjB;AACA,MAAMwB,oBAAoBf;AACxB4D,UAAQE,aAAR,EADwB,EACCkH,QADD,EACWhK,oBAAoBgK,QAApB,CADX,CAA1B;;AAGA,MAAIC,YAAYD,SAAS9J,KAAT,CAAe,CAAf,CAAhB;AACA,MAAIH,kBAAkBZ,MAAlB,GAA2B,CAA/B,EAAkC;AAChC8K,gBAAYlK,kBAAkBA,kBAAkBZ,MAAlB,GAA2B,CAA7C,EAAgDe,KAAhD,CAAsD,CAAtD,CAAZ;AACD;AACD,SAAO,UAAC4D,KAAD,UAAWA,MAAMoG,oBAAN,CAA2B,CAACF,SAAS9J,KAAT,CAAe,CAAf,CAAD,EAAoB+J,SAApB,CAA3B,EAA2D,IAA3D,CAAX,EAAP;AACD;;AAED,SAASE,wBAAT,CAAkCvH,OAAlC,EAA2CwH,aAA3C,EAA0DL,cAA1D,EAA0E;AACxE,MAAMzL,aAAasE,QAAQE,aAAR,EAAnB;AACA,MAAMkH,WAAWrK,aAAaoK,eAAexL,IAA5B,CAAjB;AACA,MAAM8L,WAAW1K,aAAayK,cAAc7L,IAA3B,CAAjB;AACA,MAAM+L,gBAAgB;AACpBxK,4BAA0BxB,UAA1B,EAAsC0L,QAAtC,CADoB;AAEpBtJ,8BAA4BpC,UAA5B,EAAwC+L,QAAxC,CAFoB,CAAtB;;AAIA,MAAK,OAAD,CAAUE,IAAV,CAAejM,WAAW6B,IAAX,CAAgBoD,SAAhB,CAA0B+G,cAAc,CAAd,CAA1B,EAA4CA,cAAc,CAAd,CAA5C,CAAf,CAAJ,EAAmF;AACjF,WAAO,UAACxG,KAAD,UAAWA,MAAM0G,WAAN,CAAkBF,aAAlB,CAAX,EAAP;AACD;AACD,SAAOvB,SAAP;AACD;;AAED,SAAS0B,yBAAT,CAAmC7H,OAAnC,EAA4CtD,QAA5C,EAAsDoL,sBAAtD,EAA8EC,aAA9E,EAA6F;AAC3F,MAAMC,+BAA+B,SAA/BA,4BAA+B,CAACR,aAAD,EAAgBL,cAAhB,EAAmC;AACtE,QAAMc,sBAAsBjI,QAAQE,aAAR,GAAwBgI,KAAxB,CAA8BvI,KAA9B;AAC1BwH,mBAAexL,IAAf,CAAoB+B,GAApB,CAAwBG,GAAxB,CAA4BD,IADF;AAE1B4J,kBAAc7L,IAAd,CAAmB+B,GAAnB,CAAuBC,KAAvB,CAA6BC,IAA7B,GAAoC,CAFV,CAA5B;;;AAKA,WAAOqK,oBAAoBrL,MAApB,CAA2B,UAACgB,IAAD,UAAU,CAACA,KAAKuK,IAAL,GAAY5L,MAAvB,EAA3B,EAA0DA,MAAjE;AACD,GAPD;AAQA,MAAM6L,4BAA4B,SAA5BA,yBAA4B,CAACZ,aAAD,EAAgBL,cAAhB,UAAmCK,cAAchM,IAAd,GAAqB,CAArB,IAA0B2L,eAAe3L,IAA5E,EAAlC;AACA,MAAI2L,iBAAiBzK,SAAS,CAAT,CAArB;;AAEAA,WAASiD,KAAT,CAAe,CAAf,EAAkB2B,OAAlB,CAA0B,UAAUkG,aAAV,EAAyB;AACjD,QAAMa,oBAAoBL,6BAA6BR,aAA7B,EAA4CL,cAA5C,CAA1B;AACA,QAAMmB,yBAAyBF,0BAA0BZ,aAA1B,EAAyCL,cAAzC,CAA/B;;AAEA,QAAIW,2BAA2B,QAA3B;AACGA,+BAA2B,0BADlC,EAC8D;AAC5D,UAAIN,cAAchM,IAAd,KAAuB2L,eAAe3L,IAAtC,IAA8C6M,sBAAsB,CAAxE,EAA2E;AACzE,YAAIN,iBAAiB,CAACA,aAAD,IAAkBO,sBAAvC,EAA+D;AAC7DtI,kBAAQgB,MAAR,CAAe;AACbrF,kBAAMwL,eAAexL,IADR;AAEboF,qBAAS,+DAFI;AAGbE,iBAAKiG,sBAAsBlH,OAAtB,EAA+BmH,cAA/B,CAHQ,EAAf;;AAKD;AACF,OARD,MAQO,IAAIkB,oBAAoB,CAApB;AACNP,iCAA2B,0BADzB,EACqD;AAC1D,YAAIC,iBAAiBP,cAAchM,IAAd,KAAuB2L,eAAe3L,IAAvD,IAA+D,CAACuM,aAAD,IAAkB,CAACO,sBAAtF,EAA8G;AAC5GtI,kBAAQgB,MAAR,CAAe;AACbrF,kBAAMwL,eAAexL,IADR;AAEboF,qBAAS,mDAFI;AAGbE,iBAAKsG,yBAAyBvH,OAAzB,EAAkCwH,aAAlC,EAAiDL,cAAjD,CAHQ,EAAf;;AAKD;AACF;AACF,KApBD,MAoBO,IAAIkB,oBAAoB,CAAxB,EAA2B;AAChCrI,cAAQgB,MAAR,CAAe;AACbrF,cAAMwL,eAAexL,IADR;AAEboF,iBAAS,qDAFI;AAGbE,aAAKsG,yBAAyBvH,OAAzB,EAAkCwH,aAAlC,EAAiDL,cAAjD,CAHQ,EAAf;;AAKD;;AAEDA,qBAAiBK,aAAjB;AACD,GAjCD;AAkCD;;AAED,SAASe,oBAAT,CAA8BC,OAA9B,EAAuC;AACrC,MAAMC,cAAcD,QAAQC,WAAR,IAAuB,EAA3C;AACA,MAAMxI,QAAQwI,YAAYxI,KAAZ,IAAqB,QAAnC;AACA,MAAMyC,kBAAkB+F,YAAY/F,eAAZ,IAA+B,QAAvD;AACA,MAAMM,kBAAkByF,YAAYzF,eAAZ,IAA+B,KAAvD;;AAEA,SAAO,EAAE/C,YAAF,EAASyC,gCAAT,EAA0BM,gCAA1B,EAAP;AACD;;AAED;AACA,IAAM0F,uBAAuB,IAA7B;;AAEAC,OAAOC,OAAP,GAAiB;AACfC,QAAM;AACJpL,UAAM,YADF;AAEJqL,UAAM;AACJC,gBAAU,aADN;AAEJC,mBAAa,8CAFT;AAGJC,WAAK,0BAAQ,OAAR,CAHD,EAFF;;;AAQJC,aAAS,MARL;AASJC,YAAQ;AACN;AACE1L,YAAM,QADR;AAEE2L,kBAAY;AACV/D,gBAAQ;AACN5H,gBAAM,OADA,EADE;;AAIV4L,uCAA+B;AAC7B5L,gBAAM,OADuB,EAJrB;;AAOVsK,uBAAe;AACbtK,gBAAM,SADO;AAEb,qBAASiL,oBAFI,EAPL;;AAWVpE,oBAAY;AACV7G,gBAAM,OADI;AAEV6L,iBAAO;AACL7L,kBAAM,QADD;AAEL2L,wBAAY;AACV1E,uBAAS;AACPjH,sBAAM,QADC,EADC;;AAIVkH,8BAAgB;AACdlH,sBAAM,QADQ,EAJN;;AAOVmH,qBAAO;AACLnH,sBAAM,QADD;AAEL,wBAAMiI,KAFD,EAPG;;AAWVb,wBAAU;AACRpH,sBAAM,QADE;AAER,wBAAM,CAAC,OAAD,EAAU,QAAV,CAFE,EAXA,EAFP;;;AAkBL8L,kCAAsB,KAlBjB;AAmBLC,sBAAU,CAAC,SAAD,EAAY,OAAZ,CAnBL,EAFG,EAXF;;;AAmCV,4BAAoB;AAClB,kBAAM;AACJ,kBADI;AAEJ,kBAFI;AAGJ,oCAHI;AAIJ,iBAJI,CADY,EAnCV;;;AA2CVf,qBAAa;AACXhL,gBAAM,QADK;AAEX2L,sBAAY;AACVpG,6BAAiB;AACfvF,oBAAM,SADS;AAEf,yBAAS,KAFM,EADP;;AAKVwC,mBAAO;AACL,sBAAM,CAAC,QAAD,EAAW,KAAX,EAAkB,MAAlB,CADD;AAEL,yBAAS,QAFJ,EALG;;AASVyC,6BAAiB;AACf,sBAAM,CAAC,QAAD,EAAW,KAAX,EAAkB,MAAlB,CADS;AAEf,yBAAS,QAFM,EATP,EAFD;;;AAgBX6G,gCAAsB,KAhBX,EA3CH;;AA6DVE,iCAAyB;AACvBhM,gBAAM,SADiB;AAEvB,qBAAS,KAFc,EA7Df,EAFd;;;AAoEE8L,4BAAsB,KApExB,EADM,CATJ,EADS;;;;;AAoFfG,uBAAQ,SAASC,eAAT,CAAyB3J,OAAzB,EAAkC;AACxC,UAAMwI,UAAUxI,QAAQwI,OAAR,CAAgB,CAAhB,KAAsB,EAAtC;AACA,UAAMV,yBAAyBU,QAAQ,kBAAR,KAA+B,QAA9D;AACA,UAAMa,gCAAgC,IAAIO,GAAJ,CAAQpB,QAAQa,6BAAR,IAAyC,CAAC,SAAD,EAAY,UAAZ,EAAwB,QAAxB,CAAjD,CAAtC;AACA,UAAMZ,cAAcF,qBAAqBC,OAArB,CAApB;AACA,UAAMT,gBAAgBS,QAAQT,aAAR,IAAyB,IAAzB,GAAgCW,oBAAhC,GAAuD,CAAC,CAACF,QAAQT,aAAvF;AACA,UAAI1D,cAAJ;;AAEA,UAAI;AACkC+B,kCAA0BoC,QAAQlE,UAAR,IAAsB,EAAhD,CADlC,CACMA,UADN,yBACMA,UADN,CACkBE,WADlB,yBACkBA,WADlB;AAE+BmB,6BAAqB6C,QAAQnD,MAAR,IAAkBlK,aAAvC,CAF/B,CAEMkK,MAFN,yBAEMA,MAFN,CAEcF,YAFd,yBAEcA,YAFd;AAGFd,gBAAQ;AACNgB,wBADM;AAENF,oCAFM;AAGNb,gCAHM;AAINE,kCAJM,EAAR;;AAMD,OATD,CASE,OAAOqF,KAAP,EAAc;AACd;AACA,eAAO;AACLC,iBADK,gCACGnO,IADH,EACS;AACZqE,sBAAQgB,MAAR,CAAerF,IAAf,EAAqBkO,MAAM9I,OAA3B;AACD,aAHI,oBAAP;;AAKD;AACD,UAAMgJ,YAAY,IAAIC,GAAJ,EAAlB;;AAEA,eAASC,eAAT,CAAyBtO,IAAzB,EAA+B;AAC7B,YAAI,CAACoO,UAAU3E,GAAV,CAAczJ,IAAd,CAAL,EAA0B;AACxBoO,oBAAUG,GAAV,CAAcvO,IAAd,EAAoB,EAApB;AACD;AACD,eAAOoO,UAAUI,GAAV,CAAcxO,IAAd,CAAP;AACD;;AAED,aAAO;AACLyO,wCAAmB,SAASC,aAAT,CAAuB1O,IAAvB,EAA6B;AAC9C;AACA,gBAAIA,KAAKmD,UAAL,CAAgBvC,MAAhB,IAA0BiM,QAAQiB,uBAAtC,EAA+D;AAC7D,kBAAMtL,OAAOxC,KAAK2O,MAAL,CAAYjI,KAAzB;AACAkD;AACEvF,qBADF;AAEE;AACErE,0BADF;AAEE0G,uBAAOlE,IAFT;AAGE0C,6BAAa1C,IAHf;AAIEV,sBAAM,QAJR,EAFF;;AAQE4G,mBARF;AASE4F,8BAAgBtO,KAAKqB,MAArB,CATF;AAUEqM,2CAVF;;AAYD;AACF,WAjBD,OAA4BgB,aAA5B,IADK;AAmBLE,gDAA2B,SAASF,aAAT,CAAuB1O,IAAvB,EAA6B;AACtD,gBAAIkF,oBAAJ;AACA,gBAAIwB,cAAJ;AACA,gBAAI5E,aAAJ;AACA;AACA,gBAAI9B,KAAK6O,QAAT,EAAmB;AACjB;AACD;AACD,gBAAI7O,KAAKqD,eAAL,CAAqBvB,IAArB,KAA8B,2BAAlC,EAA+D;AAC7D4E,sBAAQ1G,KAAKqD,eAAL,CAAqBC,UAArB,CAAgCoD,KAAxC;AACAxB,4BAAcwB,KAAd;AACA5E,qBAAO,QAAP;AACD,aAJD,MAIO;AACL4E,sBAAQ,EAAR;AACAxB,4BAAcb,QAAQE,aAAR,GAAwBuK,OAAxB,CAAgC9O,KAAKqD,eAArC,CAAd;AACAvB,qBAAO,eAAP;AACD;AACD8H;AACEvF,mBADF;AAEE;AACErE,wBADF;AAEE0G,0BAFF;AAGExB,sCAHF;AAIEpD,wBAJF,EAFF;;AAQE4G,iBARF;AASE4F,4BAAgBtO,KAAKqB,MAArB,CATF;AAUEqM,yCAVF;;AAYD,WA7BD,OAAoCgB,aAApC,IAnBK;AAiDLK,qCAAgB,SAASC,cAAT,CAAwBhP,IAAxB,EAA8B;AAC5C,gBAAI,CAAC,gCAAgBA,IAAhB,CAAL,EAA4B;AAC1B;AACD;AACD,gBAAMiP,QAAQpF,gBAAgB7J,IAAhB,CAAd;AACA,gBAAI,CAACiP,KAAL,EAAY;AACV;AACD;AACD,gBAAMzM,OAAOxC,KAAKyC,SAAL,CAAe,CAAf,EAAkBiE,KAA/B;AACAkD;AACEvF,mBADF;AAEE;AACErE,wBADF;AAEE0G,qBAAOlE,IAFT;AAGE0C,2BAAa1C,IAHf;AAIEV,oBAAM,SAJR,EAFF;;AAQE4G,iBARF;AASE4F,4BAAgBW,KAAhB,CATF;AAUEvB,yCAVF;;AAYD,WArBD,OAAyBsB,cAAzB,IAjDK;AAuEL,qCAAgB,SAASE,cAAT,GAA0B;AACxCd,sBAAUzI,OAAV,CAAkB,UAAC5E,QAAD,EAAc;AAC9B,kBAAIoL,2BAA2B,QAA/B,EAAyC;AACvCD,0CAA0B7H,OAA1B,EAAmCtD,QAAnC,EAA6CoL,sBAA7C,EAAqEC,aAArE;AACD;;AAED,kBAAIU,YAAYxI,KAAZ,KAAsB,QAA1B,EAAoC;AAClCsD,yCAAyB7G,QAAzB,EAAmC+L,WAAnC;AACD;;AAED7G,mCAAqB5B,OAArB,EAA8BtD,QAA9B;AACD,aAVD;;AAYAqN,sBAAUe,KAAV;AACD,WAdD,OAAyBD,cAAzB,IAvEK,EAAP;;AAuFD,KAzHD,OAAiBlB,eAAjB,IApFe,EAAjB","file":"order.js","sourcesContent":["'use strict';\n\nimport minimatch from 'minimatch';\nimport includes from 'array-includes';\nimport groupBy from 'object.groupby';\n\nimport importType from '../core/importType';\nimport isStaticRequire from '../core/staticRequire';\nimport docsUrl from '../docsUrl';\n\nconst defaultGroups = ['builtin', 'external', 'parent', 'sibling', 'index'];\n\n// REPORTING AND FIXING\n\nfunction reverse(array) {\n  return array.map(function (v) {\n    return { ...v, rank: -v.rank };\n  }).reverse();\n}\n\nfunction getTokensOrCommentsAfter(sourceCode, node, count) {\n  let currentNodeOrToken = node;\n  const result = [];\n  for (let i = 0; i < count; i++) {\n    currentNodeOrToken = sourceCode.getTokenOrCommentAfter(currentNodeOrToken);\n    if (currentNodeOrToken == null) {\n      break;\n    }\n    result.push(currentNodeOrToken);\n  }\n  return result;\n}\n\nfunction getTokensOrCommentsBefore(sourceCode, node, count) {\n  let currentNodeOrToken = node;\n  const result = [];\n  for (let i = 0; i < count; i++) {\n    currentNodeOrToken = sourceCode.getTokenOrCommentBefore(currentNodeOrToken);\n    if (currentNodeOrToken == null) {\n      break;\n    }\n    result.push(currentNodeOrToken);\n  }\n  return result.reverse();\n}\n\nfunction takeTokensAfterWhile(sourceCode, node, condition) {\n  const tokens = getTokensOrCommentsAfter(sourceCode, node, 100);\n  const result = [];\n  for (let i = 0; i < tokens.length; i++) {\n    if (condition(tokens[i])) {\n      result.push(tokens[i]);\n    } else {\n      break;\n    }\n  }\n  return result;\n}\n\nfunction takeTokensBeforeWhile(sourceCode, node, condition) {\n  const tokens = getTokensOrCommentsBefore(sourceCode, node, 100);\n  const result = [];\n  for (let i = tokens.length - 1; i >= 0; i--) {\n    if (condition(tokens[i])) {\n      result.push(tokens[i]);\n    } else {\n      break;\n    }\n  }\n  return result.reverse();\n}\n\nfunction findOutOfOrder(imported) {\n  if (imported.length === 0) {\n    return [];\n  }\n  let maxSeenRankNode = imported[0];\n  return imported.filter(function (importedModule) {\n    const res = importedModule.rank < maxSeenRankNode.rank;\n    if (maxSeenRankNode.rank < importedModule.rank) {\n      maxSeenRankNode = importedModule;\n    }\n    return res;\n  });\n}\n\nfunction findRootNode(node) {\n  let parent = node;\n  while (parent.parent != null && parent.parent.body == null) {\n    parent = parent.parent;\n  }\n  return parent;\n}\n\nfunction findEndOfLineWithComments(sourceCode, node) {\n  const tokensToEndOfLine = takeTokensAfterWhile(sourceCode, node, commentOnSameLineAs(node));\n  const endOfTokens = tokensToEndOfLine.length > 0\n    ? tokensToEndOfLine[tokensToEndOfLine.length - 1].range[1]\n    : node.range[1];\n  let result = endOfTokens;\n  for (let i = endOfTokens; i < sourceCode.text.length; i++) {\n    if (sourceCode.text[i] === '\\n') {\n      result = i + 1;\n      break;\n    }\n    if (sourceCode.text[i] !== ' ' && sourceCode.text[i] !== '\\t' && sourceCode.text[i] !== '\\r') {\n      break;\n    }\n    result = i + 1;\n  }\n  return result;\n}\n\nfunction commentOnSameLineAs(node) {\n  return (token) => (token.type === 'Block' ||  token.type === 'Line')\n      && token.loc.start.line === token.loc.end.line\n      && token.loc.end.line === node.loc.end.line;\n}\n\nfunction findStartOfLineWithComments(sourceCode, node) {\n  const tokensToEndOfLine = takeTokensBeforeWhile(sourceCode, node, commentOnSameLineAs(node));\n  const startOfTokens = tokensToEndOfLine.length > 0 ? tokensToEndOfLine[0].range[0] : node.range[0];\n  let result = startOfTokens;\n  for (let i = startOfTokens - 1; i > 0; i--) {\n    if (sourceCode.text[i] !== ' ' && sourceCode.text[i] !== '\\t') {\n      break;\n    }\n    result = i;\n  }\n  return result;\n}\n\nfunction isRequireExpression(expr) {\n  return expr != null\n    && expr.type === 'CallExpression'\n    && expr.callee != null\n    && expr.callee.name === 'require'\n    && expr.arguments != null\n    && expr.arguments.length === 1\n    && expr.arguments[0].type === 'Literal';\n}\n\nfunction isSupportedRequireModule(node) {\n  if (node.type !== 'VariableDeclaration') {\n    return false;\n  }\n  if (node.declarations.length !== 1) {\n    return false;\n  }\n  const decl = node.declarations[0];\n  const isPlainRequire = decl.id\n    && (decl.id.type === 'Identifier' || decl.id.type === 'ObjectPattern')\n    && isRequireExpression(decl.init);\n  const isRequireWithMemberExpression = decl.id\n    && (decl.id.type === 'Identifier' || decl.id.type === 'ObjectPattern')\n    && decl.init != null\n    && decl.init.type === 'CallExpression'\n    && decl.init.callee != null\n    && decl.init.callee.type === 'MemberExpression'\n    && isRequireExpression(decl.init.callee.object);\n  return isPlainRequire || isRequireWithMemberExpression;\n}\n\nfunction isPlainImportModule(node) {\n  return node.type === 'ImportDeclaration' && node.specifiers != null && node.specifiers.length > 0;\n}\n\nfunction isPlainImportEquals(node) {\n  return node.type === 'TSImportEqualsDeclaration' && node.moduleReference.expression;\n}\n\nfunction canCrossNodeWhileReorder(node) {\n  return isSupportedRequireModule(node) || isPlainImportModule(node) || isPlainImportEquals(node);\n}\n\nfunction canReorderItems(firstNode, secondNode) {\n  const parent = firstNode.parent;\n  const [firstIndex, secondIndex] = [\n    parent.body.indexOf(firstNode),\n    parent.body.indexOf(secondNode),\n  ].sort();\n  const nodesBetween = parent.body.slice(firstIndex, secondIndex + 1);\n  for (const nodeBetween of nodesBetween) {\n    if (!canCrossNodeWhileReorder(nodeBetween)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction makeImportDescription(node) {\n  if (node.node.importKind === 'type') {\n    return 'type import';\n  }\n  if (node.node.importKind === 'typeof') {\n    return 'typeof import';\n  }\n  return 'import';\n}\n\nfunction fixOutOfOrder(context, firstNode, secondNode, order) {\n  const sourceCode = context.getSourceCode();\n\n  const firstRoot = findRootNode(firstNode.node);\n  const firstRootStart = findStartOfLineWithComments(sourceCode, firstRoot);\n  const firstRootEnd = findEndOfLineWithComments(sourceCode, firstRoot);\n\n  const secondRoot = findRootNode(secondNode.node);\n  const secondRootStart = findStartOfLineWithComments(sourceCode, secondRoot);\n  const secondRootEnd = findEndOfLineWithComments(sourceCode, secondRoot);\n  const canFix = canReorderItems(firstRoot, secondRoot);\n\n  let newCode = sourceCode.text.substring(secondRootStart, secondRootEnd);\n  if (newCode[newCode.length - 1] !== '\\n') {\n    newCode = `${newCode}\\n`;\n  }\n\n  const firstImport = `${makeImportDescription(firstNode)} of \\`${firstNode.displayName}\\``;\n  const secondImport = `\\`${secondNode.displayName}\\` ${makeImportDescription(secondNode)}`;\n  const message = `${secondImport} should occur ${order} ${firstImport}`;\n\n  if (order === 'before') {\n    context.report({\n      node: secondNode.node,\n      message,\n      fix: canFix && ((fixer) => fixer.replaceTextRange(\n        [firstRootStart, secondRootEnd],\n        newCode + sourceCode.text.substring(firstRootStart, secondRootStart),\n      )),\n    });\n  } else if (order === 'after') {\n    context.report({\n      node: secondNode.node,\n      message,\n      fix: canFix && ((fixer) => fixer.replaceTextRange(\n        [secondRootStart, firstRootEnd],\n        sourceCode.text.substring(secondRootEnd, firstRootEnd) + newCode,\n      )),\n    });\n  }\n}\n\nfunction reportOutOfOrder(context, imported, outOfOrder, order) {\n  outOfOrder.forEach(function (imp) {\n    const found = imported.find(function hasHigherRank(importedItem) {\n      return importedItem.rank > imp.rank;\n    });\n    fixOutOfOrder(context, found, imp, order);\n  });\n}\n\nfunction makeOutOfOrderReport(context, imported) {\n  const outOfOrder = findOutOfOrder(imported);\n  if (!outOfOrder.length) {\n    return;\n  }\n\n  // There are things to report. Try to minimize the number of reported errors.\n  const reversedImported = reverse(imported);\n  const reversedOrder = findOutOfOrder(reversedImported);\n  if (reversedOrder.length < outOfOrder.length) {\n    reportOutOfOrder(context, reversedImported, reversedOrder, 'after');\n    return;\n  }\n  reportOutOfOrder(context, imported, outOfOrder, 'before');\n}\n\nconst compareString = (a, b) => {\n  if (a < b) {\n    return -1;\n  }\n  if (a > b) {\n    return 1;\n  }\n  return 0;\n};\n\n/** Some parsers (languages without types) don't provide ImportKind */\nconst DEAFULT_IMPORT_KIND = 'value';\nconst getNormalizedValue = (node, toLowerCase) => {\n  const value = node.value;\n  return toLowerCase ? String(value).toLowerCase() : value;\n};\n\nfunction getSorter(alphabetizeOptions) {\n  const multiplier = alphabetizeOptions.order === 'asc' ? 1 : -1;\n  const orderImportKind = alphabetizeOptions.orderImportKind;\n  const multiplierImportKind = orderImportKind !== 'ignore'\n    && (alphabetizeOptions.orderImportKind === 'asc' ? 1 : -1);\n\n  return function importsSorter(nodeA, nodeB) {\n    const importA = getNormalizedValue(nodeA, alphabetizeOptions.caseInsensitive);\n    const importB = getNormalizedValue(nodeB, alphabetizeOptions.caseInsensitive);\n    let result = 0;\n\n    if (!includes(importA, '/') && !includes(importB, '/')) {\n      result = compareString(importA, importB);\n    } else {\n      const A = importA.split('/');\n      const B = importB.split('/');\n      const a = A.length;\n      const b = B.length;\n\n      for (let i = 0; i < Math.min(a, b); i++) {\n        result = compareString(A[i], B[i]);\n        if (result) { break; }\n      }\n\n      if (!result && a !== b) {\n        result = a < b ? -1 : 1;\n      }\n    }\n\n    result = result * multiplier;\n\n    // In case the paths are equal (result === 0), sort them by importKind\n    if (!result && multiplierImportKind) {\n      result = multiplierImportKind * compareString(\n        nodeA.node.importKind || DEAFULT_IMPORT_KIND,\n        nodeB.node.importKind || DEAFULT_IMPORT_KIND,\n      );\n    }\n\n    return result;\n  };\n}\n\nfunction mutateRanksToAlphabetize(imported, alphabetizeOptions) {\n  const groupedByRanks = groupBy(imported, (item) => item.rank);\n\n  const sorterFn = getSorter(alphabetizeOptions);\n\n  // sort group keys so that they can be iterated on in order\n  const groupRanks = Object.keys(groupedByRanks).sort(function (a, b) {\n    return a - b;\n  });\n\n  // sort imports locally within their group\n  groupRanks.forEach(function (groupRank) {\n    groupedByRanks[groupRank].sort(sorterFn);\n  });\n\n  // assign globally unique rank to each import\n  let newRank = 0;\n  const alphabetizedRanks = groupRanks.reduce(function (acc, groupRank) {\n    groupedByRanks[groupRank].forEach(function (importedItem) {\n      acc[`${importedItem.value}|${importedItem.node.importKind}`] = parseInt(groupRank, 10) + newRank;\n      newRank += 1;\n    });\n    return acc;\n  }, {});\n\n  // mutate the original group-rank with alphabetized-rank\n  imported.forEach(function (importedItem) {\n    importedItem.rank = alphabetizedRanks[`${importedItem.value}|${importedItem.node.importKind}`];\n  });\n}\n\n// DETECTING\n\nfunction computePathRank(ranks, pathGroups, path, maxPosition) {\n  for (let i = 0, l = pathGroups.length; i < l; i++) {\n    const { pattern, patternOptions, group, position = 1 } = pathGroups[i];\n    if (minimatch(path, pattern, patternOptions || { nocomment: true })) {\n      return ranks[group] + position / maxPosition;\n    }\n  }\n}\n\nfunction computeRank(context, ranks, importEntry, excludedImportTypes) {\n  let impType;\n  let rank;\n  if (importEntry.type === 'import:object') {\n    impType = 'object';\n  } else if (importEntry.node.importKind === 'type' && ranks.omittedTypes.indexOf('type') === -1) {\n    impType = 'type';\n  } else {\n    impType = importType(importEntry.value, context);\n  }\n  if (!excludedImportTypes.has(impType)) {\n    rank = computePathRank(ranks.groups, ranks.pathGroups, importEntry.value, ranks.maxPosition);\n  }\n  if (typeof rank === 'undefined') {\n    rank = ranks.groups[impType];\n  }\n  if (importEntry.type !== 'import' && !importEntry.type.startsWith('import:')) {\n    rank += 100;\n  }\n\n  return rank;\n}\n\nfunction registerNode(context, importEntry, ranks, imported, excludedImportTypes) {\n  const rank = computeRank(context, ranks, importEntry, excludedImportTypes);\n  if (rank !== -1) {\n    imported.push({ ...importEntry, rank });\n  }\n}\n\nfunction getRequireBlock(node) {\n  let n = node;\n  // Handle cases like `const baz = require('foo').bar.baz`\n  // and `const foo = require('foo')()`\n  while (\n    n.parent.type === 'MemberExpression' && n.parent.object === n\n    || n.parent.type === 'CallExpression' && n.parent.callee === n\n  ) {\n    n = n.parent;\n  }\n  if (\n    n.parent.type === 'VariableDeclarator'\n    && n.parent.parent.type === 'VariableDeclaration'\n    && n.parent.parent.parent.type === 'Program'\n  ) {\n    return n.parent.parent.parent;\n  }\n}\n\nconst types = ['builtin', 'external', 'internal', 'unknown', 'parent', 'sibling', 'index', 'object', 'type'];\n\n// Creates an object with type-rank pairs.\n// Example: { index: 0, sibling: 1, parent: 1, external: 1, builtin: 2, internal: 2 }\n// Will throw an error if it contains a type that does not exist, or has a duplicate\nfunction convertGroupsToRanks(groups) {\n  const rankObject = groups.reduce(function (res, group, index) {\n    [].concat(group).forEach(function (groupItem) {\n      if (types.indexOf(groupItem) === -1) {\n        throw new Error(`Incorrect configuration of the rule: Unknown type \\`${JSON.stringify(groupItem)}\\``);\n      }\n      if (res[groupItem] !== undefined) {\n        throw new Error(`Incorrect configuration of the rule: \\`${groupItem}\\` is duplicated`);\n      }\n      res[groupItem] = index * 2;\n    });\n    return res;\n  }, {});\n\n  const omittedTypes = types.filter(function (type) {\n    return typeof rankObject[type] === 'undefined';\n  });\n\n  const ranks = omittedTypes.reduce(function (res, type) {\n    res[type] = groups.length * 2;\n    return res;\n  }, rankObject);\n\n  return { groups: ranks, omittedTypes };\n}\n\nfunction convertPathGroupsForRanks(pathGroups) {\n  const after = {};\n  const before = {};\n\n  const transformed = pathGroups.map((pathGroup, index) => {\n    const { group, position: positionString } = pathGroup;\n    let position = 0;\n    if (positionString === 'after') {\n      if (!after[group]) {\n        after[group] = 1;\n      }\n      position = after[group]++;\n    } else if (positionString === 'before') {\n      if (!before[group]) {\n        before[group] = [];\n      }\n      before[group].push(index);\n    }\n\n    return { ...pathGroup, position };\n  });\n\n  let maxPosition = 1;\n\n  Object.keys(before).forEach((group) => {\n    const groupLength = before[group].length;\n    before[group].forEach((groupIndex, index) => {\n      transformed[groupIndex].position = -1 * (groupLength - index);\n    });\n    maxPosition = Math.max(maxPosition, groupLength);\n  });\n\n  Object.keys(after).forEach((key) => {\n    const groupNextPosition = after[key];\n    maxPosition = Math.max(maxPosition, groupNextPosition - 1);\n  });\n\n  return {\n    pathGroups: transformed,\n    maxPosition: maxPosition > 10 ? Math.pow(10, Math.ceil(Math.log10(maxPosition))) : 10,\n  };\n}\n\nfunction fixNewLineAfterImport(context, previousImport) {\n  const prevRoot = findRootNode(previousImport.node);\n  const tokensToEndOfLine = takeTokensAfterWhile(\n    context.getSourceCode(), prevRoot, commentOnSameLineAs(prevRoot));\n\n  let endOfLine = prevRoot.range[1];\n  if (tokensToEndOfLine.length > 0) {\n    endOfLine = tokensToEndOfLine[tokensToEndOfLine.length - 1].range[1];\n  }\n  return (fixer) => fixer.insertTextAfterRange([prevRoot.range[0], endOfLine], '\\n');\n}\n\nfunction removeNewLineAfterImport(context, currentImport, previousImport) {\n  const sourceCode = context.getSourceCode();\n  const prevRoot = findRootNode(previousImport.node);\n  const currRoot = findRootNode(currentImport.node);\n  const rangeToRemove = [\n    findEndOfLineWithComments(sourceCode, prevRoot),\n    findStartOfLineWithComments(sourceCode, currRoot),\n  ];\n  if ((/^\\s*$/).test(sourceCode.text.substring(rangeToRemove[0], rangeToRemove[1]))) {\n    return (fixer) => fixer.removeRange(rangeToRemove);\n  }\n  return undefined;\n}\n\nfunction makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, distinctGroup) {\n  const getNumberOfEmptyLinesBetween = (currentImport, previousImport) => {\n    const linesBetweenImports = context.getSourceCode().lines.slice(\n      previousImport.node.loc.end.line,\n      currentImport.node.loc.start.line - 1,\n    );\n\n    return linesBetweenImports.filter((line) => !line.trim().length).length;\n  };\n  const getIsStartOfDistinctGroup = (currentImport, previousImport) => currentImport.rank - 1 >= previousImport.rank;\n  let previousImport = imported[0];\n\n  imported.slice(1).forEach(function (currentImport) {\n    const emptyLinesBetween = getNumberOfEmptyLinesBetween(currentImport, previousImport);\n    const isStartOfDistinctGroup = getIsStartOfDistinctGroup(currentImport, previousImport);\n\n    if (newlinesBetweenImports === 'always'\n        || newlinesBetweenImports === 'always-and-inside-groups') {\n      if (currentImport.rank !== previousImport.rank && emptyLinesBetween === 0) {\n        if (distinctGroup || !distinctGroup && isStartOfDistinctGroup) {\n          context.report({\n            node: previousImport.node,\n            message: 'There should be at least one empty line between import groups',\n            fix: fixNewLineAfterImport(context, previousImport),\n          });\n        }\n      } else if (emptyLinesBetween > 0\n        && newlinesBetweenImports !== 'always-and-inside-groups') {\n        if (distinctGroup && currentImport.rank === previousImport.rank || !distinctGroup && !isStartOfDistinctGroup) {\n          context.report({\n            node: previousImport.node,\n            message: 'There should be no empty line within import group',\n            fix: removeNewLineAfterImport(context, currentImport, previousImport),\n          });\n        }\n      }\n    } else if (emptyLinesBetween > 0) {\n      context.report({\n        node: previousImport.node,\n        message: 'There should be no empty line between import groups',\n        fix: removeNewLineAfterImport(context, currentImport, previousImport),\n      });\n    }\n\n    previousImport = currentImport;\n  });\n}\n\nfunction getAlphabetizeConfig(options) {\n  const alphabetize = options.alphabetize || {};\n  const order = alphabetize.order || 'ignore';\n  const orderImportKind = alphabetize.orderImportKind || 'ignore';\n  const caseInsensitive = alphabetize.caseInsensitive || false;\n\n  return { order, orderImportKind, caseInsensitive };\n}\n\n// TODO, semver-major: Change the default of \"distinctGroup\" from true to false\nconst defaultDistinctGroup = true;\n\nmodule.exports = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      category: 'Style guide',\n      description: 'Enforce a convention in module import order.',\n      url: docsUrl('order'),\n    },\n\n    fixable: 'code',\n    schema: [\n      {\n        type: 'object',\n        properties: {\n          groups: {\n            type: 'array',\n          },\n          pathGroupsExcludedImportTypes: {\n            type: 'array',\n          },\n          distinctGroup: {\n            type: 'boolean',\n            default: defaultDistinctGroup,\n          },\n          pathGroups: {\n            type: 'array',\n            items: {\n              type: 'object',\n              properties: {\n                pattern: {\n                  type: 'string',\n                },\n                patternOptions: {\n                  type: 'object',\n                },\n                group: {\n                  type: 'string',\n                  enum: types,\n                },\n                position: {\n                  type: 'string',\n                  enum: ['after', 'before'],\n                },\n              },\n              additionalProperties: false,\n              required: ['pattern', 'group'],\n            },\n          },\n          'newlines-between': {\n            enum: [\n              'ignore',\n              'always',\n              'always-and-inside-groups',\n              'never',\n            ],\n          },\n          alphabetize: {\n            type: 'object',\n            properties: {\n              caseInsensitive: {\n                type: 'boolean',\n                default: false,\n              },\n              order: {\n                enum: ['ignore', 'asc', 'desc'],\n                default: 'ignore',\n              },\n              orderImportKind: {\n                enum: ['ignore', 'asc', 'desc'],\n                default: 'ignore',\n              },\n            },\n            additionalProperties: false,\n          },\n          warnOnUnassignedImports: {\n            type: 'boolean',\n            default: false,\n          },\n        },\n        additionalProperties: false,\n      },\n    ],\n  },\n\n  create: function importOrderRule(context) {\n    const options = context.options[0] || {};\n    const newlinesBetweenImports = options['newlines-between'] || 'ignore';\n    const pathGroupsExcludedImportTypes = new Set(options.pathGroupsExcludedImportTypes || ['builtin', 'external', 'object']);\n    const alphabetize = getAlphabetizeConfig(options);\n    const distinctGroup = options.distinctGroup == null ? defaultDistinctGroup : !!options.distinctGroup;\n    let ranks;\n\n    try {\n      const { pathGroups, maxPosition } = convertPathGroupsForRanks(options.pathGroups || []);\n      const { groups, omittedTypes } = convertGroupsToRanks(options.groups || defaultGroups);\n      ranks = {\n        groups,\n        omittedTypes,\n        pathGroups,\n        maxPosition,\n      };\n    } catch (error) {\n      // Malformed configuration\n      return {\n        Program(node) {\n          context.report(node, error.message);\n        },\n      };\n    }\n    const importMap = new Map();\n\n    function getBlockImports(node) {\n      if (!importMap.has(node)) {\n        importMap.set(node, []);\n      }\n      return importMap.get(node);\n    }\n\n    return {\n      ImportDeclaration: function handleImports(node) {\n        // Ignoring unassigned imports unless warnOnUnassignedImports is set\n        if (node.specifiers.length || options.warnOnUnassignedImports) {\n          const name = node.source.value;\n          registerNode(\n            context,\n            {\n              node,\n              value: name,\n              displayName: name,\n              type: 'import',\n            },\n            ranks,\n            getBlockImports(node.parent),\n            pathGroupsExcludedImportTypes,\n          );\n        }\n      },\n      TSImportEqualsDeclaration: function handleImports(node) {\n        let displayName;\n        let value;\n        let type;\n        // skip \"export import\"s\n        if (node.isExport) {\n          return;\n        }\n        if (node.moduleReference.type === 'TSExternalModuleReference') {\n          value = node.moduleReference.expression.value;\n          displayName = value;\n          type = 'import';\n        } else {\n          value = '';\n          displayName = context.getSourceCode().getText(node.moduleReference);\n          type = 'import:object';\n        }\n        registerNode(\n          context,\n          {\n            node,\n            value,\n            displayName,\n            type,\n          },\n          ranks,\n          getBlockImports(node.parent),\n          pathGroupsExcludedImportTypes,\n        );\n      },\n      CallExpression: function handleRequires(node) {\n        if (!isStaticRequire(node)) {\n          return;\n        }\n        const block = getRequireBlock(node);\n        if (!block) {\n          return;\n        }\n        const name = node.arguments[0].value;\n        registerNode(\n          context,\n          {\n            node,\n            value: name,\n            displayName: name,\n            type: 'require',\n          },\n          ranks,\n          getBlockImports(block),\n          pathGroupsExcludedImportTypes,\n        );\n      },\n      'Program:exit': function reportAndReset() {\n        importMap.forEach((imported) => {\n          if (newlinesBetweenImports !== 'ignore') {\n            makeNewlinesBetweenReport(context, imported, newlinesBetweenImports, distinctGroup);\n          }\n\n          if (alphabetize.order !== 'ignore') {\n            mutateRanksToAlphabetize(imported, alphabetize);\n          }\n\n          makeOutOfOrderReport(context, imported);\n        });\n\n        importMap.clear();\n      },\n    };\n  },\n};\n"]}