micromatch 4.0.6 → 4.0.7

package/index.js

@@ -4,13 +4,7 @@ const util = require('util');
 const braces = require('braces');
 const picomatch = require('picomatch');
 const utils = require('picomatch/lib/utils');
-
-const isEmptyString = v => v === '' || v === './';
-const isObject = v => v !== null && typeof v === 'object' && !Array.isArray(v);
-const hasBraces = v => {
-  const index = v.indexOf('{');
-  return index > -1 && v.indexOf('}', index) > -1;
-};
+const isEmptyString = val => val === '' || val === './';
 
 /**
  * Returns an array of strings that match one or more glob patterns.
@@ -34,12 +28,12 @@ const micromatch = (list, patterns, options) => {
   patterns = [].concat(patterns);
   list = [].concat(list);
 
-  const omit = new Set();
-  const keep = new Set();
-  const items = new Set();
+  let omit = new Set();
+  let keep = new Set();
+  let items = new Set();
   let negatives = 0;
 
-  const onResult = state => {
+  let onResult = state => {
     items.add(state.output);
     if (options && options.onResult) {
       options.onResult(state);
@@ -47,14 +41,14 @@ const micromatch = (list, patterns, options) => {
   };
 
   for (let i = 0; i < patterns.length; i++) {
-    const isMatch = picomatch(String(patterns[i]), { windows: true, ...options, onResult }, true);
-    const negated = isMatch.state.negated || isMatch.state.negatedExtglob;
+    let isMatch = picomatch(String(patterns[i]), { ...options, onResult }, true);
+    let negated = isMatch.state.negated || isMatch.state.negatedExtglob;
     if (negated) negatives++;
 
-    for (const item of list) {
-      const matched = isMatch(item, true);
+    for (let item of list) {
+      let matched = isMatch(item, true);
 
-      const match = negated ? !matched.isMatch : matched.isMatch;
+      let match = negated ? !matched.isMatch : matched.isMatch;
       if (!match) continue;
 
       if (negated) {
@@ -66,8 +60,8 @@ const micromatch = (list, patterns, options) => {
     }
   }
 
-  const result = negatives === patterns.length ? [...items] : [...keep];
-  const matches = result.filter(item => !omit.has(item));
+  let result = negatives === patterns.length ? [...items] : [...keep];
+  let matches = result.filter(item => !omit.has(item));
 
   if (options && matches.length === 0) {
     if (options.failglob === true) {
@@ -100,17 +94,14 @@ micromatch.match = micromatch;
  * const isMatch = mm.matcher('*.!(*a)');
  * console.log(isMatch('a.a')); //=> false
  * console.log(isMatch('a.b')); //=> true
- *
- * const isMatch = mm.matcher(['b.*', '*.a']);
- * console.log(isMatch('a.a')); //=> true
  * ```
- * @param {String|Array} `pattern` One or more glob patterns to use for matching.
+ * @param {String} `pattern` Glob pattern
  * @param {Object} `options`
  * @return {Function} Returns a matcher function.
  * @api public
  */
 
