string-match-left-right 7.1.0 → 8.0.3

package/CHANGELOG.md

@@ -3,6 +3,36 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## 8.0.3 (2021-11-02)
+
+### Bug Fixes
+
+- bump TS and separate ESLint plugins away from this monorepo ([b1ebce1](https://github.com/codsen/codsen/commit/b1ebce1637d8c41c2d848fc24b0ba4058865bd5d))
+
+### Features
+
+- migrate to ES Modules ([c579dff](https://github.com/codsen/codsen/commit/c579dff3b23205e383035ca10ddcec671e35d0fe))
+
+### BREAKING CHANGES
+
+- programs now are in ES Modules and won't work with Common JS require()
+
+## 8.0.1 (2021-09-13)
+
+### Bug Fixes
+
+- bump TS and separate ESLint plugins away from this monorepo ([2e07d42](https://github.com/codsen/codsen/commit/2e07d424222b6ffedf5fb45c83ad453627ec2904))
+
+## 8.0.0 (2021-09-09)
+
+### Features
+
+- migrate to ES Modules ([8c9d95d](https://github.com/codsen/codsen/commit/8c9d95d5dea0b769c2f070397141918a4893d575))
+
+### BREAKING CHANGES
+
+- programs now are in ES Modules and won't work with Common JS require()
+
 ## 7.1.0 (2021-05-24)
 
 ### Features

package/README.md

@@ -26,10 +26,14 @@
 
 ## Install
 
+This package is ESM only: Node 12+ is needed to use it and it must be imported instead of required:
+
 ```bash
 npm i string-match-left-right
 ```
 
+If you need a legacy version which works with `require`, use version 7.1.0
+
 ## Quick Take
 
 ```js

package/dist/string-match-left-right.esm.js

@@ -1,7 +1,7 @@
 /**
  * @name string-match-left-right
  * @fileoverview Match substrings on the left or right of a given index, ignoring whitespace
- * @version 7.1.0
+ * @version 8.0.3
  * @author Roy Revelt, Codsen Ltd
  * @license MIT
  * {@link https://codsen.com/os/string-match-left-right/}
@@ -207,52 +207,52 @@ function main(mode, str, position, originalWhatToMatch, originalOpts) {
   Array.isArray(whatToMatch) && !whatToMatch.length ||
   Array.isArray(whatToMatch) && whatToMatch.length === 1 && isStr(whatToMatch[0]) && !whatToMatch[0].trim()
   ) {
-      if (typeof opts.cb === "function") {
-        let firstCharOutsideIndex;
-        let startingPosition = position;
-        if (mode === "matchLeftIncl" || mode === "matchRight") {
-          startingPosition += 1;
-        }
-        if (mode[5] === "L") {
-          for (let y = startingPosition; y--;) {
-            const currentChar = str[y];
-            if ((!opts.trimBeforeMatching || opts.trimBeforeMatching && currentChar !== undefined && currentChar.trim()) && (!opts.trimCharsBeforeMatching || !opts.trimCharsBeforeMatching.length || currentChar !== undefined && !opts.trimCharsBeforeMatching.includes(currentChar))) {
-              firstCharOutsideIndex = y;
-              break;
-            }
-          }
-        } else if (mode.startsWith("matchRight")) {
-          for (let y = startingPosition; y < str.length; y++) {
-            const currentChar = str[y];
-            if ((!opts.trimBeforeMatching || opts.trimBeforeMatching && currentChar.trim()) && (!opts.trimCharsBeforeMatching || !opts.trimCharsBeforeMatching.length || !opts.trimCharsBeforeMatching.includes(currentChar))) {
-              firstCharOutsideIndex = y;
-              break;
-            }
+    if (typeof opts.cb === "function") {
+      let firstCharOutsideIndex;
+      let startingPosition = position;
+      if (mode === "matchLeftIncl" || mode === "matchRight") {
+        startingPosition += 1;
+      }
+      if (mode[5] === "L") {
+        for (let y = startingPosition; y--;) {
+          const currentChar = str[y];
+          if ((!opts.trimBeforeMatching || opts.trimBeforeMatching && currentChar !== undefined && currentChar.trim()) && (!opts.trimCharsBeforeMatching || !opts.trimCharsBeforeMatching.length || currentChar !== undefined && !opts.trimCharsBeforeMatching.includes(currentChar))) {
+            firstCharOutsideIndex = y;
+            break;
           }
         }
-        if (firstCharOutsideIndex === undefined) {
-          return false;
-        }
-        const wholeCharacterOutside = str[firstCharOutsideIndex];
-        const indexOfTheCharacterAfter = firstCharOutsideIndex + 1;
-        let theRemainderOfTheString = "";
-        if (indexOfTheCharacterAfter && indexOfTheCharacterAfter > 0) {
-          theRemainderOfTheString = str.slice(0, indexOfTheCharacterAfter);
-        }
-        if (mode[5] === "L") {
-          return opts.cb(wholeCharacterOutside, theRemainderOfTheString, firstCharOutsideIndex);
-        }
-        if (firstCharOutsideIndex && firstCharOutsideIndex > 0) {
-          theRemainderOfTheString = str.slice(firstCharOutsideIndex);
+      } else if (mode.startsWith("matchRight")) {
+        for (let y = startingPosition; y < str.length; y++) {
+          const currentChar = str[y];
+          if ((!opts.trimBeforeMatching || opts.trimBeforeMatching && currentChar.trim()) && (!opts.trimCharsBeforeMatching || !opts.trimCharsBeforeMatching.length || !opts.trimCharsBeforeMatching.includes(currentChar))) {
+            firstCharOutsideIndex = y;
+            break;
+          }
         }
+      }
+      if (firstCharOutsideIndex === undefined) {
+        return false;
+      }
+      const wholeCharacterOutside = str[firstCharOutsideIndex];
+      const indexOfTheCharacterAfter = firstCharOutsideIndex + 1;
+      let theRemainderOfTheString = "";
+      if (indexOfTheCharacterAfter && indexOfTheCharacterAfter > 0) {
+        theRemainderOfTheString = str.slice(0, indexOfTheCharacterAfter);
+      }
+      if (mode[5] === "L") {
         return opts.cb(wholeCharacterOutside, theRemainderOfTheString, firstCharOutsideIndex);
       }
-      let extraNote = "";
-      if (!originalOpts) {
-        extraNote = " More so, the whole options object, the fourth input argument, is missing!";
+      if (firstCharOutsideIndex && firstCharOutsideIndex > 0) {
+        theRemainderOfTheString = str.slice(firstCharOutsideIndex);
       }
-      throw new Error(`string-match-left-right/${mode}(): [THROW_ID_08] the third argument, "whatToMatch", was given as an empty string. This means, you intend to match purely by a callback. The callback was not set though, the opts key "cb" is not set!${extraNote}`);
+      return opts.cb(wholeCharacterOutside, theRemainderOfTheString, firstCharOutsideIndex);
     }
+    let extraNote = "";
+    if (!originalOpts) {
+      extraNote = " More so, the whole options object, the fourth input argument, is missing!";
+    }
+    throw new Error(`string-match-left-right/${mode}(): [THROW_ID_08] the third argument, "whatToMatch", was given as an empty string. This means, you intend to match purely by a callback. The callback was not set though, the opts key "cb" is not set!${extraNote}`);
+  }
   for (let i = 0, len = whatToMatch.length; i < len; i++) {
     special = typeof whatToMatch[i] === "function";
     const whatToMatchVal = whatToMatch[i];

package/dist/string-match-left-right.umd.js

@@ -1,7 +1,7 @@
 /**
  * @name string-match-left-right
  * @fileoverview Match substrings on the left or right of a given index, ignoring whitespace
- * @version 7.1.0
+ * @version 8.0.3
  * @author Roy Revelt, Codsen Ltd
  * @license MIT
  * {@link https://codsen.com/os/string-match-left-right/}
@@ -11,7 +11,7 @@
 /**
  * @name arrayiffy-if-string
  * @fileoverview Put non-empty strings into arrays, turn empty-ones into empty arrays. Bypass everything else.
- * @version 3.14.0
+ * @version 4.0.3
  * @author Roy Revelt, Codsen Ltd
  * @license MIT
  * {@link https://codsen.com/os/arrayiffy-if-string/}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "string-match-left-right",
-  "version": "7.1.0",
+  "version": "8.0.3",
   "description": "Match substrings on the left or right of a given index, ignoring whitespace",
   "keywords": [
     "left",
@@ -24,17 +24,21 @@
     "email": "roy@codsen.com",
     "url": "https://codsen.com"
   },
-  "main": "dist/string-match-left-right.cjs.js",
-  "module": "dist/string-match-left-right.esm.js",
-  "browser": "dist/string-match-left-right.umd.js",
+  "type": "module",
+  "exports": {
+    "script": "./dist/string-match-left-right.umd.js",
+    "default": "./dist/string-match-left-right.esm.js"
+  },
   "types": "types/index.d.ts",
   "scripts": {
     "build": "rollup -c",
-    "esbuild": "node '../../scripts/esbuild.js'",
-    "esbuild_dev": "cross-env MODE=dev node '../../scripts/esbuild.js'",
     "ci_test": "npm run build && npm run format && tap --no-only --reporter=silent --output-file=testStats.md && npm run clean_cov",
+    "clean_cov": "../../scripts/leaveCoverageTotalOnly.js",
+    "clean_types": "../../scripts/cleanTypes.js",
     "dev": "rollup -c --dev",
     "devunittest": "npm run dev && tap --only -R 'base'",
+    "esbuild": "node '../../scripts/esbuild.js'",
+    "esbuild_dev": "cross-env MODE=dev node '../../scripts/esbuild.js'",
     "format": "npm run lect && npm run prettier && npm run lint",
     "lect": "lect",
     "lint": "../../node_modules/eslint/bin/eslint.js . --ext .js --ext .ts --fix --config \"../../.eslintrc.json\" --quiet",
@@ -42,22 +46,22 @@
     "prettier": "../../node_modules/prettier/bin-prettier.js '*.{js,css,scss,vue,md,ts}' --write --loglevel silent",
     "republish": "npm publish || :",
     "tap": "tap",
-    "tsc": "tsc",
     "pretest": "npm run build",
     "test": "npm run lint && npm run unittest && npm run test:examples && npm run clean_cov && npm run format",
     "test:examples": "../../scripts/test-examples.js && npm run lect && npm run prettier",
-    "unittest": "./node_modules/.bin/tap --no-only --output-file=testStats.md --reporter=terse && tsc -p tsconfig.json --noEmit && npm run clean_cov && npm run perf",
-    "clean_cov": "../../scripts/leaveCoverageTotalOnly.js",
-    "clean_types": "../../scripts/cleanTypes.js"
+    "tsc": "tsc",
+    "unittest": "tap --no-only --output-file=testStats.md --reporter=terse && tsc -p tsconfig.json --noEmit && npm run clean_cov && npm run perf"
   },
   "tap": {
+    "check-coverage": false,
     "coverage-report": [
       "json-summary",
       "text"
     ],
-    "nyc-arg": [
-      "--exclude=**/*.cjs.js",
-      "--exclude=**/*.umd.js"
+    "node-arg": [
+      "--no-warnings",
+      "--experimental-loader",
+      "@istanbuljs/esm-loader-hook"
     ],
     "timeout": 0
   },
@@ -75,46 +79,50 @@
     }
   },
   "dependencies": {
-    "@babel/runtime": "^7.14.0",
-    "arrayiffy-if-string": "^3.14.0",
+    "@babel/runtime": "^7.16.0",
+    "arrayiffy-if-string": "^4.0.3",
     "lodash.isplainobject": "^4.0.6",
-    "string-character-is-astral-surrogate": "^1.13.0"
+    "string-character-is-astral-surrogate": "^2.0.3"
   },
   "devDependencies": {
-    "@babel/cli": "^7.14.3",
-    "@babel/core": "^7.14.3",
-    "@babel/node": "^7.14.2",
-    "@babel/plugin-external-helpers": "^7.12.13",
-    "@babel/plugin-proposal-class-properties": "^7.13.0",
-    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.14.2",
-    "@babel/plugin-proposal-object-rest-spread": "^7.14.2",
-    "@babel/plugin-proposal-optional-chaining": "^7.14.2",
-    "@babel/plugin-transform-runtime": "^7.14.3",
-    "@babel/preset-env": "^7.14.2",
-    "@babel/preset-typescript": "^7.13.0",
-    "@babel/register": "^7.13.16",
+    "@babel/cli": "^7.16.0",
+    "@babel/core": "^7.16.0",
+    "@babel/node": "^7.16.0",
+    "@babel/plugin-external-helpers": "^7.16.0",
+    "@babel/plugin-proposal-class-properties": "^7.16.0",
+    "@babel/plugin-proposal-nullish-coalescing-operator": "^7.16.0",
+    "@babel/plugin-proposal-object-rest-spread": "^7.16.0",
+    "@babel/plugin-proposal-optional-chaining": "^7.16.0",
+    "@babel/plugin-transform-runtime": "^7.16.0",
+    "@babel/preset-env": "^7.16.0",
+    "@babel/preset-typescript": "^7.16.0",
+    "@babel/register": "^7.16.0",
+    "@istanbuljs/esm-loader-hook": "^0.1.2",
     "@rollup/plugin-babel": "^5.3.0",
-    "@rollup/plugin-commonjs": "^19.0.0",
-    "@rollup/plugin-node-resolve": "^13.0.0",
-    "@rollup/plugin-strip": "^2.0.1",
-    "@rollup/plugin-typescript": "^8.2.1",
+    "@rollup/plugin-commonjs": "^21.0.1",
+    "@rollup/plugin-node-resolve": "^13.0.6",
+    "@rollup/plugin-strip": "^2.1.0",
+    "@rollup/plugin-typescript": "^8.3.0",
     "@types/lodash.isplainobject": "^4.0.6",
-    "@types/node": "^15.6.0",
-    "@types/tap": "^15.0.1",
-    "@typescript-eslint/eslint-plugin": "^4.24.0",
-    "@typescript-eslint/parser": "^4.24.0",
-    "core-js": "^3.12.1",
+    "@types/node": "^16.11.6",
+    "@types/tap": "^15.0.5",
+    "@typescript-eslint/eslint-plugin": "^5.2.0",
+    "@typescript-eslint/parser": "^5.2.0",
+    "core-js": "^3.19.0",
     "cross-env": "^7.0.3",
-    "eslint": "^7.27.0",
-    "lect": "^0.17.0",
-    "rollup": "^2.49.0",
+    "eslint": "^8.1.0",
+    "lect": "^0.18.3",
+    "rollup": "^2.59.0",
     "rollup-plugin-ascii": "^0.0.3",
     "rollup-plugin-banner": "^0.2.1",
     "rollup-plugin-cleanup": "^3.2.1",
-    "rollup-plugin-dts": "^3.0.1",
+    "rollup-plugin-dts": "^4.0.0",
     "rollup-plugin-terser": "^7.0.2",
-    "tap": "^14.11.0",
-    "tslib": "^2.2.0",
-    "typescript": "^4.2.4"
+    "tap": "^15.0.10",
+    "tslib": "^2.3.1",
+    "typescript": "^4.4.4"
+  },
+  "engines": {
+    "node": ">=12"
   }
 }

package/dist/string-match-left-right.cjs.js

@@ -1,325 +0,0 @@
-/**
- * @name string-match-left-right
- * @fileoverview Match substrings on the left or right of a given index, ignoring whitespace
- * @version 7.1.0
- * @author Roy Revelt, Codsen Ltd
- * @license MIT
- * {@link https://codsen.com/os/string-match-left-right/}
- */
-
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var _objectSpread = require('@babel/runtime/helpers/objectSpread2');
-var _typeof = require('@babel/runtime/helpers/typeof');
-var arrayiffyIfString = require('arrayiffy-if-string');
-
-function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-var _objectSpread__default = /*#__PURE__*/_interopDefaultLegacy(_objectSpread);
-var _typeof__default = /*#__PURE__*/_interopDefaultLegacy(_typeof);
-
-function isObj(something) {
-  return something && _typeof__default['default'](something) === "object" && !Array.isArray(something);
-}
-function isStr(something) {
-  return typeof something === "string";
-}
-var defaults = {
-  cb: undefined,
-  i: false,
-  trimBeforeMatching: false,
-  trimCharsBeforeMatching: [],
-  maxMismatches: 0,
-  firstMustMatch: false,
-  lastMustMatch: false,
-  hungry: false
-};
-var defaultGetNextIdx = function defaultGetNextIdx(index) {
-  return index + 1;
-};
-function march(str, position, whatToMatchVal, originalOpts) {
-  var special = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
-  var getNextIdx = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : defaultGetNextIdx;
-  var whatToMatchValVal = typeof whatToMatchVal === "function" ? whatToMatchVal() : whatToMatchVal;
-  if (+position < 0 && special && whatToMatchValVal === "EOL") {
-    return whatToMatchValVal;
-  }
-  var opts = _objectSpread__default['default'](_objectSpread__default['default']({}, defaults), originalOpts);
-  if (position >= str.length && !special) {
-    return false;
-  }
-  var charsToCheckCount = special ? 1 : whatToMatchVal.length;
-  var charsMatchedTotal = 0;
-  var patienceReducedBeforeFirstMatch = false;
-  var lastWasMismatched = false;
-  var atLeastSomethingWasMatched = false;
-  var patience = opts.maxMismatches;
-  var i = position;
-  var somethingFound = false;
-  var firstCharacterMatched = false;
-  var lastCharacterMatched = false;
-  function whitespaceInFrontOfFirstChar() {
-    return (
-      charsMatchedTotal === 1 &&
-      patience < opts.maxMismatches - 1
-    );
-  }
-  while (str[i]) {
-    var nextIdx = getNextIdx(i);
-    if (opts.trimBeforeMatching && str[i].trim() === "") {
-      if (!str[nextIdx] && special && whatToMatchVal === "EOL") {
-        return true;
-      }
-      i = getNextIdx(i);
-      continue;
-    }
-    if (opts && !opts.i && opts.trimCharsBeforeMatching && opts.trimCharsBeforeMatching.includes(str[i]) || opts && opts.i && opts.trimCharsBeforeMatching && opts.trimCharsBeforeMatching.map(function (val) {
-      return val.toLowerCase();
-    }).includes(str[i].toLowerCase())) {
-      if (special && whatToMatchVal === "EOL" && !str[nextIdx]) {
-        return true;
-      }
-      i = getNextIdx(i);
-      continue;
-    }
-    var charToCompareAgainst = nextIdx > i ? whatToMatchVal[whatToMatchVal.length - charsToCheckCount] : whatToMatchVal[charsToCheckCount - 1];
-    if (!opts.i && str[i] === charToCompareAgainst || opts.i && str[i].toLowerCase() === charToCompareAgainst.toLowerCase()) {
-      if (!somethingFound) {
-        somethingFound = true;
-      }
-      if (!atLeastSomethingWasMatched) {
-        atLeastSomethingWasMatched = true;
-      }
-      if (charsToCheckCount === whatToMatchVal.length) {
-        firstCharacterMatched = true;
-        if (patience !== opts.maxMismatches) {
-          return false;
-        }
-      } else if (charsToCheckCount === 1) {
-        lastCharacterMatched = true;
-      }
-      charsToCheckCount -= 1;
-      charsMatchedTotal++;
-      if (whitespaceInFrontOfFirstChar()) {
-        return false;
-      }
-      if (!charsToCheckCount) {
-        return (
-          charsMatchedTotal !== whatToMatchVal.length ||
-          patience === opts.maxMismatches ||
-          !patienceReducedBeforeFirstMatch ? i : false
-        );
-      }
-    } else {
-      if (!patienceReducedBeforeFirstMatch && !charsMatchedTotal) {
-        patienceReducedBeforeFirstMatch = true;
-      }
-      if (opts.maxMismatches && patience && i) {
-        patience -= 1;
-        for (var y = 0; y <= patience; y++) {
-          var nextCharToCompareAgainst = nextIdx > i ? whatToMatchVal[whatToMatchVal.length - charsToCheckCount + 1 + y] : whatToMatchVal[charsToCheckCount - 2 - y];
-          var nextCharInSource = str[getNextIdx(i)];
-          if (nextCharToCompareAgainst && (!opts.i && str[i] === nextCharToCompareAgainst || opts.i && str[i].toLowerCase() === nextCharToCompareAgainst.toLowerCase()) && (
-          !opts.firstMustMatch || charsToCheckCount !== whatToMatchVal.length)) {
-            charsMatchedTotal++;
-            if (whitespaceInFrontOfFirstChar()) {
-              return false;
-            }
-            charsToCheckCount -= 2;
-            somethingFound = true;
-            break;
-          } else if (nextCharInSource && nextCharToCompareAgainst && (!opts.i && nextCharInSource === nextCharToCompareAgainst || opts.i && nextCharInSource.toLowerCase() === nextCharToCompareAgainst.toLowerCase()) && (
-          !opts.firstMustMatch || charsToCheckCount !== whatToMatchVal.length)) {
-            if (!charsMatchedTotal && !opts.hungry) {
-              return false;
-            }
-            charsToCheckCount -= 1;
-            somethingFound = true;
-            break;
-          } else if (nextCharToCompareAgainst === undefined && patience >= 0 && somethingFound && (!opts.firstMustMatch || firstCharacterMatched) && (!opts.lastMustMatch || lastCharacterMatched)) {
-            return i;
-          }
-        }
-        if (!somethingFound) {
-          lastWasMismatched = i;
-        }
-      } else if (i === 0 && charsToCheckCount === 1 && !opts.lastMustMatch && atLeastSomethingWasMatched) {
-        return 0;
-      } else {
-        return false;
-      }
-    }
-    if (lastWasMismatched !== false && lastWasMismatched !== i) {
-      lastWasMismatched = false;
-    }
-    if (charsToCheckCount < 1) {
-      return i;
-    }
-    i = getNextIdx(i);
-  }
-  if (charsToCheckCount > 0) {
-    if (special && whatToMatchValVal === "EOL") {
-      return true;
-    }
-    if (opts && opts.maxMismatches >= charsToCheckCount && atLeastSomethingWasMatched) {
-      return lastWasMismatched || 0;
-    }
-    return false;
-  }
-}
-function main(mode, str, position, originalWhatToMatch, originalOpts) {
-  if (isObj(originalOpts) && Object.prototype.hasOwnProperty.call(originalOpts, "trimBeforeMatching") && typeof originalOpts.trimBeforeMatching !== "boolean") {
-    throw new Error("string-match-left-right/".concat(mode, "(): [THROW_ID_09] opts.trimBeforeMatching should be boolean!").concat(Array.isArray(originalOpts.trimBeforeMatching) ? " Did you mean to use opts.trimCharsBeforeMatching?" : ""));
-  }
-  var opts = _objectSpread__default['default'](_objectSpread__default['default']({}, defaults), originalOpts);
-  if (typeof opts.trimCharsBeforeMatching === "string") {
-    opts.trimCharsBeforeMatching = arrayiffyIfString.arrayiffy(opts.trimCharsBeforeMatching);
-  }
-  opts.trimCharsBeforeMatching = opts.trimCharsBeforeMatching.map(function (el) {
-    return isStr(el) ? el : String(el);
-  });
-  if (!isStr(str)) {
-    return false;
-  }
-  if (!str.length) {
-    return false;
-  }
-  if (!Number.isInteger(position) || position < 0) {
-    throw new Error("string-match-left-right/".concat(mode, "(): [THROW_ID_03] the second argument should be a natural number. Currently it's of a type: ").concat(_typeof__default['default'](position), ", equal to:\n").concat(JSON.stringify(position, null, 4)));
-  }
-  var whatToMatch;
-  var special;
-  if (isStr(originalWhatToMatch)) {
-    whatToMatch = [originalWhatToMatch];
-  } else if (Array.isArray(originalWhatToMatch)) {
-    whatToMatch = originalWhatToMatch;
-  } else if (!originalWhatToMatch) {
-    whatToMatch = originalWhatToMatch;
-  } else if (typeof originalWhatToMatch === "function") {
-    whatToMatch = [];
-    whatToMatch.push(originalWhatToMatch);
-  } else {
-    throw new Error("string-match-left-right/".concat(mode, "(): [THROW_ID_05] the third argument, whatToMatch, is neither string nor array of strings! It's ").concat(_typeof__default['default'](originalWhatToMatch), ", equal to:\n").concat(JSON.stringify(originalWhatToMatch, null, 4)));
-  }
-  if (originalOpts && !isObj(originalOpts)) {
-    throw new Error("string-match-left-right/".concat(mode, "(): [THROW_ID_06] the fourth argument, options object, should be a plain object. Currently it's of a type \"").concat(_typeof__default['default'](originalOpts), "\", and equal to:\n").concat(JSON.stringify(originalOpts, null, 4)));
-  }
-  var culpritsIndex = 0;
-  var culpritsVal = "";
-  if (opts && opts.trimCharsBeforeMatching && opts.trimCharsBeforeMatching.some(function (el, i) {
-    if (el.length > 1) {
-      culpritsIndex = i;
-      culpritsVal = el;
-      return true;
-    }
-    return false;
-  })) {
-    throw new Error("string-match-left-right/".concat(mode, "(): [THROW_ID_07] the fourth argument, options object contains trimCharsBeforeMatching. It was meant to list the single characters but one of the entries at index ").concat(culpritsIndex, " is longer than 1 character, ").concat(culpritsVal.length, " (equals to ").concat(culpritsVal, "). Please split it into separate characters and put into array as separate elements."));
-  }
-  if (!whatToMatch || !Array.isArray(whatToMatch) ||
-  Array.isArray(whatToMatch) && !whatToMatch.length ||
-  Array.isArray(whatToMatch) && whatToMatch.length === 1 && isStr(whatToMatch[0]) && !whatToMatch[0].trim()
-  ) {
-      if (typeof opts.cb === "function") {
-        var firstCharOutsideIndex;
-        var startingPosition = position;
-        if (mode === "matchLeftIncl" || mode === "matchRight") {
-          startingPosition += 1;
-        }
-        if (mode[5] === "L") {
-          for (var y = startingPosition; y--;) {
-            var currentChar = str[y];
-            if ((!opts.trimBeforeMatching || opts.trimBeforeMatching && currentChar !== undefined && currentChar.trim()) && (!opts.trimCharsBeforeMatching || !opts.trimCharsBeforeMatching.length || currentChar !== undefined && !opts.trimCharsBeforeMatching.includes(currentChar))) {
-              firstCharOutsideIndex = y;
-              break;
-            }
-          }
-        } else if (mode.startsWith("matchRight")) {
-          for (var _y = startingPosition; _y < str.length; _y++) {
-            var _currentChar = str[_y];
-            if ((!opts.trimBeforeMatching || opts.trimBeforeMatching && _currentChar.trim()) && (!opts.trimCharsBeforeMatching || !opts.trimCharsBeforeMatching.length || !opts.trimCharsBeforeMatching.includes(_currentChar))) {
-              firstCharOutsideIndex = _y;
-              break;
-            }
-          }
-        }
-        if (firstCharOutsideIndex === undefined) {
-          return false;
-        }
-        var wholeCharacterOutside = str[firstCharOutsideIndex];
-        var indexOfTheCharacterAfter = firstCharOutsideIndex + 1;
-        var theRemainderOfTheString = "";
-        if (indexOfTheCharacterAfter && indexOfTheCharacterAfter > 0) {
-          theRemainderOfTheString = str.slice(0, indexOfTheCharacterAfter);
-        }
-        if (mode[5] === "L") {
-          return opts.cb(wholeCharacterOutside, theRemainderOfTheString, firstCharOutsideIndex);
-        }
-        if (firstCharOutsideIndex && firstCharOutsideIndex > 0) {
-          theRemainderOfTheString = str.slice(firstCharOutsideIndex);
-        }
-        return opts.cb(wholeCharacterOutside, theRemainderOfTheString, firstCharOutsideIndex);
-      }
-      var extraNote = "";
-      if (!originalOpts) {
-        extraNote = " More so, the whole options object, the fourth input argument, is missing!";
-      }
-      throw new Error("string-match-left-right/".concat(mode, "(): [THROW_ID_08] the third argument, \"whatToMatch\", was given as an empty string. This means, you intend to match purely by a callback. The callback was not set though, the opts key \"cb\" is not set!").concat(extraNote));
-    }
-  for (var i = 0, len = whatToMatch.length; i < len; i++) {
-    special = typeof whatToMatch[i] === "function";
-    var whatToMatchVal = whatToMatch[i];
-    var fullCharacterInFront = void 0;
-    var indexOfTheCharacterInFront = void 0;
-    var restOfStringInFront = "";
-    var _startingPosition = position;
-    if (mode === "matchRight") {
-      _startingPosition += 1;
-    } else if (mode === "matchLeft") {
-      _startingPosition -= 1;
-    }
-    var found = march(str, _startingPosition, whatToMatchVal, opts, special, function (i2) {
-      return mode[5] === "L" ? i2 - 1 : i2 + 1;
-    });
-    if (found && special && typeof whatToMatchVal === "function" && whatToMatchVal() === "EOL") {
-      return whatToMatchVal() && (opts.cb ? opts.cb(fullCharacterInFront, restOfStringInFront, indexOfTheCharacterInFront) : true) ? whatToMatchVal() : false;
-    }
-    if (Number.isInteger(found)) {
-      indexOfTheCharacterInFront = mode.startsWith("matchLeft") ? found - 1 : found + 1;
-      if (mode[5] === "L") {
-        restOfStringInFront = str.slice(0, found);
-      } else {
-        restOfStringInFront = str.slice(indexOfTheCharacterInFront);
-      }
-    }
-    if (indexOfTheCharacterInFront < 0) {
-      indexOfTheCharacterInFront = undefined;
-    }
-    if (str[indexOfTheCharacterInFront]) {
-      fullCharacterInFront = str[indexOfTheCharacterInFront];
-    }
-    if (Number.isInteger(found) && (opts.cb ? opts.cb(fullCharacterInFront, restOfStringInFront, indexOfTheCharacterInFront) : true)) {
-      return whatToMatchVal;
-    }
-  }
-  return false;
-}
-function matchLeftIncl(str, position, whatToMatch, opts) {
-  return main("matchLeftIncl", str, position, whatToMatch, opts);
-}
-function matchLeft(str, position, whatToMatch, opts) {
-  return main("matchLeft", str, position, whatToMatch, opts);
-}
-function matchRightIncl(str, position, whatToMatch, opts) {
-  return main("matchRightIncl", str, position, whatToMatch, opts);
-}
-function matchRight(str, position, whatToMatch, opts) {
-  return main("matchRight", str, position, whatToMatch, opts);
-}
-
-exports.matchLeft = matchLeft;
-exports.matchLeftIncl = matchLeftIncl;
-exports.matchRight = matchRight;
-exports.matchRightIncl = matchRightIncl;

package/dist/string-match-left-right.dev.umd.js

@@ -1,558 +0,0 @@
-/**
- * @name string-match-left-right
- * @fileoverview Match substrings on the left or right of a given index, ignoring whitespace
- * @version 7.1.0
- * @author Roy Revelt, Codsen Ltd
- * @license MIT
- * {@link https://codsen.com/os/string-match-left-right/}
- */
-
-(function (global, factory) {
-typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
-typeof define === 'function' && define.amd ? define(['exports'], factory) :
-(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.stringMatchLeftRight = {}));
-}(this, (function (exports) { 'use strict';
-
-/**
- * @name arrayiffy-if-string
- * @fileoverview Put non-empty strings into arrays, turn empty-ones into empty arrays. Bypass everything else.
- * @version 3.14.0
- * @author Roy Revelt, Codsen Ltd
- * @license MIT
- * {@link https://codsen.com/os/arrayiffy-if-string/}
- */
-
-function arrayiffy(something) {
-  if (typeof something === "string") {
-    if (something.length) {
-      return [something];
-    }
-    return [];
-  }
-  return something;
-}
-
-/* eslint no-plusplus:0 */
-function isObj(something) {
-    return (something && typeof something === "object" && !Array.isArray(something));
-}
-function isStr(something) {
-    return typeof something === "string";
-}
-const defaults = {
-    cb: undefined,
-    i: false,
-    trimBeforeMatching: false,
-    trimCharsBeforeMatching: [],
-    maxMismatches: 0,
-    firstMustMatch: false,
-    lastMustMatch: false,
-    hungry: false,
-};
-const defaultGetNextIdx = (index) => index + 1;
-// eslint-disable-next-line consistent-return
-function march(str, position, whatToMatchVal, originalOpts, special = false, getNextIdx = defaultGetNextIdx) {
-    const whatToMatchValVal = typeof whatToMatchVal === "function" ? whatToMatchVal() : whatToMatchVal;
-    // early ending case if matching EOL being at 0-th index:
-    if (+position < 0 && special && whatToMatchValVal === "EOL") {
-        return whatToMatchValVal;
-    }
-    const opts = { ...defaults, ...originalOpts };
-    if (position >= str.length && !special) {
-        return false;
-    }
-    // The "charsToCheckCount" varies, it decreases with skipped characters,
-    // as long as "maxMismatches" allows. It's not the count of how many
-    // characters de-facto have been matched from the source.
-    let charsToCheckCount = special ? 1 : whatToMatchVal.length;
-    // this is the counter of real characters matched. It is not reduced
-    // from the holes in matched. For example, if source is "abc" and
-    // maxMismatches=1 and we have "ac", result of the match will be true,
-    // the following var will be equal to 2, meaning we matched two
-    // characters:
-    let charsMatchedTotal = 0;
-    // used to catch frontal false positives, where too-eager matching
-    // depletes the mismatches allowance before precisely matching the exact
-    // string that follows, yielding too early false-positive start
-    let patienceReducedBeforeFirstMatch = false;
-    let lastWasMismatched = false; // value is "false" or index of where it was activated
-    // if no character was ever matched, even through if opts.maxMismatches
-    // would otherwise allow to skip characters, this will act as a last
-    // insurance - at least one character must have been matched to yield a
-    // positive result!
-    let atLeastSomethingWasMatched = false;
-    let patience = opts.maxMismatches;
-    let i = position;
-    // internal-use flag, not the same as "atLeastSomethingWasMatched":
-    let somethingFound = false;
-    // these two drive opts.firstMustMatch and opts.lastMustMatch:
-    let firstCharacterMatched = false;
-    let lastCharacterMatched = false;
-    // bail early if there's whitespace in front, imagine:
-    // abc important}
-    //   ^
-    //  start, match ["!important"], matchRightIncl()
-    //
-    // in case above, "c" consumed 1 patience, let's say 1 is left,
-    // we stumble upon "i" where "!" is missing. "c" is false start.
-    function whitespaceInFrontOfFirstChar() {
-        return (
-        // it's a first letter match
-        charsMatchedTotal === 1 &&
-            // and character in front exists
-            // str[i - 1] &&
-            // and it's whitespace
-            // !str[i - 1].trim() &&
-            // some patience has been consumed already
-            patience < opts.maxMismatches - 1);
-    }
-    while (str[i]) {
-        const nextIdx = getNextIdx(i);
-        if (opts.trimBeforeMatching && str[i].trim() === "") {
-            if (!str[nextIdx] && special && whatToMatchVal === "EOL") {
-                return true;
-            }
-            i = getNextIdx(i);
-            continue;
-        }
-        if ((opts &&
-            !opts.i &&
-            opts.trimCharsBeforeMatching &&
-            opts.trimCharsBeforeMatching.includes(str[i])) ||
-            (opts &&
-                opts.i &&
-                opts.trimCharsBeforeMatching &&
-                opts.trimCharsBeforeMatching
-                    .map((val) => val.toLowerCase())
-                    .includes(str[i].toLowerCase()))) {
-            if (special && whatToMatchVal === "EOL" && !str[nextIdx]) {
-                // return true because we reached the zero'th index, exactly what we're looking for
-                return true;
-            }
-            i = getNextIdx(i);
-            continue;
-        }
-        const charToCompareAgainst = nextIdx > i
-            ? whatToMatchVal[whatToMatchVal.length - charsToCheckCount]
-            : whatToMatchVal[charsToCheckCount - 1];
-        // let's match
-        if ((!opts.i && str[i] === charToCompareAgainst) ||
-            (opts.i && str[i].toLowerCase() === charToCompareAgainst.toLowerCase())) {
-            if (!somethingFound) {
-                somethingFound = true;
-            }
-            if (!atLeastSomethingWasMatched) {
-                atLeastSomethingWasMatched = true;
-            }
-            // if this was the first character from the "to-match" list, flip the flag
-            if (charsToCheckCount === whatToMatchVal.length) {
-                firstCharacterMatched = true;
-                // now, if the first character was matched and yet, patience was
-                // reduced already, this means there's a false beginning in front
-                if (patience !== opts.maxMismatches) {
-                    return false;
-                }
-            }
-            else if (charsToCheckCount === 1) {
-                lastCharacterMatched = true;
-            }
-            charsToCheckCount -= 1;
-            charsMatchedTotal++;
-            // bail early if there's whitespace in front, imagine:
-            // abc important}
-            //   ^
-            //  start, match ["!important"], matchRightIncl()
-            //
-            // in case above, "c" consumed 1 patience, let's say 1 is left,
-            // we stumble upon "i" where "!" is missing. "c" is false start.
-            if (whitespaceInFrontOfFirstChar()) {
-                return false;
-            }
-            if (!charsToCheckCount) {
-                return (
-                // either it was not a perfect match
-                charsMatchedTotal !== whatToMatchVal.length ||
-                    // or it was, and in that case, no patience was reduced
-                    // (if a perfect match was found, yet some "patience" was reduced,
-                    // that means we have false positive characters)
-                    patience === opts.maxMismatches ||
-                    // mind you, it can be a case of rogue characters in-between
-                    // the what was matched, imagine:
-                    // source: "abxcd", matching ["bc"], maxMismatches=1
-                    // in above case, charsMatchedTotal === 2 and whatToMatchVal ("bc") === 2
-                    // - we want to exclude cases of frontal false positives, like:
-                    // source: "xy abc", match "abc", maxMismatches=2, start at 0
-                    //          ^
-                    //       match form here to the right
-                    !patienceReducedBeforeFirstMatch
-                    ? i
-                    : false);
-            }
-        }
-        else {
-            if (!patienceReducedBeforeFirstMatch && !charsMatchedTotal) {
-                patienceReducedBeforeFirstMatch = true;
-            }
-            if (opts.maxMismatches && patience && i) {
-                patience -= 1;
-                // the bigger the maxMismatches, the further away we must check for
-                // alternative matches
-                for (let y = 0; y <= patience; y++) {
-                    // maybe str[i] will match against next charToCompareAgainst?
-                    const nextCharToCompareAgainst = nextIdx > i
-                        ? whatToMatchVal[whatToMatchVal.length - charsToCheckCount + 1 + y]
-                        : whatToMatchVal[charsToCheckCount - 2 - y];
-                    const nextCharInSource = str[getNextIdx(i)];
-                    if (nextCharToCompareAgainst &&
-                        ((!opts.i && str[i] === nextCharToCompareAgainst) ||
-                            (opts.i &&
-                                str[i].toLowerCase() ===
-                                    nextCharToCompareAgainst.toLowerCase())) &&
-                        // ensure we're not skipping the first enforced character:
-                        (!opts.firstMustMatch ||
-                            charsToCheckCount !== whatToMatchVal.length)) {
-                        charsMatchedTotal++;
-                        // bail early if there's whitespace in front, imagine:
-                        // abc important}
-                        //   ^
-                        //  start, match ["!important"], matchRightIncl()
-                        //
-                        // in case above, "c" consumed 1 patience, let's say 1 is left,
-                        // we stumble upon "i" where "!" is missing. "c" is false start.
-                        if (whitespaceInFrontOfFirstChar()) {
-                            return false;
-                        }
-                        charsToCheckCount -= 2;
-                        somethingFound = true;
-                        break;
-                    }
-                    else if (nextCharInSource &&
-                        nextCharToCompareAgainst &&
-                        ((!opts.i && nextCharInSource === nextCharToCompareAgainst) ||
-                            (opts.i &&
-                                nextCharInSource.toLowerCase() ===
-                                    nextCharToCompareAgainst.toLowerCase())) &&
-                        // ensure we're not skipping the first enforced character:
-                        (!opts.firstMustMatch ||
-                            charsToCheckCount !== whatToMatchVal.length)) {
-                        if (!charsMatchedTotal && !opts.hungry) {
-                            return false;
-                        }
-                        charsToCheckCount -= 1;
-                        somethingFound = true;
-                        break;
-                    }
-                    else if (nextCharToCompareAgainst === undefined &&
-                        patience >= 0 &&
-                        somethingFound &&
-                        (!opts.firstMustMatch || firstCharacterMatched) &&
-                        (!opts.lastMustMatch || lastCharacterMatched)) {
-                        // If "nextCharToCompareAgainst" is undefined, this
-                        // means there are no more characters left to match,
-                        // this is the last character to be matched.
-                        // This means, if patience >= 0, this is it,
-                        // the match is still positive.
-                        return i;
-                    }
-                    // ███████████████████████████████████████
-                }
-                if (!somethingFound) {
-                    // if the character was rogue, we mark it:
-                    lastWasMismatched = i;
-                    // patience--;
-                    // console.log(
-                    //   `350 ${`\u001b[${32}m${`SET`}\u001b[${39}m`} ${`\u001b[${33}m${`patience`}\u001b[${39}m`} = ${patience}`
-                    // );
-                }
-            }
-            else if (i === 0 &&
-                charsToCheckCount === 1 &&
-                !opts.lastMustMatch &&
-                atLeastSomethingWasMatched) {
-                return 0;
-            }
-            else {
-                return false;
-            }
-        }
-        // turn off "lastWasMismatched" if it's on and it hasn't been activated
-        // on this current index:
-        if (lastWasMismatched !== false && lastWasMismatched !== i) {
-            lastWasMismatched = false;
-        }
-        // if all was matched, happy days
-        if (charsToCheckCount < 1) {
-            return i;
-        }
-        // iterate onto the next index, otherwise while would loop infinitely
-        i = getNextIdx(i);
-    }
-    if (charsToCheckCount > 0) {
-        if (special && whatToMatchValVal === "EOL") {
-            return true;
-        }
-        if (opts &&
-            opts.maxMismatches >= charsToCheckCount &&
-            atLeastSomethingWasMatched) {
-            return lastWasMismatched || 0;
-        }
-        return false;
-    }
-}
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-//
-// Real deal
-function main(mode, str, position, originalWhatToMatch, originalOpts) {
-    // insurance
-    if (isObj(originalOpts) &&
-        Object.prototype.hasOwnProperty.call(originalOpts, "trimBeforeMatching") &&
-        typeof originalOpts.trimBeforeMatching !== "boolean") {
-        throw new Error(`string-match-left-right/${mode}(): [THROW_ID_09] opts.trimBeforeMatching should be boolean!${Array.isArray(originalOpts.trimBeforeMatching)
-            ? ` Did you mean to use opts.trimCharsBeforeMatching?`
-            : ""}`);
-    }
-    const opts = { ...defaults, ...originalOpts };
-    if (typeof opts.trimCharsBeforeMatching === "string") {
-        // arrayiffy if needed:
-        opts.trimCharsBeforeMatching = arrayiffy(opts.trimCharsBeforeMatching);
-    }
-    // stringify all:
-    opts.trimCharsBeforeMatching = opts.trimCharsBeforeMatching.map((el) => (isStr(el) ? el : String(el)));
-    if (!isStr(str)) {
-        return false;
-    }
-    if (!str.length) {
-        return false;
-    }
-    if (!Number.isInteger(position) || position < 0) {
-        throw new Error(`string-match-left-right/${mode}(): [THROW_ID_03] the second argument should be a natural number. Currently it's of a type: ${typeof position}, equal to:\n${JSON.stringify(position, null, 4)}`);
-    }
-    let whatToMatch;
-    let special;
-    if (isStr(originalWhatToMatch)) {
-        whatToMatch = [originalWhatToMatch];
-    }
-    else if (Array.isArray(originalWhatToMatch)) {
-        whatToMatch = originalWhatToMatch;
-    }
-    else if (!originalWhatToMatch) {
-        whatToMatch = originalWhatToMatch;
-    }
-    else if (typeof originalWhatToMatch === "function") {
-        whatToMatch = [];
-        whatToMatch.push(originalWhatToMatch);
-    }
-    else {
-        throw new Error(`string-match-left-right/${mode}(): [THROW_ID_05] the third argument, whatToMatch, is neither string nor array of strings! It's ${typeof originalWhatToMatch}, equal to:\n${JSON.stringify(originalWhatToMatch, null, 4)}`);
-    }
-    if (originalOpts && !isObj(originalOpts)) {
-        throw new Error(`string-match-left-right/${mode}(): [THROW_ID_06] the fourth argument, options object, should be a plain object. Currently it's of a type "${typeof originalOpts}", and equal to:\n${JSON.stringify(originalOpts, null, 4)}`);
-    }
-    let culpritsIndex = 0;
-    let culpritsVal = "";
-    if (opts &&
-        opts.trimCharsBeforeMatching &&
-        opts.trimCharsBeforeMatching.some((el, i) => {
-            if (el.length > 1) {
-                culpritsIndex = i;
-                culpritsVal = el;
-                return true;
-            }
-            return false;
-        })) {
-        throw new Error(`string-match-left-right/${mode}(): [THROW_ID_07] the fourth argument, options object contains trimCharsBeforeMatching. It was meant to list the single characters but one of the entries at index ${culpritsIndex} is longer than 1 character, ${culpritsVal.length} (equals to ${culpritsVal}). Please split it into separate characters and put into array as separate elements.`);
-    }
-    // action
-    // CASE 1. If it's driven by callback-only, the 3rd input argument, what to look
-    // for - is falsey - empty string within array (or not), OR given null
-    if (!whatToMatch ||
-        !Array.isArray(whatToMatch) || // 0
-        (Array.isArray(whatToMatch) && !whatToMatch.length) || // []
-        (Array.isArray(whatToMatch) &&
-            whatToMatch.length === 1 &&
-            isStr(whatToMatch[0]) &&
-            !whatToMatch[0].trim()) // [""]
-    ) {
-        if (typeof opts.cb === "function") {
-            let firstCharOutsideIndex;
-            // matchLeft() or matchRightIncl() methods start at index "position"
-            let startingPosition = position;
-            if (mode === "matchLeftIncl" || mode === "matchRight") {
-                startingPosition += 1;
-            }
-            if (mode[5] === "L") {
-                for (let y = startingPosition; y--;) {
-                    // assemble the value of the current character
-                    const currentChar = str[y];
-                    // do the actual evaluation, is the current character non-whitespace/non-skiped
-                    if ((!opts.trimBeforeMatching ||
-                        (opts.trimBeforeMatching &&
-                            currentChar !== undefined &&
-                            currentChar.trim())) &&
-                        (!opts.trimCharsBeforeMatching ||
-                            !opts.trimCharsBeforeMatching.length ||
-                            (currentChar !== undefined &&
-                                !opts.trimCharsBeforeMatching.includes(currentChar)))) {
-                        firstCharOutsideIndex = y;
-                        break;
-                    }
-                }
-            }
-            else if (mode.startsWith("matchRight")) {
-                for (let y = startingPosition; y < str.length; y++) {
-                    // assemble the value of the current character
-                    const currentChar = str[y];
-                    // do the actual evaluation, is the current character non-whitespace/non-skiped
-                    if ((!opts.trimBeforeMatching ||
-                        (opts.trimBeforeMatching && currentChar.trim())) &&
-                        (!opts.trimCharsBeforeMatching ||
-                            !opts.trimCharsBeforeMatching.length ||
-                            !opts.trimCharsBeforeMatching.includes(currentChar))) {
-                        firstCharOutsideIndex = y;
-                        break;
-                    }
-                }
-            }
-            if (firstCharOutsideIndex === undefined) {
-                return false;
-            }
-            const wholeCharacterOutside = str[firstCharOutsideIndex];
-            const indexOfTheCharacterAfter = firstCharOutsideIndex + 1;
-            let theRemainderOfTheString = "";
-            if (indexOfTheCharacterAfter && indexOfTheCharacterAfter > 0) {
-                theRemainderOfTheString = str.slice(0, indexOfTheCharacterAfter);
-            }
-            if (mode[5] === "L") {
-                return opts.cb(wholeCharacterOutside, theRemainderOfTheString, firstCharOutsideIndex);
-            }
-            // ELSE matchRight & matchRightIncl
-            if (firstCharOutsideIndex && firstCharOutsideIndex > 0) {
-                theRemainderOfTheString = str.slice(firstCharOutsideIndex);
-            }
-            return opts.cb(wholeCharacterOutside, theRemainderOfTheString, firstCharOutsideIndex);
-        }
-        let extraNote = "";
-        if (!originalOpts) {
-            extraNote =
-                " More so, the whole options object, the fourth input argument, is missing!";
-        }
-        throw new Error(`string-match-left-right/${mode}(): [THROW_ID_08] the third argument, "whatToMatch", was given as an empty string. This means, you intend to match purely by a callback. The callback was not set though, the opts key "cb" is not set!${extraNote}`);
-    }
-    // Case 2. Normal operation where callback may or may not be present, but it is
-    // only accompanying the matching of what was given in 3rd input argument.
-    // Then if 3rd arg's contents were matched, callback is checked and its Boolean
-    // result is merged using logical "AND" - meaning both have to be true to yield
-    // final result "true".
-    for (let i = 0, len = whatToMatch.length; i < len; i++) {
-        special = typeof whatToMatch[i] === "function";
-        // since input can be function, we need to grab the value explicitly:
-        const whatToMatchVal = whatToMatch[i];
-        let fullCharacterInFront;
-        let indexOfTheCharacterInFront;
-        let restOfStringInFront = "";
-        let startingPosition = position;
-        if (mode === "matchRight") {
-            startingPosition += 1;
-        }
-        else if (mode === "matchLeft") {
-            startingPosition -= 1;
-        }
-        const found = march(str, startingPosition, whatToMatchVal, opts, special, (i2) => (mode[5] === "L" ? i2 - 1 : i2 + 1));
-        // if march() returned positive result and it was "special" case,
-        // Bob's your uncle, here's the result:
-        if (found &&
-            special &&
-            typeof whatToMatchVal === "function" &&
-            whatToMatchVal() === "EOL") {
-            return whatToMatchVal() &&
-                (opts.cb
-                    ? opts.cb(fullCharacterInFront, restOfStringInFront, indexOfTheCharacterInFront)
-                    : true)
-                ? whatToMatchVal()
-                : false;
-        }
-        // now, the "found" is the index of the first character of what was found.
-        // we need to calculate the character to the left/right of it:
-        if (Number.isInteger(found)) {
-            indexOfTheCharacterInFront = mode.startsWith("matchLeft")
-                ? found - 1
-                : found + 1;
-            //
-            if (mode[5] === "L") {
-                restOfStringInFront = str.slice(0, found);
-            }
-            else {
-                restOfStringInFront = str.slice(indexOfTheCharacterInFront);
-            }
-        }
-        if (indexOfTheCharacterInFront < 0) {
-            indexOfTheCharacterInFront = undefined;
-        }
-        if (str[indexOfTheCharacterInFront]) {
-            fullCharacterInFront = str[indexOfTheCharacterInFront];
-        }
-        if (Number.isInteger(found) &&
-            (opts.cb
-                ? opts.cb(fullCharacterInFront, restOfStringInFront, indexOfTheCharacterInFront)
-                : true)) {
-            return whatToMatchVal;
-        }
-    }
-    return false;
-}
-// External API functions
-function matchLeftIncl(str, position, whatToMatch, opts) {
-    return main("matchLeftIncl", str, position, whatToMatch, opts);
-}
-function matchLeft(str, position, whatToMatch, opts) {
-    return main("matchLeft", str, position, whatToMatch, opts);
-}
-function matchRightIncl(str, position, whatToMatch, opts) {
-    return main("matchRightIncl", str, position, whatToMatch, opts);
-}
-function matchRight(str, position, whatToMatch, opts) {
-    return main("matchRight", str, position, whatToMatch, opts);
-}
-
-exports.matchLeft = matchLeft;
-exports.matchLeftIncl = matchLeftIncl;
-exports.matchRight = matchRight;
-exports.matchRightIncl = matchRightIncl;
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-})));