binary-collections 2.0.11 → 2.0.12

package/lib/cross-env/command.mjs

@@ -0,0 +1,9 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  commandConvert
+} from "../chunk-C6D2TTYU.mjs";
+import "../chunk-XPJGCDOD.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export {
+  commandConvert
+};

package/lib/cross-env/index.cjs

@@ -0,0 +1,178 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cross-env/index.ts
+var cross_env_exports = {};
+__export(cross_env_exports, {
+  crossEnv: () => crossEnv
+});
+module.exports = __toCommonJS(cross_env_exports);
+var import_cross_spawn = require("cross-spawn");
+
+// src/cross-env/command.ts
+var import_path = __toESM(require("path"), 1);
+
+// src/utils/isWindows.js
+function isWindows() {
+  return process.platform === "win32" || /^(msys|cygwin)$/.test(process.env.OSTYPE || "");
+}
+
+// src/cross-env/command.ts
+function commandConvert(command, env, normalize = false) {
+  if (!isWindows()) {
+    return command;
+  }
+  const simpleEnvRegex = /\$(\w+)|\${(\w+)}/g;
+  const defaultValueRegex = /\$\{(\w+):-([^}]+)\}/g;
+  let convertedCmd = command;
+  convertedCmd = convertedCmd.replace(defaultValueRegex, (match, varName, defaultValue) => {
+    const value = env[varName] || defaultValue;
+    return value;
+  });
+  convertedCmd = convertedCmd.replace(simpleEnvRegex, (match, $1, $2) => {
+    const varName = $1 || $2;
+    return env[varName] ? `%${varName}%` : "";
+  });
+  return normalize === true ? import_path.default.normalize(convertedCmd) : convertedCmd;
+}
+
+// src/cross-env/variable.ts
+var pathLikeEnvVarWhitelist = /* @__PURE__ */ new Set(["PATH", "NODE_PATH"]);
+function replaceListDelimiters(varValue, varName = "") {
+  const targetSeparator = isWindows() ? ";" : ":";
+  if (!pathLikeEnvVarWhitelist.has(varName)) {
+    return varValue;
+  }
+  return varValue.replace(/(\\*):/g, (match, backslashes) => {
+    if (backslashes.length % 2) {
+      return match.substring(1);
+    }
+    return backslashes + targetSeparator;
+  });
+}
+function resolveEnvVars(varValue) {
+  const envUnixRegex = /(\\*)(\$(\w+)|\${(\w+)})/g;
+  return varValue.replace(envUnixRegex, (_, escapeChars, varNameWithDollarSign, varName, altVarName) => {
+    if (escapeChars.length % 2 === 1) {
+      return varNameWithDollarSign;
+    }
+    return escapeChars.substring(0, escapeChars.length / 2) + (process.env[varName || altVarName] || "");
+  });
+}
+function varValueConvert(originalValue, originalName) {
+  return resolveEnvVars(replaceListDelimiters(originalValue, originalName));
+}
+
+// src/cross-env/index.ts
+var envSetterRegex = /(\w+)=('(.*)'|"(.*)"|(.*))/;
+function crossEnv(args, options = {}) {
+  const [envSetters, command, commandArgs] = parseCommand(args);
+  const env = getEnvVars(envSetters);
+  if (command) {
+    const spawnOptions = {
+      stdio: "inherit",
+      shell: options.shell,
+      env
+    };
+    const proc = (0, import_cross_spawn.spawn)(
+      // run `path.normalize` for command(on windows)
+      commandConvert(command, env, true),
+      // by default normalize is `false`, so not run for cmd args
+      commandArgs.map((arg) => commandConvert(arg, env)),
+      spawnOptions
+    );
+    process.on("SIGTERM", () => proc.kill("SIGTERM"));
+    process.on("SIGINT", () => proc.kill("SIGINT"));
+    process.on("SIGBREAK", () => proc.kill("SIGBREAK"));
+    process.on("SIGHUP", () => proc.kill("SIGHUP"));
+    proc.on("exit", (code, signal) => {
+      let crossEnvExitCode = code;
+      if (crossEnvExitCode === null) {
+        crossEnvExitCode = signal === "SIGINT" ? 0 : 1;
+      }
+      process.exit(crossEnvExitCode);
+    });
+    return proc;
+  }
+  return null;
+}
+function parseCommand(args) {
+  const envSetters = {};
+  let command = null;
+  let commandArgs = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+    const match = envSetterRegex.exec(arg);
+    if (match && match[1]) {
+      let value;
+      if (typeof match[3] !== "undefined") {
+        value = match[3];
+      } else if (typeof match[4] === "undefined") {
+        value = match[5] || "";
+      } else {
+        value = match[4];
+      }
+      envSetters[match[1]] = value;
+    } else {
+      const cStart = args.slice(i).map((a) => {
+        const re = /\\\\|(\\)?'|([\\])(?=[$"\\])/g;
+        return a.replace(re, (m) => {
+          if (m === "\\\\") return "\\";
+          if (m === "\\'") return "'";
+          return "";
+        });
+      });
+      const parsedCommand = cStart[0];
+      if (!parsedCommand) {
+        throw new Error("Command is required");
+      }
+      command = parsedCommand;
+      commandArgs = cStart.slice(1).filter(Boolean);
+      break;
+    }
+  }
+  return [envSetters, command, commandArgs];
+}
+function getEnvVars(envSetters) {
+  const envVars = { ...process.env };
+  if (process.env.APPDATA) {
+    envVars.APPDATA = process.env.APPDATA;
+  }
+  Object.keys(envSetters).forEach((varName) => {
+    const value = envSetters[varName];
+    if (value !== void 0) {
+      envVars[varName] = varValueConvert(value, varName);
+    }
+  });
+  return envVars;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  crossEnv
+});

