balanced-match 0.4.0 → 1.0.1

package/.github/FUNDING.yml

@@ -0,0 +1,2 @@
+tidelift: 'npm/balanced-match'
+patreon: juliangruber

package/README.md

@@ -12,11 +12,11 @@ Match balanced string pairs, like `{` and `}` or `<b>` and `</b>`. Supports regu
 Get the first matching pair of braces:
 
 ```js
-var balanced = require('balanced-match');
+var balanced = require('balanced-match')
 
-console.log(balanced('{', '}', 'pre{in{nested}}post'));
-console.log(balanced('{', '}', 'pre{first}between{second}post'));
-console.log(balanced(/\s+\{\s+/, /\s+\}\s+/, 'pre  {   in{nest}   }  post'));
+console.log(balanced('{', '}', 'pre{in{nested}}post'))
+console.log(balanced('{', '}', 'pre{first}between{second}post'))
+console.log(balanced(/\s+\{\s+/, /\s+\}\s+/, 'pre  {   in{nest}   }  post'))
 ```
 
 The matches are:
@@ -39,15 +39,15 @@ $ node example.js
 For the first non-nested matching pair of `a` and `b` in `str`, return an
 object with those keys:
 
-* **start** the index of the first match of `a`
-* **end** the index of the matching `b`
-* **pre** the preamble, `a` and `b` not included
-* **body** the match, `a` and `b` not included
-* **post** the postscript, `a` and `b` not included
+- **start** the index of the first match of `a`
+- **end** the index of the matching `b`
+- **pre** the preamble, `a` and `b` not included
+- **body** the match, `a` and `b` not included
+- **post** the postscript, `a` and `b` not included
 
 If there's no match, `undefined` will be returned.
 
-If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `['{', 'a', '']`.
+If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `['{', 'a', '']` and `{a}}` will match `['', 'a', '}']`.
 
 ### var r = balanced.range(a, b, str)
 
@@ -56,7 +56,7 @@ array with indexes: `[ <a index>, <b index> ]`.
 
 If there's no match, `undefined` will be returned.
 
-If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `[ 1, 3 ]`.
+If the `str` contains more `a` than `b` / there are unmatched pairs, the first match that was closed will be used. For example, `{{a}` will match `[ 1, 3 ]` and `{a}}` will match `[0, 2]`.
 
 ## Installation
 
