nativescript 8.6.0-vision.3 → 8.6.0-vision.5

package/lib/key-commands/index.js

@@ -0,0 +1,291 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuestionMark = exports.N = exports.C = exports.W = exports.CtrlC = exports.ShiftR = exports.R = exports.ShiftI = exports.I = exports.ShiftA = exports.A = void 0;
+const fs = require("fs");
+const os_1 = require("os");
+const path = require("path");
+const color_1 = require("../color");
+const yok_1 = require("../common/yok");
+class A {
+    constructor($startService) {
+        this.$startService = $startService;
+        this.key = "a";
+        this.platform = "Android";
+        this.description = "Run android app";
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$startService.runAndroid();
+        });
+    }
+    canExecute(processType) {
+        return processType === "start";
+    }
+}
+exports.A = A;
+class ShiftA {
+    constructor($logger, $liveSyncCommandHelper, $childProcess, $projectData) {
+        this.$logger = $logger;
+        this.$liveSyncCommandHelper = $liveSyncCommandHelper;
+        this.$childProcess = $childProcess;
+        this.$projectData = $projectData;
+        this.key = "A";
+        this.platform = "Android";
+        this.description = "Open android project in Android Studio";
+        this.willBlockKeyCommandExecution = true;
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$liveSyncCommandHelper.validatePlatform(this.platform);
+            this.$projectData.initializeProjectData();
+            const androidDir = `${this.$projectData.platformsDir}/android`;
+            if (!fs.existsSync(androidDir)) {
+                const prepareCommand = yok_1.injector.resolveCommand("prepare");
+                yield prepareCommand.execute([this.platform]);
+                process.stdin.resume();
+            }
+            const os = (0, os_1.platform)();
+            if (os === "darwin") {
+                const possibleStudioPaths = [
+                    "/Applications/Android Studio.app",
+                    `${process.env.HOME}/Applications/Android Studio.app`,
+                ];
+                const studioPath = possibleStudioPaths.find((p) => {
+                    this.$logger.trace(`Checking for Android Studio at ${p}`);
+                    return fs.existsSync(p);
+                });
+                if (!studioPath) {
+                    this.$logger.error("Android Studio is not installed, or not in a standard location.");
+                    return;
+                }
+                this.$childProcess.exec(`open -a "${studioPath}" ${androidDir}`);
+            }
+            else if (os === "win32") {
+                const studioPath = path.join("C:", "Program Files", "Android", "Android Studio", "bin", "studio64.exe");
+                if (!fs.existsSync(studioPath)) {
+                    this.$logger.error("Android Studio is not installed");
+                    return;
+                }
+                this.$childProcess.exec(`"${studioPath}" "${androidDir}"`);
+            }
+            else if (os === "linux") {
+                if (!fs.existsSync(`/usr/local/android-studio/bin/studio.sh`)) {
+                    this.$logger.error("Android Studio is not installed");
+                    return;
+                }
+                this.$childProcess.exec(`/usr/local/android-studio/bin/studio.sh ${androidDir}`);
+            }
+        });
+    }
+}
+exports.ShiftA = ShiftA;
+class I {
+    constructor($startService) {
+        this.$startService = $startService;
+        this.key = "i";
+        this.platform = "iOS";
+        this.description = "Run iOS app";
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$startService.runIOS();
+        });
+    }
+    canExecute(processType) {
+        return processType === "start";
+    }
+}
+exports.I = I;
+class ShiftI {
+    constructor($logger, $childProcess, $projectData) {
+        this.$logger = $logger;
+        this.$childProcess = $childProcess;
+        this.$projectData = $projectData;
+        this.key = "I";
+        this.platform = "iOS";
+        this.description = "Open iOS project in Xcode";
+        this.willBlockKeyCommandExecution = true;
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.$projectData.initializeProjectData();
+            const iosDir = path.resolve(this.$projectData.platformsDir, "ios");
+            const xcprojectFile = path.resolve(iosDir);
+            if (!fs.existsSync(iosDir)) {
+                const prepareCommand = yok_1.injector.resolveCommand("prepare");
+                yield prepareCommand.execute(["ios"]);
+                process.stdin.resume();
+            }
+            const os = (0, os_1.platform)();
+            if (os === "darwin") {
+                if (!fs.existsSync("/Applications/Xcode.app")) {
+                    this.$logger.error("Xcode is not installed");
+                    return;
+                }
+                this.$childProcess.exec(`open ${xcprojectFile}`);
+            }
+        });
+    }
+}
+exports.ShiftI = ShiftI;
+class R {
+    constructor($liveSyncCommandHelper) {
+        this.$liveSyncCommandHelper = $liveSyncCommandHelper;
+        this.key = "r";
+        this.platform = "all";
+        this.description = "Rebuild native app if needed and restart";
+        this.willBlockKeyCommandExecution = true;
+    }
+    execute(platform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = yield this.$liveSyncCommandHelper.getDeviceInstances(platform);
+            yield this.$liveSyncCommandHelper.executeLiveSyncOperation(devices, platform, {
+                restartLiveSync: true,
+            });
+        });
+    }
+}
+exports.R = R;
+class ShiftR {
+    constructor($liveSyncCommandHelper) {
+        this.$liveSyncCommandHelper = $liveSyncCommandHelper;
+        this.key = "R";
+        this.platform = "all";
+        this.description = "Force rebuild native app and restart";
+        this.willBlockKeyCommandExecution = true;
+    }
+    execute(platform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const devices = yield this.$liveSyncCommandHelper.getDeviceInstances(platform);
+            yield this.$liveSyncCommandHelper.executeLiveSyncOperation(devices, platform, {
+                skipNativePrepare: false,
+                forceRebuildNativeApp: true,
+                restartLiveSync: true,
+            });
+        });
+    }
+}
+exports.ShiftR = ShiftR;
+class CtrlC {
+    constructor() {
+        this.key = "\u0003";
+        this.platform = "all";
+        this.willBlockKeyCommandExecution = false;
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            process.exit();
+        });
+    }
+}
+exports.CtrlC = CtrlC;
+class W {
+    constructor($prepareController) {
+        this.$prepareController = $prepareController;
+        this.key = "w";
+        this.platform = "all";
+        this.description = "Toggle file watcher";
+        this.willBlockKeyCommandExecution = true;
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const paused = yield this.$prepareController.toggleFileWatcher();
+                process.stdout.write(paused
+                    ? color_1.color.gray("Paused watching file changes... Press 'w' to resume.")
+                    : color_1.color.bgGreen("Resumed watching file changes"));
+            }
+            catch (e) { }
+        });
+    }
+}
+exports.W = W;
+class C {
+    constructor($childProcess, $liveSyncCommandHelper) {
+        this.$childProcess = $childProcess;
+        this.$liveSyncCommandHelper = $liveSyncCommandHelper;
+        this.key = "c";
+        this.platform = "all";
+        this.description = "Clean project";
+        this.willBlockKeyCommandExecution = true;
+    }
+    execute() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.$liveSyncCommandHelper.stop();
+            const clean = this.$childProcess.spawn("ns", ["clean"]);
+            clean.stdout.on("data", (data) => {
+                process.stdout.write(data);
+                if (data.toString().includes("Project successfully cleaned.") ||
+                    data.toString().includes("Project unsuccessfully cleaned.")) {
+                    clean.kill("SIGINT");
+                }
+            });
+        });
+    }
+}
+exports.C = C;
+class N {
+    constructor() {
+        this.key = "n";
+        this.platform = "all";
+        this.description = "Install dependencies";
+        this.willBlockKeyCommandExecution = true;
+    }
+    execute(platform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const install = yok_1.injector.resolveCommand("install");
+            yield install.execute([]);
+            process.stdin.resume();
+        });
+    }
+}
+exports.N = N;
+class QuestionMark {
+    constructor($keyCommandHelper) {
+        this.$keyCommandHelper = $keyCommandHelper;
+        this.key = "?";
+        this.platform = "all";
+        this.description = "Show this help";
+        this.willBlockKeyCommandExecution = true;
+    }
+    execute(platform_) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let platform;
+            switch (platform_.toLowerCase()) {
+                case "android":
+                    platform = "Android";
+                    break;
+                case "ios":
+                    platform = "iOS";
+                    break;
+                default:
+                    platform = "all";
+                    break;
+            }
+            this.$keyCommandHelper.printCommands(platform);
+            process.stdin.resume();
+        });
+    }
+}
+exports.QuestionMark = QuestionMark;
+yok_1.injector.registerKeyCommand("a", A);
+yok_1.injector.registerKeyCommand("i", I);
+yok_1.injector.registerKeyCommand("A", ShiftA);
+yok_1.injector.registerKeyCommand("I", ShiftI);
+yok_1.injector.registerKeyCommand("r", R);
+yok_1.injector.registerKeyCommand("R", ShiftR);
+yok_1.injector.registerKeyCommand("w", W);
+yok_1.injector.registerKeyCommand("c", C);
+yok_1.injector.registerKeyCommand("A", ShiftA);
+yok_1.injector.registerKeyCommand("n", N);
+yok_1.injector.registerKeyCommand("?", QuestionMark);
+yok_1.injector.registerKeyCommand("\u0003", CtrlC);

