brace-expansion 2.0.1 → 3.0.0

package/.github/workflows/ci.yml

@@ -0,0 +1,15 @@
+name: CI
+on: [push]
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node: ['18', '20']
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: ${{ matrix.node }}
+      - run: npm ci
+      - run: npm test

package/README.md

@@ -1,18 +1,15 @@
 # brace-expansion
 
-[Brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html), 
+[Brace expansion](https://www.gnu.org/software/bash/manual/html_node/Brace-Expansion.html),
 as known from sh/bash, in JavaScript.
 
-[![build status](https://secure.travis-ci.org/juliangruber/brace-expansion.svg)](http://travis-ci.org/juliangruber/brace-expansion)
+[![CI](https://github.com/juliangruber/brace-expansion/actions/workflows/ci.yml/badge.svg)](https://github.com/juliangruber/brace-expansion/actions/workflows/ci.yml)
 [![downloads](https://img.shields.io/npm/dm/brace-expansion.svg)](https://www.npmjs.org/package/brace-expansion)
-[![Greenkeeper badge](https://badges.greenkeeper.io/juliangruber/brace-expansion.svg)](https://greenkeeper.io/)
-
-[![testling badge](https://ci.testling.com/juliangruber/brace-expansion.png)](https://ci.testling.com/juliangruber/brace-expansion)
 
 ## Example
 
 ```js
-var expand = require('brace-expansion');
+import expand from 'brace-expansion'
 
 expand('file-{a,b,c}.jpg')
 // => ['file-a.jpg', 'file-b.jpg', 'file-c.jpg']
@@ -48,10 +45,10 @@ expand('ppp{,config,oe{,conf}}')
 ## API
 
 ```js
-var expand = require('brace-expansion');
+import expand from 'brace-expansion'
 ```
 
-### var expanded = expand(str)
+### const expanded = expand(str)
 
 Return an array of all possible and valid expansions of `str`. If none are
 found, `[str]` is returned.
@@ -97,6 +94,7 @@ npm install brace-expansion
 
 - [Julian Gruber](https://github.com/juliangruber)
 - [Isaac Z. Schlueter](https://github.com/isaacs)
+- [Haelwenn Monnier](https://github.com/lanodan)
 
 ## Sponsors
 

package/bench/bench.js

@@ -0,0 +1,13 @@
+/* global bench */
+
+import expand from '..'
+import fs from 'fs'
+
+const resfile = new URL('../test/cases.txt', import.meta.url)
+const cases = fs.readFileSync(resfile, 'utf8').split('\n')
+
+bench('Average', function () {
+  cases.forEach(function (testcase) {
+    expand(testcase)
+  })
+})

package/index.js

@@ -1,69 +1,76 @@
-var balanced = require('balanced-match');
-
-module.exports = expandTop;
-
-var escSlash = '\0SLASH'+Math.random()+'\0';
-var escOpen = '\0OPEN'+Math.random()+'\0';
-var escClose = '\0CLOSE'+Math.random()+'\0';
-var escComma = '\0COMMA'+Math.random()+'\0';
-var escPeriod = '\0PERIOD'+Math.random()+'\0';
-
-function numeric(str) {
-  return parseInt(str, 10) == str
+import balanced from 'balanced-match'
+
+const escSlash = '\0SLASH' + Math.random() + '\0'
+const escOpen = '\0OPEN' + Math.random() + '\0'
+const escClose = '\0CLOSE' + Math.random() + '\0'
+const escComma = '\0COMMA' + Math.random() + '\0'
+const escPeriod = '\0PERIOD' + Math.random() + '\0'
+
+/**
+ * @return {number}
+ */
+function numeric (str) {
+  return !isNaN(str)
     ? parseInt(str, 10)
-    : str.charCodeAt(0);
+    : str.charCodeAt(0)
 }
 
-function escapeBraces(str) {
+/**
+ * @param {string} str
+ */
+function escapeBraces (str) {
   return str.split('\\\\').join(escSlash)
-            .split('\\{').join(escOpen)
-            .split('\\}').join(escClose)
-            .split('\\,').join(escComma)
-            .split('\\.').join(escPeriod);
+    .split('\\{').join(escOpen)
+    .split('\\}').join(escClose)
+    .split('\\,').join(escComma)
+    .split('\\.').join(escPeriod)
 }
 
-function unescapeBraces(str) {
+/**
+ * @param {string} str
+ */
+function unescapeBraces (str) {
   return str.split(escSlash).join('\\')
-            .split(escOpen).join('{')
-            .split(escClose).join('}')
-            .split(escComma).join(',')
-            .split(escPeriod).join('.');
+    .split(escOpen).join('{')
+    .split(escClose).join('}')
+    .split(escComma).join(',')
+    .split(escPeriod).join('.')
 }
 
+/**
+ * Basically just str.split(","), but handling cases
+ * where we have nested braced sections, which should be
+ * treated as individual members, like {a,{b,c},d}
+ * @param {string} str
+ */
+function parseCommaParts (str) {
+  if (!str) { return [''] }
 
-// Basically just str.split(","), but handling cases
-// where we have nested braced sections, which should be
-// treated as individual members, like {a,{b,c},d}
-function parseCommaParts(str) {
-  if (!str)
-    return [''];
-
-  var parts = [];
-  var m = balanced('{', '}', str);
+  const parts = []
+  const m = balanced('{', '}', str)
 
-  if (!m)
-    return str.split(',');
+  if (!m) { return str.split(',') }
 
-  var pre = m.pre;
-  var body = m.body;
-  var post = m.post;
-  var p = pre.split(',');
+  const { pre, body, post } = m
+  const p = pre.split(',')
 
-  p[p.length-1] += '{' + body + '}';
-  var postParts = parseCommaParts(post);
+  p[p.length - 1] += '{' + body + '}'
+  const postParts = parseCommaParts(post)
   if (post.length) {
-    p[p.length-1] += postParts.shift();
-    p.push.apply(p, postParts);
+    p[p.length - 1] += postParts.shift()
+    p.push.apply(p, postParts)
   }
 
-  parts.push.apply(parts, p);
+  parts.push.apply(parts, p)
 
-  return parts;
+  return parts
 }
 
-function expandTop(str) {
-  if (!str)
-    return [];
+/**
+ * @param {string} str
+ */
+export default function expandTop (str) {
+  if (!str) { return [] }
 
   // I don't know why Bash 4.3 does this, but it does.
   // Anything starting with {} will have the first two bytes preserved
@@ -71,133 +78,148 @@ function expandTop(str) {
   // but a{},b}c will be expanded to [a}c,abc].
   // One could argue that this is a bug in Bash, but since the goal of
   // this module is to match Bash's rules, we escape a leading {}
-  if (str.substr(0, 2) === '{}') {
-    str = '\\{\\}' + str.substr(2);
+  if (str.slice(0, 2) === '{}') {
+    str = '\\{\\}' + str.slice(2)
   }
 
-  return expand(escapeBraces(str), true).map(unescapeBraces);
+  return expand(escapeBraces(str), true).map(unescapeBraces)
 }
 
-function embrace(str) {
-  return '{' + str + '}';
+/**
+ * @param {string} str
+ */
+function embrace (str) {
+  return '{' + str + '}'
 }
-function isPadded(el) {
-  return /^-?0\d/.test(el);
+
+/**
+ * @param {string} el
+ */
+function isPadded (el) {
+  return /^-?0\d/.test(el)
 }
 
-function lte(i, y) {
-  return i <= y;
+/**
+ * @param {number} i
+ * @param {number} y
+ */
+function lte (i, y) {
+  return i <= y
 }
-function gte(i, y) {
-  return i >= y;
+
+/**
+ * @param {number} i
+ * @param {number} y
+ */
+function gte (i, y) {
+  return i >= y
 }
 
-function expand(str, isTop) {
-  var expansions = [];
+/**
+ * @param {string} str
+ * @param {boolean} [isTop]
+ */
+function expand (str, isTop) {
+  /** @type {string[]} */
+  const expansions = []
 
-  var m = balanced('{', '}', str);
-  if (!m) return [str];
+  const m = balanced('{', '}', str)
+  if (!m) return [str]
 
   // no need to expand pre, since it is guaranteed to be free of brace-sets
-  var pre = m.pre;
-  var post = m.post.length
+  const pre = m.pre
+  const post = m.post.length
     ? expand(m.post, false)
-    : [''];
+    : ['']
 
-  if (/\$$/.test(m.pre)) {    
-    for (var k = 0; k < post.length; k++) {
-      var expansion = pre+ '{' + m.body + '}' + post[k];
-      expansions.push(expansion);
+  if (/\$$/.test(m.pre)) {
+    for (let k = 0; k < post.length; k++) {
+      const expansion = pre + '{' + m.body + '}' + post[k]
+      expansions.push(expansion)
     }
   } else {
-    var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-    var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-    var isSequence = isNumericSequence || isAlphaSequence;
-    var isOptions = m.body.indexOf(',') >= 0;
+    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body)
+    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body)
+    const isSequence = isNumericSequence || isAlphaSequence
+    const isOptions = m.body.indexOf(',') >= 0
     if (!isSequence && !isOptions) {
       // {a},b}
       if (m.post.match(/,.*\}/)) {
-        str = m.pre + '{' + m.body + escClose + m.post;
-        return expand(str);
+        str = m.pre + '{' + m.body + escClose + m.post
+        return expand(str)
       }
-      return [str];
+      return [str]
     }
 
-    var n;
+    let n
     if (isSequence) {
-      n = m.body.split(/\.\./);
+      n = m.body.split(/\.\./)
     } else {
-      n = parseCommaParts(m.body);
+      n = parseCommaParts(m.body)
       if (n.length === 1) {
         // x{{a,b}}y ==> x{a}y x{b}y
-        n = expand(n[0], false).map(embrace);
+        n = expand(n[0], false).map(embrace)
         if (n.length === 1) {
-          return post.map(function(p) {
-            return m.pre + n[0] + p;
-          });
+          return post.map(function (p) {
+            return m.pre + n[0] + p
+          })
         }
       }
     }
 
     // at this point, n is the parts, and we know it's not a comma set
     // with a single entry.
-    var N;
+    let N
 
     if (isSequence) {
-      var x = numeric(n[0]);
-      var y = numeric(n[1]);
-      var width = Math.max(n[0].length, n[1].length)
-      var incr = n.length == 3
+      const x = numeric(n[0])
+      const y = numeric(n[1])
+      const width = Math.max(n[0].length, n[1].length)
+      let incr = n.length === 3
         ? Math.abs(numeric(n[2]))
-        : 1;
-      var test = lte;
-      var reverse = y < x;
+        : 1
+      let test = lte
+      const reverse = y < x
       if (reverse) {
-        incr *= -1;
-        test = gte;
+        incr *= -1
+        test = gte
       }
-      var pad = n.some(isPadded);
+      const pad = n.some(isPadded)
 
-      N = [];
+      N = []
 
-      for (var i = x; test(i, y); i += incr) {
-        var c;
+      for (let i = x; test(i, y); i += incr) {
+        let c
         if (isAlphaSequence) {
-          c = String.fromCharCode(i);
-          if (c === '\\')
-            c = '';
+          c = String.fromCharCode(i)
+          if (c === '\\') { c = '' }
         } else {
-          c = String(i);
+          c = String(i)
           if (pad) {
-            var need = width - c.length;
+            const need = width - c.length
             if (need > 0) {
-              var z = new Array(need + 1).join('0');
-              if (i < 0)
-                c = '-' + z + c.slice(1);
-              else
-                c = z + c;
+              const z = new Array(need + 1).join('0')
+              if (i < 0) { c = '-' + z + c.slice(1) } else { c = z + c }
             }
           }
         }
-        N.push(c);
+        N.push(c)
       }
     } else {
-      N = [];
+      N = []
 
-      for (var j = 0; j < n.length; j++) {
-        N.push.apply(N, expand(n[j], false));
+      for (let j = 0; j < n.length; j++) {
+        N.push.apply(N, expand(n[j], false))
       }
     }
 
-    for (var j = 0; j < N.length; j++) {
-      for (var k = 0; k < post.length; k++) {
-        var expansion = pre + N[j] + post[k];
-        if (!isTop || isSequence || expansion)
-          expansions.push(expansion);
+    for (let j = 0; j < N.length; j++) {
+      for (let k = 0; k < post.length; k++) {
+        const expansion = pre + N[j] + post[k]
+        if (!isTop || isSequence || expansion) { expansions.push(expansion) }
       }
     }
   }
 
-  return expansions;
+  return expansions
 }
-

package/package.json

@@ -1,24 +1,25 @@
 {
   "name": "brace-expansion",
   "description": "Brace expansion as known from sh/bash",
-  "version": "2.0.1",
+  "version": "3.0.0",
   "repository": {
     "type": "git",
     "url": "git://github.com/juliangruber/brace-expansion.git"
   },
   "homepage": "https://github.com/juliangruber/brace-expansion",
-  "main": "index.js",
+  "exports": "./index.js",
+  "type": "module",
   "scripts": {
-    "test": "tape test/*.js",
+    "test": "standard --fix && node --test",
     "gentest": "bash test/generate.sh",
-    "bench": "matcha test/perf/bench.js"
+    "bench": "matcha bench/bench.js"
   },
   "dependencies": {
-    "balanced-match": "^1.0.0"
+    "balanced-match": "^3.0.0"
   },
   "devDependencies": {
     "@c4312/matcha": "^1.3.1",
-    "tape": "^4.6.0"
+    "standard": "^17.1.0"
   },
   "keywords": [],
   "author": {
@@ -42,5 +43,8 @@
       "iphone/6.0..latest",
       "android-browser/4.2..latest"
     ]
+  },
+  "engines": {
+    "node": ">= 18"
   }
 }