@@ -66,6 +66,12 @@ With [npm](https://npmjs.org) do:
 npm install balanced-match
 ```
 
+## Security contact information
+
+To report a security vulnerability, please use the
+[Tidelift security contact](https://tidelift.com/security).
+Tidelift will coordinate the fix and disclosure.
+
 ## License
 
 (MIT)

package/index.js

@@ -1,58 +1,64 @@
-module.exports = balanced;
-function balanced(a, b, str) {
-  if (a instanceof RegExp) a = maybeMatch(a, str);
-  if (b instanceof RegExp) b = maybeMatch(b, str);
-
-  var r = range(a, b, str);
-
-  return r && {
-    start: r[0],
-    end: r[1],
-    pre: str.slice(0, r[0]),
-    body: str.slice(r[0] + a.length, r[1]),
-    post: str.slice(r[1] + b.length)
-  };
+'use strict'
+module.exports = balanced
+function balanced (a, b, str) {
+  if (a instanceof RegExp) a = maybeMatch(a, str)
+  if (b instanceof RegExp) b = maybeMatch(b, str)
+
+  const r = range(a, b, str)
+
+  return (
+    r && {
+      start: r[0],
+      end: r[1],
+      pre: str.slice(0, r[0]),
+      body: str.slice(r[0] + a.length, r[1]),
+      post: str.slice(r[1] + b.length)
+    }
+  )
 }
 
-function maybeMatch(reg, str) {
-  var m = str.match(reg);
-  return m ? m[0] : null;
+function maybeMatch (reg, str) {
+  const m = str.match(reg)
+  return m ? m[0] : null
 }
 
-balanced.range = range;
-function range(a, b, str) {
-  var begs, beg, left, right, result;
-  var ai = str.indexOf(a);
-  var bi = str.indexOf(b, ai + 1);
-  var i = ai;
+balanced.range = range
+function range (a, b, str) {
+  let begs, beg, left, right, result
+  let ai = str.indexOf(a)
+  let bi = str.indexOf(b, ai + 1)
+  let i = ai
 
   if (ai >= 0 && bi > 0) {
-    begs = [];
-    left = str.length;
-
-    while (i < str.length && i >= 0 && ! result) {
-      if (i == ai) {
-        begs.push(i);
-        ai = str.indexOf(a, i + 1);
-      } else if (begs.length == 1) {
-        result = [ begs.pop(), bi ];
+    if (a === b) {
+      return [ai, bi]
+    }
+    begs = []
+    left = str.length
+
+    while (i >= 0 && !result) {
+      if (i === ai) {
+        begs.push(i)
+        ai = str.indexOf(a, i + 1)
+      } else if (begs.length === 1) {
+        result = [begs.pop(), bi]
       } else {
-        beg = begs.pop();
+        beg = begs.pop()
         if (beg < left) {
-          left = beg;
-          right = bi;
+          left = beg
+          right = bi
         }
 
-        bi = str.indexOf(b, i + 1);
+        bi = str.indexOf(b, i + 1)
       }
 
-      i = ai < bi && ai >= 0 ? ai : bi;
+      i = ai < bi && ai >= 0 ? ai : bi
     }
 
     if (begs.length) {
-      result = [ left, right ];
+      result = [left, right]
     }
   }
 
-  return result;
+  return result
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "balanced-match",
   "description": "Match balanced character pairs, like \"{\" and \"}\"",
-  "version": "0.4.0",
+  "version": "1.0.1",
   "repository": {
     "type": "git",
     "url": "git://github.com/juliangruber/balanced-match.git"
@@ -9,11 +9,16 @@
   "homepage": "https://github.com/juliangruber/balanced-match",
   "main": "index.js",
   "scripts": {
-    "test": "make test"
+    "test": "prettier-standard && standard && tape test/test.js",
+    "bench": "matcha test/bench.js",
+    "release": "np"
   },
-  "dependencies": {},
   "devDependencies": {
-    "tape": "~4.5.0"
+    "@c4312/matcha": "^1.3.1",
+    "np": "^7.4.0",
+    "prettier-standard": "^16.4.1",
+    "standard": "^16.0.3",
+    "tape": "^4.6.0"
   },
   "keywords": [
     "match",

package/.npmignore

@@ -1,2 +0,0 @@
-node_modules
-.DS_Store

package/.travis.yml

@@ -1,3 +0,0 @@
-language: node_js
-node_js:
-  - "0.10"

package/Makefile

@@ -1,6 +0,0 @@
-
-test:
-	@node_modules/.bin/tape test/*.js
-
-.PHONY: test
-

package/example.js

@@ -1,5 +0,0 @@
-var balanced = require('./');
-
-console.log(balanced('{', '}', 'pre{in{nested}}post'));
-console.log(balanced('{', '}', 'pre{first}between{second}post'));
-

package/test/balanced.js

@@ -1,92 +0,0 @@
-var test = require('tape');
-var balanced = require('..');
-
-test('balanced', function(t) {
-  t.deepEqual(balanced('{', '}', 'pre{in{nest}}post'), {
-    start: 3,
-    end: 12,
-    pre: 'pre',
-    body: 'in{nest}',
-    post: 'post'
-  });
-  t.deepEqual(balanced('{', '}', '{{{{{{{{{in}post'), {
-    start: 8,
-    end: 11,
-    pre: '{{{{{{{{',
-    body: 'in',
-    post: 'post'
-  });
-  t.deepEqual(balanced('{', '}', 'pre{body{in}post'), {
-    start: 8,
-    end: 11,
-    pre: 'pre{body',
-    body: 'in',
-    post: 'post'
-  });
-  t.deepEqual(balanced('{', '}', 'pre}{in{nest}}post'), {
-    start: 4,
-    end: 13,
-    pre: 'pre}',
-    body: 'in{nest}',
-    post: 'post'
-  });
-  t.deepEqual(balanced('{', '}', 'pre{body}between{body2}post'), {
-    start: 3,
-    end: 8,
-    pre: 'pre',
-    body: 'body',
-    post: 'between{body2}post'
-  });
-  t.notOk(balanced('{', '}', 'nope'), 'should be notOk');
-  t.deepEqual(balanced('<b>', '</b>', 'pre<b>in<b>nest</b></b>post'), {
-    start: 3,
-    end: 19,
-    pre: 'pre',
-    body: 'in<b>nest</b>',
-    post: 'post'
-  });
-  t.deepEqual(balanced('<b>', '</b>', 'pre</b><b>in<b>nest</b></b>post'), {
-    start: 7,
-    end: 23,
-    pre: 'pre</b>',
-    body: 'in<b>nest</b>',
-    post: 'post'
-  });
-  t.deepEqual(balanced('{{', '}}', 'pre{{{in}}}post'), {
-    start: 3,
-    end: 9,
-    pre: 'pre',
-    body: '{in}',
-    post: 'post'
-  });
-  t.deepEqual(balanced('{{{', '}}', 'pre{{{in}}}post'), {
-    start: 3,
-    end: 8,
-    pre: 'pre',
-    body: 'in',
-    post: '}post'
-  });
-  t.deepEqual(balanced('{', '}', 'pre{{first}in{second}post'), {
-    start: 4,
-    end: 10,
-    pre: 'pre{',
-    body: 'first',
-    post: 'in{second}post'
-  });
-  t.deepEqual(balanced('<?', '?>', 'pre<?>post'), {
-    start: 3,
-    end: 4,
-    pre: 'pre',
-    body: '',
-    post: 'post'
-  });
-  t.notOk(balanced(/\{/, /\}/, 'nope'), 'should be notOk');
-  t.deepEqual(balanced(/\s+\{\s+/, /\s+\}\s+/, 'pre  {   in{nest}   }  post'), {
-    start: 3,
-    end: 17,
-    pre: 'pre',
-    body: 'in{nest}',
-    post: 'post'
-  });
-  t.end();
-});