package/lib/cross-env/index.d.ts

@@ -0,0 +1,8 @@
+export type CrossEnvOptions = {
+    shell?: boolean;
+};
+export type ProcessResult = {
+    exitCode: number | null;
+    signal?: string | null;
+};
+export declare function crossEnv(args: string[], options?: CrossEnvOptions): ProcessResult | null;

package/lib/cross-env/index.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crossEnv = crossEnv;
+const cross_spawn_1 = require("cross-spawn");
+const command_js_1 = require("./command.js");
+const variable_js_1 = require("./variable.js");
+const envSetterRegex = /(\w+)=('(.*)'|"(.*)"|(.*))/;
+function crossEnv(args, options = {}) {
+    const [envSetters, command, commandArgs] = parseCommand(args);
+    const env = getEnvVars(envSetters);
+    if (command) {
+        const spawnOptions = {
+            stdio: 'inherit',
+            shell: options.shell,
+            env
+        };
+        const proc = (0, cross_spawn_1.spawn)(
+        // run `path.normalize` for command(on windows)
+        (0, command_js_1.commandConvert)(command, env, true), 
+        // by default normalize is `false`, so not run for cmd args
+        commandArgs.map((arg) => (0, command_js_1.commandConvert)(arg, env)), spawnOptions);
+        process.on('SIGTERM', () => proc.kill('SIGTERM'));
+        process.on('SIGINT', () => proc.kill('SIGINT'));
+        process.on('SIGBREAK', () => proc.kill('SIGBREAK'));
+        process.on('SIGHUP', () => proc.kill('SIGHUP'));
+        proc.on('exit', (code, signal) => {
+            let crossEnvExitCode = code;
+            // exit code could be null when OS kills the process(out of memory, etc) or due to node handling it
+            // but if the signal is SIGINT the user exited the process so we want exit code 0
+            if (crossEnvExitCode === null) {
+                crossEnvExitCode = signal === 'SIGINT' ? 0 : 1;
+            }
+            process.exit(crossEnvExitCode);
+        });
+        return proc;
+    }
+    return null;
+}
+function parseCommand(args) {
+    const envSetters = {};
+    let command = null;
+    let commandArgs = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (!arg)
+            continue;
+        const match = envSetterRegex.exec(arg);
+        if (match && match[1]) {
+            let value;
+            if (typeof match[3] !== 'undefined') {
+                value = match[3];
+            }
+            else if (typeof match[4] === 'undefined') {
+                value = match[5] || '';
+            }
+            else {
+                value = match[4];
+            }
+            envSetters[match[1]] = value;
+        }
+        else {
+            // No more env setters, the rest of the line must be the command and args
+            const cStart = args
+                .slice(i)
+                // Regex:
+                // match "\'" or "'"
+                // or match "\" if followed by [$"\] (lookahead)
+                .map((a) => {
+                const re = /\\\\|(\\)?'|([\\])(?=[$"\\])/g;
+                // Eliminate all matches except for "\'" => "'"
+                return a.replace(re, (m) => {
+                    if (m === '\\\\')
+                        return '\\';
+                    if (m === "\\'")
+                        return "'";
+                    return '';
+                });
+            });
+            const parsedCommand = cStart[0];
+            if (!parsedCommand) {
+                throw new Error('Command is required');
+            }
+            command = parsedCommand;
+            commandArgs = cStart.slice(1).filter(Boolean);
+            break;
+        }
+    }
+    return [envSetters, command, commandArgs];
+}
+function getEnvVars(envSetters) {
+    const envVars = Object.assign({}, process.env);
+    if (process.env.APPDATA) {
+        envVars.APPDATA = process.env.APPDATA;
+    }
+    Object.keys(envSetters).forEach((varName) => {
+        const value = envSetters[varName];
+        if (value !== undefined) {
+            envVars[varName] = (0, variable_js_1.varValueConvert)(value, varName);
+        }
+    });
+    return envVars;
+}