-micromatch.matcher = (pattern, options) => picomatch(pattern, { windows: true, ...options });
+micromatch.matcher = (pattern, options) => picomatch(pattern, options);
 
 /**
  * Returns true if **any** of the given glob `patterns` match the specified `string`.
@@ -156,17 +147,17 @@ micromatch.any = micromatch.isMatch;
 
 micromatch.not = (list, patterns, options = {}) => {
   patterns = [].concat(patterns).map(String);
-  const result = new Set();
-  const items = [];
+  let result = new Set();
+  let items = [];
 
-  const onResult = state => {
+  let onResult = state => {
     if (options.onResult) options.onResult(state);
     items.push(state.output);
   };
 
-  const matches = new Set(micromatch(list, patterns, { ...options, onResult }));
+  let matches = new Set(micromatch(list, patterns, { ...options, onResult }));
 
-  for (const item of items) {
+  for (let item of items) {
     if (!matches.has(item)) {
       result.add(item);
     }
@@ -237,12 +228,12 @@ micromatch.contains = (str, pattern, options) => {
  */
 
 micromatch.matchKeys = (obj, patterns, options) => {
-  if (!isObject(obj)) {
+  if (!utils.isObject(obj)) {
     throw new TypeError('Expected the first argument to be an object');
   }
-  const keys = micromatch(Object.keys(obj), patterns, options);
-  const res = {};
-  for (const key of keys) res[key] = obj[key];
+  let keys = micromatch(Object.keys(obj), patterns, options);
+  let res = {};
+  for (let key of keys) res[key] = obj[key];
   return res;
 };
 
@@ -266,10 +257,10 @@ micromatch.matchKeys = (obj, patterns, options) => {
  */
 
 micromatch.some = (list, patterns, options) => {
-  const items = [].concat(list);
+  let items = [].concat(list);
 
-  for (const pattern of [].concat(patterns)) {
-    const isMatch = picomatch(String(pattern), { windows: true, ...options });
+  for (let pattern of [].concat(patterns)) {
+    let isMatch = picomatch(String(pattern), options);
     if (items.some(item => isMatch(item))) {
       return true;
     }
@@ -302,10 +293,10 @@ micromatch.some = (list, patterns, options) => {
  */
 
 micromatch.every = (list, patterns, options) => {
-  const items = [].concat(list);
+  let items = [].concat(list);
 
-  for (const pattern of [].concat(patterns)) {
-    const isMatch = picomatch(String(pattern), { windows: true, ...options });
+  for (let pattern of [].concat(patterns)) {
+    let isMatch = picomatch(String(pattern), options);
     if (!items.every(item => isMatch(item))) {
       return false;
     }
@@ -345,7 +336,7 @@ micromatch.all = (str, patterns, options) => {
     throw new TypeError(`Expected a string: "${util.inspect(str)}"`);
   }
 
-  return [].concat(patterns).every(p => picomatch(p, { windows: true, ...options })(str));
+  return [].concat(patterns).every(p => picomatch(p, options)(str));
 };
 
 /**
@@ -368,9 +359,9 @@ micromatch.all = (str, patterns, options) => {
  */
 
 micromatch.capture = (glob, input, options) => {
-  const windows = utils.isWindows(options);
-  const regex = picomatch.makeRe(String(glob), { windows: true, ...options, capture: true });
-  const match = regex.exec(windows ? utils.toPosixSlashes(input) : input);
+  let posix = utils.isWindows(options);
+  let regex = picomatch.makeRe(String(glob), { ...options, capture: true });
+  let match = regex.exec(posix ? utils.toPosixSlashes(input) : input);
 
   if (match) {
     return match.slice(1).map(v => v === void 0 ? '' : v);
@@ -393,7 +384,7 @@ micromatch.capture = (glob, input, options) => {
  * @api public
  */
 
-micromatch.makeRe = (pattern, options) => picomatch.makeRe(pattern, { windows: true, ...options });
+micromatch.makeRe = (...args) => picomatch.makeRe(...args);
 
 /**
  * Scan a glob pattern to separate the pattern into segments. Used
@@ -409,7 +400,7 @@ micromatch.makeRe = (pattern, options) => picomatch.makeRe(pattern, { windows: t
  * @api public
  */
 
-micromatch.scan = (pattern, options) => picomatch.scan(pattern, { windows: true, ...options });
+micromatch.scan = (...args) => picomatch.scan(...args);
 
 /**
  * Parse a glob pattern to create the source string for a regular
@@ -426,10 +417,10 @@ micromatch.scan = (pattern, options) => picomatch.scan(pattern, { windows: true,
  */
 
 micromatch.parse = (patterns, options) => {
-  const res = [];
-  for (const pattern of [].concat(patterns || [])) {
-    for (const str of braces(String(pattern), options)) {
-      res.push(picomatch.parse(str, { windows: utils.isWindows(), ...options }));
+  let res = [];
+  for (let pattern of [].concat(patterns || [])) {
+    for (let str of braces(String(pattern), options)) {
+      res.push(picomatch.parse(str, options));
     }
   }
   return res;
@@ -454,7 +445,7 @@ micromatch.parse = (patterns, options) => {
 
 micromatch.braces = (pattern, options) => {
   if (typeof pattern !== 'string') throw new TypeError('Expected a string');
-  if ((options && options.nobrace === true) || !hasBraces(pattern)) {
+  if ((options && options.nobrace === true) || !/\{.*\}/.test(pattern)) {
     return [pattern];
   }
   return braces(pattern, options);
@@ -473,6 +464,4 @@ micromatch.braceExpand = (pattern, options) => {
  * Expose micromatch
  */
 
-// exposed for tests
-micromatch.hasBraces = hasBraces;
 module.exports = micromatch;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "micromatch",
   "description": "Glob matching for javascript/node.js. A replacement and faster alternative to minimatch and multimatch.",
-  "version": "4.0.6",
+  "version": "4.0.7",
   "homepage": "https://github.com/micromatch/micromatch",
   "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
   "contributors": [
@@ -26,9 +26,7 @@
     "url": "https://github.com/micromatch/micromatch/issues"
   },
   "license": "MIT",
-  "files": [
-    "index.js"
-  ],
+  "files": ["index.js"],
   "main": "index.js",
   "engines": {
     "node": ">=8.6"
@@ -38,13 +36,13 @@
   },
   "dependencies": {
     "braces": "^3.0.3",
-    "picomatch": "^4.0.2"
+    "picomatch": "^2.3.1"
   },
   "devDependencies": {
     "fill-range": "^7.0.1",
     "gulp-format-md": "^2.0.0",
-    "minimatch": "^9.0.3",
-    "mocha": "^10.4.0",
+    "minimatch": "^5.0.1",
+    "mocha": "^9.2.2",
     "time-require": "github:jonschlinkert/time-require"
   },
   "keywords": [
@@ -90,30 +88,14 @@
   "verb": {
     "toc": "collapsible",
     "layout": "default",
-    "tasks": [
-      "readme"
-    ],
-    "plugins": [
-      "gulp-format-md"
-    ],
+    "tasks": ["readme"],
+    "plugins": ["gulp-format-md"],
     "lint": {
       "reflinks": true
     },
     "related": {
-      "list": [
-        "braces",
-        "expand-brackets",
-        "extglob",
-        "fill-range",
-        "nanomatch"
-      ]
+      "list": ["braces", "expand-brackets", "extglob", "fill-range", "nanomatch"]
     },
-    "reflinks": [
-      "extglob",
-      "fill-range",
-      "glob-object",
-      "minimatch",
-      "multimatch"
-    ]
+    "reflinks": ["extglob", "fill-range", "glob-object", "minimatch", "multimatch"]
   }
 }