package/lib/services/android-plugin-build-service.js

@@ -44,7 +44,7 @@ class AndroidPluginBuildService {
         this.$watchIgnoreListService = $watchIgnoreListService;
     }
     getAndroidSourceDirectories(source) {
-        const directories = [constants_1.RESOURCES_DIR, "java", constants_1.ASSETS_DIR, "jniLibs"];
+        const directories = [constants_1.RESOURCES_DIR, "java", constants_1.ASSETS_DIR, "jniLibs", "cpp"];
         const resultArr = [];
         this.$fs.enumerateFilesInDirectorySync(source, (file, stat) => {
             if (stat.isDirectory() &&
@@ -310,7 +310,7 @@ class AndroidPluginBuildService {
             return null;
         }
         if (installedRuntimePackageJSON.version_info) {
-            const { gradle, gradleAndroid, } = installedRuntimePackageJSON.version_info;
+            const { gradle, gradleAndroid } = installedRuntimePackageJSON.version_info;
             return {
                 gradleVersion: gradle,
                 gradleAndroidPluginVersion: gradleAndroid,
@@ -449,9 +449,10 @@ class AndroidPluginBuildService {
                     validateTargetSdk: true,
                     projectDir: pluginBuildSettings.projectDir,
                 });
-                pluginBuildSettings.androidToolsInfo = this.$androidToolsInfo.getToolsInfo({
-                    projectDir: pluginBuildSettings.projectDir,
-                });
+                pluginBuildSettings.androidToolsInfo =
+                    this.$androidToolsInfo.getToolsInfo({
+                        projectDir: pluginBuildSettings.projectDir,
+                    });
             }
             const gradlew = (_a = pluginBuildSettings.gradlePath) !== null && _a !== void 0 ? _a : (this.$hostInfo.isWindows ? "gradlew.bat" : "./gradlew");
             const localArgs = [

package/lib/services/apple-portal/apple-portal-session-service.js

@@ -123,7 +123,7 @@ This password will be used for the iTunes Transporter, which is used to upload y
                         !(0, helpers_1.isInteractive)()) {
                         this.$errors
                             .fail(`Your account has two-factor authentication enabled, but your console is not interactive.
-For more details how to set up your environment, please execute "tns publish ios --help".`);
+For more details how to set up your environment, please execute "ns publish ios --help".`);
                     }
                     const headers = (err && err.response && err.response.headers) || {};
                     result.scnt = headers.scnt;

package/lib/services/build-artifacts-service.js

@@ -26,7 +26,7 @@ class BuildArtifactsService {
             const applicationPackage = this.getLatestApplicationPackage(outputPath, platformData.getValidBuildOutputData(buildOutputOptions));
             const packageFile = applicationPackage.packageName;
             if (!packageFile || !this.$fs.exists(packageFile)) {
-                this.$errors.fail(`Unable to find built application. Try 'tns build ${platformData.platformNameLowerCase}'.`);
+                this.$errors.fail(`Unable to find built application. Try 'ns build ${platformData.platformNameLowerCase}'.`);
             }
             return packageFile;
         });

package/lib/services/ios-project-service.js

@@ -270,8 +270,7 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
     }
     isDynamicFramework(frameworkPath) {
         return __awaiter(this, void 0, void 0, function* () {
-            const frameworkName = path.basename(frameworkPath, path.extname(frameworkPath));
-            const isDynamicFrameworkBundle = (bundlePath) => __awaiter(this, void 0, void 0, function* () {
+            const isDynamicFrameworkBundle = (bundlePath, frameworkName) => __awaiter(this, void 0, void 0, function* () {
                 const frameworkBinaryPath = path.join(bundlePath, frameworkName);
                 const fileResult = (yield this.$childProcess.spawnFromEvent("file", [frameworkBinaryPath], "close")).stdout;
                 const isDynamicallyLinked = _.includes(fileResult, "dynamically linked");
@@ -279,20 +278,20 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
             });
             if (path.extname(frameworkPath) === ".xcframework") {
                 let isDynamic = true;
-                const subDirs = this.$fs
-                    .readDirectory(frameworkPath)
-                    .filter((entry) => this.$fs.getFsStats(path.join(frameworkPath, entry)).isDirectory());
-                for (const subDir of subDirs) {
-                    const singlePlatformFramework = path.join(subDir, frameworkName + ".framework");
+                const plistJson = this.$plistParser.parseFileSync(path.join(frameworkPath, "Info.plist"));
+                for (const library of plistJson.AvailableLibraries) {
+                    const singlePlatformFramework = path.join(frameworkPath, library.LibraryIdentifier, library.LibraryPath);
                     if (this.$fs.exists(singlePlatformFramework)) {
-                        isDynamic = yield isDynamicFrameworkBundle(singlePlatformFramework);
+                        const frameworkName = path.basename(singlePlatformFramework, path.extname(singlePlatformFramework));
+                        isDynamic = yield isDynamicFrameworkBundle(singlePlatformFramework, frameworkName);
                         break;
                     }
                 }
                 return isDynamic;
             }
             else {
-                return yield isDynamicFrameworkBundle(frameworkPath);
+                const frameworkName = path.basename(frameworkPath, path.extname(frameworkPath));
+                return yield isDynamicFrameworkBundle(frameworkPath, frameworkName);
             }
         });
     }
@@ -302,7 +301,8 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
                 this.validateFramework(frameworkPath);
                 const project = this.createPbxProj(projectData);
                 const frameworkAddOptions = { customFramework: true };
-                if (yield this.isDynamicFramework(frameworkPath)) {
+                const dynamic = yield this.isDynamicFramework(frameworkPath);
+                if (dynamic) {
                     frameworkAddOptions["embed"] = true;
                     frameworkAddOptions["sign"] = true;
                 }

package/lib/services/livesync/android-livesync-tool.js

@@ -282,7 +282,7 @@ class AndroidLivesyncTool {
                         this.$logger.trace("In Android LiveSync tool, lastKnownError is: ", lastKnownError);
                         this.$logger.info(color_1.color.yellow(`Application ${configuration.appIdentifier} is not running on device ${configuration.deviceIdentifier}.`));
                         this.$logger.info(color_1.color.cyan(`This issue may be caused by:
-	* crash at startup (try \`tns debug android --debug-brk\` to check why it crashes)
+	* crash at startup (try \`ns debug android --debug-brk\` to check why it crashes)
 	* different application identifier in your package.json and in your gradle files (check your identifier in \`package.json\` and in all *.gradle files in your App_Resources directory)
 	* device is locked
 	* manual closing of the application`));

package/lib/services/plugins-service.js

@@ -130,10 +130,11 @@ class PluginsService {
                 if (!oldPluginNativeHashes ||
                     this.$filesHashService.hasChangesInShasums(oldPluginNativeHashes, currentPluginNativeHashes)) {
                     yield platformData.platformProjectService.preparePluginNativeCode(pluginData, projectData);
+                    const updatedPluginNativeHashes = yield this.getPluginNativeHashes(pluginPlatformsFolderPath);
                     this.setPluginNativeHashes({
                         pathToPluginsBuildFile,
                         pluginData,
-                        currentPluginNativeHashes,
+                        currentPluginNativeHashes: updatedPluginNativeHashes,
                         allPluginsNativeHashes,
                     });
                 }

package/lib/services/start-service.js

@@ -0,0 +1,104 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const yok_1 = require("../common/yok");
+class StartService {
+    constructor($keyCommandHelper, $childProcess, $devicePlatformsConstants, $projectData, $logger, $staticConfig) {
+        this.$keyCommandHelper = $keyCommandHelper;
+        this.$childProcess = $childProcess;
+        this.$devicePlatformsConstants = $devicePlatformsConstants;
+        this.$projectData = $projectData;
+        this.$logger = $logger;
+        this.$staticConfig = $staticConfig;
+        this.verbose = false;
+    }
+    toggleVerbose() {
+        this.verbose = true;
+        this.$logger.info(this.verbose ? `Verbose logging enabled` : `Verbose logging disabled`);
+    }
+    format(data, platform) {
+        return data;
+    }
+    runForPlatform(platform) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const platformLowerCase = platform.toLowerCase();
+            this[platformLowerCase] = this.$childProcess.spawn("node", [this.$staticConfig.cliBinPath, "run", platform.toLowerCase()], {
+                cwd: this.$projectData.projectDir,
+                stdio: ["ipc"],
+                env: Object.assign({ FORCE_COLOR: 1, HIDE_HEADER: true, NS_IS_INTERACTIVE: true }, process.env),
+            });
+            this[platformLowerCase].stdout.on("data", (data) => {
+                process.stdout.write(this.format(data, platform));
+            });
+            this[platformLowerCase].stderr.on("data", (data) => {
+                process.stderr.write(this.format(data, platform));
+            });
+        });
+    }
+    runIOS() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.runForPlatform(this.$devicePlatformsConstants.iOS);
+        });
+    }
+    runAndroid() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.runForPlatform(this.$devicePlatformsConstants.Android);
+        });
+    }
+    stopIOS() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.ios) {
+                this.ios.kill("SIGINT");
+            }
+        });
+    }
+    stopAndroid() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.android) {
+                this.android.kill("SIGINT");
+            }
+        });
+    }
+    start() {
+        this.addKeyCommandOverrides();
+        this.$keyCommandHelper.attachKeyCommands("all", "start");
+        this.$keyCommandHelper.printCommands("all");
+    }
+    addKeyCommandOverrides() {
+        const keys = ["w", "r", "R"];
+        for (let key of keys) {
+            this.$keyCommandHelper.addOverride(key, () => __awaiter(this, void 0, void 0, function* () {
+                var _a, _b;
+                (_a = this.ios) === null || _a === void 0 ? void 0 : _a.send(key);
+                (_b = this.android) === null || _b === void 0 ? void 0 : _b.send(key);
+                return false;
+            }));
+        }
+        this.$keyCommandHelper.addOverride("c", () => __awaiter(this, void 0, void 0, function* () {
+            yield this.stopIOS();
+            yield this.stopAndroid();
+            const clean = this.$childProcess.spawn("node", [
+                this.$staticConfig.cliBinPath,
+                "clean",
+            ]);
+            clean.stdout.on("data", (data) => {
+                process.stdout.write(data);
+                if (data.toString().includes("Project successfully cleaned.") ||
+                    data.toString().includes("Project unsuccessfully cleaned.")) {
+                    clean.kill("SIGINT");
+                }
+            });
+            return false;
+        }));
+    }
+}
+exports.default = StartService;
+yok_1.injector.register("startService", StartService);