package/lib/cross-env/index.mjs

@@ -0,0 +1,101 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  commandConvert
+} from "../chunk-C6D2TTYU.mjs";
+import {
+  varValueConvert
+} from "../chunk-V2IBPCEV.mjs";
+import "../chunk-XPJGCDOD.mjs";
+import {
+  init_esm_shims
+} from "../chunk-QQ4A6DLD.mjs";
+
+// src/cross-env/index.ts
+init_esm_shims();
+import { spawn } from "cross-spawn";
+var envSetterRegex = /(\w+)=('(.*)'|"(.*)"|(.*))/;
+function crossEnv(args, options = {}) {
+  const [envSetters, command, commandArgs] = parseCommand(args);
+  const env = getEnvVars(envSetters);
+  if (command) {
+    const spawnOptions = {
+      stdio: "inherit",
+      shell: options.shell,
+      env
+    };
+    const proc = spawn(
+      // run `path.normalize` for command(on windows)
+      commandConvert(command, env, true),
+      // by default normalize is `false`, so not run for cmd args
+      commandArgs.map((arg) => commandConvert(arg, env)),
+      spawnOptions
+    );
+    process.on("SIGTERM", () => proc.kill("SIGTERM"));
+    process.on("SIGINT", () => proc.kill("SIGINT"));
+    process.on("SIGBREAK", () => proc.kill("SIGBREAK"));
+    process.on("SIGHUP", () => proc.kill("SIGHUP"));
+    proc.on("exit", (code, signal) => {
+      let crossEnvExitCode = code;
+      if (crossEnvExitCode === null) {
+        crossEnvExitCode = signal === "SIGINT" ? 0 : 1;
+      }
+      process.exit(crossEnvExitCode);
+    });
+    return proc;
+  }
+  return null;
+}
+function parseCommand(args) {
+  const envSetters = {};
+  let command = null;
+  let commandArgs = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (!arg) continue;
+    const match = envSetterRegex.exec(arg);
+    if (match && match[1]) {
+      let value;
+      if (typeof match[3] !== "undefined") {
+        value = match[3];
+      } else if (typeof match[4] === "undefined") {
+        value = match[5] || "";
+      } else {
+        value = match[4];
+      }
+      envSetters[match[1]] = value;
+    } else {
+      const cStart = args.slice(i).map((a) => {
+        const re = /\\\\|(\\)?'|([\\])(?=[$"\\])/g;
+        return a.replace(re, (m) => {
+          if (m === "\\\\") return "\\";
+          if (m === "\\'") return "'";
+          return "";
+        });
+      });
+      const parsedCommand = cStart[0];
+      if (!parsedCommand) {
+        throw new Error("Command is required");
+      }
+      command = parsedCommand;
+      commandArgs = cStart.slice(1).filter(Boolean);
+      break;
+    }
+  }
+  return [envSetters, command, commandArgs];
+}
+function getEnvVars(envSetters) {
+  const envVars = { ...process.env };
+  if (process.env.APPDATA) {
+    envVars.APPDATA = process.env.APPDATA;
+  }
+  Object.keys(envSetters).forEach((varName) => {
+    const value = envSetters[varName];
+    if (value !== void 0) {
+      envVars[varName] = varValueConvert(value, varName);
+    }
+  });
+  return envVars;
+}
+export {
+  crossEnv
+};

