增加井号重复判断

‘liusuyi’

2023-07-03 29d8ea701df5bba27bda837a550853b299207040

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
'use strict';
const { compare, filterOutStabilizedProposals, has, intersection } = require('./helpers');
const data = require('./data');
const entries = require('./entries');
const getModulesListForTargetVersion = require('./get-modules-list-for-target-version');
const allModules = require('./modules');
const targetsParser = require('./targets-parser');
 
function throwInvalidFilter(filter) {
  throw TypeError(`Specified invalid module name or pattern: ${ filter }`);
}
 
function atLeastSomeModules(modules, filter) {
  if (!modules.length) throwInvalidFilter(filter);
  return modules;
}
 
function getModules(filter) {
  if (typeof filter == 'string') {
    if (has(entries, filter)) return entries[filter];
    return atLeastSomeModules(allModules.filter(it => it.startsWith(filter)), filter);
  } else if (filter instanceof RegExp) return atLeastSomeModules(allModules.filter(it => filter.test(it)), filter);
  throwInvalidFilter(filter);
}
 
function normalizeModules(option) {
  // TODO: use `.flatMap` in core-js@4
  return new Set(Array.isArray(option) ? [].concat.apply([], option.map(getModules)) : getModules(option));
}
 
function checkModule(name, targets) {
  const result = {
    required: !targets,
    targets: {},
  };
 
  if (!targets) return result;
 
  const requirements = data[name];
 
  for (const [engine, version] of targets) {
    if (!has(requirements, engine) || compare(version, '<', requirements[engine])) {
      result.required = true;
      result.targets[engine] = version;
    }
  }
 
  return result;
}
 
module.exports = function ({
  filter = null, // TODO: Obsolete, remove from `core-js@4`
  modules = null,
  exclude = [],
  targets = null,
  version = null,
  inverse = false,
} = {}) {
  if (modules == null) modules = filter;
  inverse = !!inverse;
 
  const parsedTargets = targets ? targetsParser(targets) : null;
 
  const result = {
    list: [],
    targets: {},
  };
 
  exclude = normalizeModules(exclude);
 
  modules = modules ? [...normalizeModules(modules)] : allModules;
 
  if (exclude.size) modules = modules.filter(it => !exclude.has(it));
 
  modules = intersection(modules, version ? getModulesListForTargetVersion(version) : allModules);
 
  if (!inverse) modules = filterOutStabilizedProposals(modules);
 
  for (const key of modules) {
    const check = checkModule(key, parsedTargets);
 
    if (check.required ^ inverse) {
      result.list.push(key);
      result.targets[key] = check.targets;
    }
  }
 
  return result;
};