package/lib/services/webpack/webpack-compiler-service.js

@@ -52,6 +52,12 @@ class WebpackCompilerService extends events_1.EventEmitter {
                 prepareData.watch = true;
                 try {
                     const childProcess = yield this.startWebpackProcess(platformData, projectData, prepareData);
+                    childProcess.stdout.on("data", function (data) {
+                        process.stdout.write(data);
+                    });
+                    childProcess.stderr.on("data", function (data) {
+                        process.stderr.write(data);
+                    });
                     childProcess.on("message", (message) => {
                         this.$logger.trace("Message from webpack", message);
                         if (typeof message === "object" &&
@@ -72,7 +78,8 @@ class WebpackCompilerService extends events_1.EventEmitter {
                         if (message.emittedFiles) {
                             if (isFirstWebpackWatchCompilation) {
                                 isFirstWebpackWatchCompilation = false;
-                                this.expectedHashes[platformData.platformNameLowerCase] = prepareData.hmr ? message.hash : "";
+                                this.expectedHashes[platformData.platformNameLowerCase] =
+                                    prepareData.hmr ? message.hash : "";
                                 return;
                             }
                             const previousHash = this.expectedHashes[platformData.platformNameLowerCase];
@@ -206,9 +213,7 @@ class WebpackCompilerService extends events_1.EventEmitter {
             if (prepareData.watch) {
                 args.push("--watch");
             }
-            const stdio = prepareData.watch
-                ? ["inherit", "inherit", "inherit", "ipc"]
-                : "inherit";
+            const stdio = prepareData.watch ? ["ipc"] : "inherit";
             const childProcess = this.$childProcess.spawn(process.execPath, args, {
                 cwd: projectData.projectDir,
                 stdio,

package/node_modules/@npmcli/move-file/node_modules/mkdirp/CHANGELOG.md

@@ -0,0 +1,15 @@
+# Changers Lorgs!
+
+## 1.0
+
+Full rewrite.  Essentially a brand new module.
+
+- Return a promise instead of taking a callback.
+- Use native `fs.mkdir(path, { recursive: true })` when available.
+- Drop support for outdated Node.js versions.  (Technically still works on
+  Node.js v8, but only 10 and above are officially supported.)
+
+## 0.x
+
+Original and most widely used recursive directory creation implementation
+in JavaScript, dating back to 2010.

package/node_modules/balanced-match/.github/FUNDING.yml

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

package/node_modules/balanced-match/README.md

@@ -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/node_modules/balanced-match/index.js

@@ -28,6 +28,9 @@ function range(a, b, str) {
   var i = ai;
 
   if (ai >= 0 && bi > 0) {
+    if(a===b) {
+      return [ai, bi];
+    }
     begs = [];
     left = str.length;
 

package/node_modules/balanced-match/package.json

@@ -1,7 +1,7 @@
 {
   "name": "balanced-match",
   "description": "Match balanced character pairs, like \"{\" and \"}\"",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "repository": {
     "type": "git",
     "url": "git://github.com/juliangruber/balanced-match.git"
@@ -9,10 +9,9 @@
   "homepage": "https://github.com/juliangruber/balanced-match",
   "main": "index.js",
   "scripts": {
-    "test": "make test",
-    "bench": "make bench"
+    "test": "tape test/test.js",
+    "bench": "matcha test/bench.js"
   },
-  "dependencies": {},
   "devDependencies": {
     "matcha": "^0.7.0",
     "tape": "^4.6.0"