package/lib/cross-env/variable.cjs

@@ -0,0 +1,60 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/cross-env/variable.ts
+var variable_exports = {};
+__export(variable_exports, {
+  varValueConvert: () => varValueConvert
+});
+module.exports = __toCommonJS(variable_exports);
+
+// src/utils/isWindows.js
+function isWindows() {
+  return process.platform === "win32" || /^(msys|cygwin)$/.test(process.env.OSTYPE || "");
+}
+
+// src/cross-env/variable.ts
+var pathLikeEnvVarWhitelist = /* @__PURE__ */ new Set(["PATH", "NODE_PATH"]);
+function replaceListDelimiters(varValue, varName = "") {
+  const targetSeparator = isWindows() ? ";" : ":";
+  if (!pathLikeEnvVarWhitelist.has(varName)) {
+    return varValue;
+  }
+  return varValue.replace(/(\\*):/g, (match, backslashes) => {
+    if (backslashes.length % 2) {
+      return match.substring(1);
+    }
+    return backslashes + targetSeparator;
+  });
+}
+function resolveEnvVars(varValue) {
+  const envUnixRegex = /(\\*)(\$(\w+)|\${(\w+)})/g;
+  return varValue.replace(envUnixRegex, (_, escapeChars, varNameWithDollarSign, varName, altVarName) => {
+    if (escapeChars.length % 2 === 1) {
+      return varNameWithDollarSign;
+    }
+    return escapeChars.substring(0, escapeChars.length / 2) + (process.env[varName || altVarName] || "");
+  });
+}
+function varValueConvert(originalValue, originalName) {
+  return resolveEnvVars(replaceListDelimiters(originalValue, originalName));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  varValueConvert
+});

package/lib/cross-env/variable.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Converts an environment variable value to be appropriate for the current OS.
+ * @param originalValue Original value of the env variable
+ * @param originalName Original name of the env variable
+ * @returns Converted value
+ */
+export declare function varValueConvert(originalValue: string, originalName: string): string;

package/lib/cross-env/variable.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.varValueConvert = varValueConvert;
+const isWindows_js_1 = require("../utils/isWindows.js");
+const pathLikeEnvVarWhitelist = new Set(['PATH', 'NODE_PATH']);
+/**
+ * This will transform UNIX-style list values to Windows-style.
+ * For example, the value of the $PATH variable "/usr/bin:/usr/local/bin:."
+ * will become "/usr/bin;/usr/local/bin;." on Windows.
+ * @param varValue Original value of the env variable
+ * @param varName Original name of the env variable
+ * @returns Converted value
+ */
+function replaceListDelimiters(varValue, varName = '') {
+    const targetSeparator = (0, isWindows_js_1.isWindows)() ? ';' : ':';
+    if (!pathLikeEnvVarWhitelist.has(varName)) {
+        return varValue;
+    }
+    return varValue.replace(/(\\*):/g, (match, backslashes) => {
+        if (backslashes.length % 2) {
+            // Odd number of backslashes preceding it means it's escaped,
+            // remove 1 backslash and return the rest as-is
+            return match.substring(1);
+        }
+        return backslashes + targetSeparator;
+    });
+}
+/**
+ * This will attempt to resolve the value of any env variables that are inside
+ * this string. For example, it will transform this:
+ * cross-env FOO=$NODE_ENV BAR=\\$NODE_ENV echo $FOO $BAR
+ * Into this:
+ * FOO=development BAR=$NODE_ENV echo $FOO
+ * (Or whatever value the variable NODE_ENV has)
+ * Note that this function is only called with the right-side portion of the
+ * env var assignment, so in that example, this function would transform
+ * the string "$NODE_ENV" into "development"
+ * @param varValue Original value of the env variable
+ * @returns Converted value
+ */
+function resolveEnvVars(varValue) {
+    const envUnixRegex = /(\\*)(\$(\w+)|\${(\w+)})/g; // $my_var or ${my_var} or \$my_var
+    return varValue.replace(envUnixRegex, (_, escapeChars, varNameWithDollarSign, varName, altVarName) => {
+        // do not replace things preceded by a odd number of \
+        if (escapeChars.length % 2 === 1) {
+            return varNameWithDollarSign;
+        }
+        return escapeChars.substring(0, escapeChars.length / 2) + (process.env[varName || altVarName] || '');
+    });
+}
+/**
+ * Converts an environment variable value to be appropriate for the current OS.
+ * @param originalValue Original value of the env variable
+ * @param originalName Original name of the env variable
+ * @returns Converted value
+ */
+function varValueConvert(originalValue, originalName) {
+    return resolveEnvVars(replaceListDelimiters(originalValue, originalName));
+}

package/lib/cross-env/variable.mjs

@@ -0,0 +1,9 @@
+import { createRequire } from 'module'; const require = createRequire(import.meta.url);
+import {
+  varValueConvert
+} from "../chunk-V2IBPCEV.mjs";
+import "../chunk-XPJGCDOD.mjs";
+import "../chunk-QQ4A6DLD.mjs";
+export {
+  varValueConvert
+};

package/lib/del-gradle.cjs

@@ -88,7 +88,7 @@ var require_utils = __commonJS({
           try {
             fs.rmdirSync(fullPath);
             console.log("deleted", fullPath);
-          } catch (e) {
+          } catch (_e) {
             try {
               fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
               console.log("deleted", fullPath);
@@ -101,7 +101,7 @@ var require_utils = __commonJS({
         try {
           fs.unlinkSync(fullPath);
           console.log("deleted", fullPath);
-        } catch (e) {
+        } catch (_e) {
           try {
             fs.rmSync(fullPath, { recursive: true, force: true, retryDelay: 7e3 });
             console.log("deleted", fullPath);

package/lib/del-gradle.js

@@ -1,16 +1,16 @@
 "use strict";
-const glob = require("glob");
-const path = require("upath");
-const { del } = require("./utils/index.cjs");
-const globStream = new glob.Glob(["**/build.gradle"], {
+const glob = require('glob');
+const path = require('upath');
+const { del } = require('./utils/index.cjs');
+const globStream = new glob.Glob(['**/build.gradle'], {
     withFileTypes: false,
     cwd: process.cwd(),
-    ignore: ["**/node_modules/**", "**/vendor/**"]
+    ignore: ['**/node_modules/**', '**/vendor/**']
 });
-globStream.stream().on("data", (result) => {
+globStream.stream().on('data', (result) => {
     const fullPath = path.resolve(process.cwd(), result);
     const base = path.dirname(fullPath);
-    const buildFolder = path.join(base, "build");
-    console.log("delete build folder", buildFolder);
+    const buildFolder = path.join(base, 'build');
+    console.log('delete build folder', buildFolder);
     del(buildFolder);
 });

package/lib/del-gradle.mjs

@@ -1,7 +1,7 @@
 import { createRequire } from 'module'; const require = createRequire(import.meta.url);
 import {
   require_utils
-} from "./chunk-Z6JLYU2J.mjs";
+} from "./chunk-5RTXZVCW.mjs";
 import {
   __require,
   init_esm_shims