@dotenvx/next-env 2.1.2 → 2.2.1

package/dist/index.cjs

@@ -5965,8 +5965,8 @@ var require_dist = __commonJS({
           const processEnv2 = options.processEnv || process.env;
           const runningParsed = options.runningParsed || {};
           const matches = value.match(/\$\(([^)]+(?:\)[^(]*)*)\)/g) || [];
-          return matches.reduce((newValue, match) => {
-            const command = match.slice(2, -1);
+          return matches.reduce((newValue, match2) => {
+            const command = match2.slice(2, -1);
             let result;
             try {
               result = execSync(command, { env: { ...processEnv2, ...runningParsed } }).toString();
@@ -5974,7 +5974,7 @@ var require_dist = __commonJS({
               throw new Errors({ command, message: e.message.trim() }).commandSubstitutionFailed();
             }
             result = chomp(result);
-            return newValue.replace(match, result);
+            return newValue.replace(match2, result);
           }, value);
         }
         module22.exports = evaluate2;
@@ -5993,29 +5993,30 @@ var require_dist = __commonJS({
           }
           const regex = /(?<!\\)\${([^{}]+)}|(?<!\\)\$([A-Za-z_][A-Za-z0-9_]*)/g;
           let result = value;
-          let match;
-          while ((match = regex.exec(result)) !== null) {
-            const [template, bracedExpression, unbracedExpression] = match;
+          let match2;
+          while ((match2 = regex.exec(result)) !== null) {
+            const [template, bracedExpression, unbracedExpression] = match2;
             const expression = bracedExpression || unbracedExpression;
             const opRegex = /(:\+|\+|:-|-)/;
             const opMatch = expression.match(opRegex);
             const splitter = opMatch ? opMatch[0] : null;
             const r = expression.split(splitter);
-            let defaultValue;
-            let value2;
             const name = r.shift();
-            if ([":+", "+"].includes(splitter)) {
-              defaultValue = env[name] ? r.join(splitter) : "";
-              value2 = null;
+            const rest = r.join(splitter);
+            const hasValue = Object.prototype.hasOwnProperty.call(env, name);
+            let replacementValue;
+            if (splitter === ":-") {
+              replacementValue = env[name] || rest;
+            } else if (splitter === "-") {
+              replacementValue = hasValue ? env[name] : rest;
+            } else if (splitter === ":+") {
+              replacementValue = env[name] ? rest : "";
+            } else if (splitter === "+") {
+              replacementValue = hasValue ? rest : "";
             } else {
-              defaultValue = r.join(splitter);
-              value2 = env[name];
-            }
-            if (value2) {
-              result = result.replace(template, value2);
-            } else {
-              result = result.replace(template, defaultValue);
+              replacementValue = env[name] || "";
             }
+            result = result.replace(template, replacementValue);
             if (result === env[name]) {
               break;
             }
@@ -6032,7 +6033,14 @@ var require_dist = __commonJS({
     var require_keypair = __commonJS2({
       "src/keypair.js"(exports22, module22) {
         var { PrivateKey } = require_dist2();
-        function keypair2() {
+        var derive2 = require_derive();
+        function keypair2(privateKey) {
+          if (privateKey) {
+            return {
+              publicKey: derive2(privateKey),
+              privateKey
+            };
+          }
           const kp = new PrivateKey();
           return {
             publicKey: kp.publicKey.toHex(),
@@ -6042,8 +6050,1765 @@ var require_dist = __commonJS({
         module22.exports = keypair2;
       }
     });
+    var require_constants = __commonJS2({
+      "node_modules/picomatch/lib/constants.js"(exports22, module22) {
+        "use strict";
+        var WIN_SLASH = "\\\\/";
+        var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+        var DEFAULT_MAX_EXTGLOB_RECURSION = 0;
+        var DOT_LITERAL = "\\.";
+        var PLUS_LITERAL = "\\+";
+        var QMARK_LITERAL = "\\?";
+        var SLASH_LITERAL = "\\/";
+        var ONE_CHAR = "(?=.)";
+        var QMARK = "[^/]";
+        var END_ANCHOR = `(?:${SLASH_LITERAL}|$)`;
+        var START_ANCHOR = `(?:^|${SLASH_LITERAL})`;
+        var DOTS_SLASH = `${DOT_LITERAL}{1,2}${END_ANCHOR}`;
+        var NO_DOT = `(?!${DOT_LITERAL})`;
+        var NO_DOTS = `(?!${START_ANCHOR}${DOTS_SLASH})`;
+        var NO_DOT_SLASH = `(?!${DOT_LITERAL}{0,1}${END_ANCHOR})`;
+        var NO_DOTS_SLASH = `(?!${DOTS_SLASH})`;
+        var QMARK_NO_DOT = `[^.${SLASH_LITERAL}]`;
+        var STAR = `${QMARK}*?`;
+        var SEP = "/";
+        var POSIX_CHARS = {
+          DOT_LITERAL,
+          PLUS_LITERAL,
+          QMARK_LITERAL,
+          SLASH_LITERAL,
+          ONE_CHAR,
+          QMARK,
+          END_ANCHOR,
+          DOTS_SLASH,
+          NO_DOT,
+          NO_DOTS,
+          NO_DOT_SLASH,
+          NO_DOTS_SLASH,
+          QMARK_NO_DOT,
+          STAR,
+          START_ANCHOR,
+          SEP
+        };
+        var WINDOWS_CHARS = {
+          ...POSIX_CHARS,
+          SLASH_LITERAL: `[${WIN_SLASH}]`,
+          QMARK: WIN_NO_SLASH,
+          STAR: `${WIN_NO_SLASH}*?`,
+          DOTS_SLASH: `${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$)`,
+          NO_DOT: `(?!${DOT_LITERAL})`,
+          NO_DOTS: `(?!(?:^|[${WIN_SLASH}])${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+          NO_DOT_SLASH: `(?!${DOT_LITERAL}{0,1}(?:[${WIN_SLASH}]|$))`,
+          NO_DOTS_SLASH: `(?!${DOT_LITERAL}{1,2}(?:[${WIN_SLASH}]|$))`,
+          QMARK_NO_DOT: `[^.${WIN_SLASH}]`,
+          START_ANCHOR: `(?:^|[${WIN_SLASH}])`,
+          END_ANCHOR: `(?:[${WIN_SLASH}]|$)`,
+          SEP: "\\"
+        };
+        var POSIX_REGEX_SOURCE = {
+          __proto__: null,
+          alnum: "a-zA-Z0-9",
+          alpha: "a-zA-Z",
+          ascii: "\\x00-\\x7F",
+          blank: " \\t",
+          cntrl: "\\x00-\\x1F\\x7F",
+          digit: "0-9",
+          graph: "\\x21-\\x7E",
+          lower: "a-z",
+          print: "\\x20-\\x7E ",
+          punct: "\\-!\"#$%&'()\\*+,./:;<=>?@[\\]^_`{|}~",
+          space: " \\t\\r\\n\\v\\f",
+          upper: "A-Z",
+          word: "A-Za-z0-9_",
+          xdigit: "A-Fa-f0-9"
+        };
+        module22.exports = {
+          DEFAULT_MAX_EXTGLOB_RECURSION,
+          MAX_LENGTH: 1024 * 64,
+          POSIX_REGEX_SOURCE,
+          // regular expressions
+          REGEX_BACKSLASH: /\\(?![*+?^${}(|)[\]])/g,
+          REGEX_NON_SPECIAL_CHARS: /^[^@![\].,$*+?^{}()|\\/]+/,
+          REGEX_SPECIAL_CHARS: /[-*+?.^${}(|)[\]]/,
+          REGEX_SPECIAL_CHARS_BACKREF: /(\\?)((\W)(\3*))/g,
+          REGEX_SPECIAL_CHARS_GLOBAL: /([-*+?.^${}(|)[\]])/g,
+          REGEX_REMOVE_BACKSLASH: /(?:\[.*?[^\\]\]|\\(?=.))/g,
+          // Replace globs with equivalent patterns to reduce parsing time.
+          REPLACEMENTS: {
+            __proto__: null,
+            "***": "*",
+            "**/**": "**",
+            "**/**/**": "**"
+          },
+          // Digits
+          CHAR_0: 48,
+          /* 0 */
+          CHAR_9: 57,
+          /* 9 */
+          // Alphabet chars.
+          CHAR_UPPERCASE_A: 65,
+          /* A */
+          CHAR_LOWERCASE_A: 97,
+          /* a */
+          CHAR_UPPERCASE_Z: 90,
+          /* Z */
+          CHAR_LOWERCASE_Z: 122,
+          /* z */
+          CHAR_LEFT_PARENTHESES: 40,
+          /* ( */
+          CHAR_RIGHT_PARENTHESES: 41,
+          /* ) */
+          CHAR_ASTERISK: 42,
+          /* * */
+          // Non-alphabetic chars.
+          CHAR_AMPERSAND: 38,
+          /* & */
+          CHAR_AT: 64,
+          /* @ */
+          CHAR_BACKWARD_SLASH: 92,
+          /* \ */
+          CHAR_CARRIAGE_RETURN: 13,
+          /* \r */
+          CHAR_CIRCUMFLEX_ACCENT: 94,
+          /* ^ */
+          CHAR_COLON: 58,
+          /* : */
+          CHAR_COMMA: 44,
+          /* , */
+          CHAR_DOT: 46,
+          /* . */
+          CHAR_DOUBLE_QUOTE: 34,
+          /* " */
+          CHAR_EQUAL: 61,
+          /* = */
+          CHAR_EXCLAMATION_MARK: 33,
+          /* ! */
+          CHAR_FORM_FEED: 12,
+          /* \f */
+          CHAR_FORWARD_SLASH: 47,
+          /* / */
+          CHAR_GRAVE_ACCENT: 96,
+          /* ` */
+          CHAR_HASH: 35,
+          /* # */
+          CHAR_HYPHEN_MINUS: 45,
+          /* - */
+          CHAR_LEFT_ANGLE_BRACKET: 60,
+          /* < */
+          CHAR_LEFT_CURLY_BRACE: 123,
+          /* { */
+          CHAR_LEFT_SQUARE_BRACKET: 91,
+          /* [ */
+          CHAR_LINE_FEED: 10,
+          /* \n */
+          CHAR_NO_BREAK_SPACE: 160,
+          /* \u00A0 */
+          CHAR_PERCENT: 37,
+          /* % */
+          CHAR_PLUS: 43,
+          /* + */
+          CHAR_QUESTION_MARK: 63,
+          /* ? */
+          CHAR_RIGHT_ANGLE_BRACKET: 62,
+          /* > */
+          CHAR_RIGHT_CURLY_BRACE: 125,
+          /* } */
+          CHAR_RIGHT_SQUARE_BRACKET: 93,
+          /* ] */
+          CHAR_SEMICOLON: 59,
+          /* ; */
+          CHAR_SINGLE_QUOTE: 39,
+          /* ' */
+          CHAR_SPACE: 32,
+          /*   */
+          CHAR_TAB: 9,
+          /* \t */
+          CHAR_UNDERSCORE: 95,
+          /* _ */
+          CHAR_VERTICAL_LINE: 124,
+          /* | */
+          CHAR_ZERO_WIDTH_NOBREAK_SPACE: 65279,
+          /* \uFEFF */
+          /**
+           * Create EXTGLOB_CHARS
+           */
+          extglobChars(chars) {
+            return {
+              "!": { type: "negate", open: "(?:(?!(?:", close: `))${chars.STAR})` },
+              "?": { type: "qmark", open: "(?:", close: ")?" },
+              "+": { type: "plus", open: "(?:", close: ")+" },
+              "*": { type: "star", open: "(?:", close: ")*" },
+              "@": { type: "at", open: "(?:", close: ")" }
+            };
+          },
+          /**
+           * Create GLOB_CHARS
+           */
+          globChars(win32) {
+            return win32 === true ? WINDOWS_CHARS : POSIX_CHARS;
+          }
+        };
+      }
+    });
+    var require_utils5 = __commonJS2({
+      "node_modules/picomatch/lib/utils.js"(exports22) {
+        "use strict";
+        var {
+          REGEX_BACKSLASH,
+          REGEX_REMOVE_BACKSLASH,
+          REGEX_SPECIAL_CHARS,
+          REGEX_SPECIAL_CHARS_GLOBAL
+        } = require_constants();
+        exports22.isObject = (val) => val !== null && typeof val === "object" && !Array.isArray(val);
+        exports22.hasRegexChars = (str) => REGEX_SPECIAL_CHARS.test(str);
+        exports22.isRegexChar = (str) => str.length === 1 && exports22.hasRegexChars(str);
+        exports22.escapeRegex = (str) => str.replace(REGEX_SPECIAL_CHARS_GLOBAL, "\\$1");
+        exports22.toPosixSlashes = (str) => str.replace(REGEX_BACKSLASH, "/");
+        exports22.isWindows = () => {
+          if (typeof navigator !== "undefined" && navigator.platform) {
+            const platform = navigator.platform.toLowerCase();
+            return platform === "win32" || platform === "windows";
+          }
+          if (typeof process !== "undefined" && process.platform) {
+            return process.platform === "win32";
+          }
+          return false;
+        };
+        exports22.removeBackslashes = (str) => {
+          return str.replace(REGEX_REMOVE_BACKSLASH, (match2) => {
+            return match2 === "\\" ? "" : match2;
+          });
+        };
+        exports22.escapeLast = (input, char, lastIdx) => {
+          const idx = input.lastIndexOf(char, lastIdx);
+          if (idx === -1) return input;
+          if (input[idx - 1] === "\\") return exports22.escapeLast(input, char, idx - 1);
+          return `${input.slice(0, idx)}\\${input.slice(idx)}`;
+        };
+        exports22.removePrefix = (input, state = {}) => {
+          let output = input;
+          if (output.startsWith("./")) {
+            output = output.slice(2);
+            state.prefix = "./";
+          }
+          return output;
+        };
+        exports22.wrapOutput = (input, state = {}, options = {}) => {
+          const prepend = options.contains ? "" : "^";
+          const append = options.contains ? "" : "$";
+          let output = `${prepend}(?:${input})${append}`;
+          if (state.negated === true) {
+            output = `(?:^(?!${output}).*$)`;
+          }
+          return output;
+        };
+        exports22.basename = (path2, { windows } = {}) => {
+          const segs = path2.split(windows ? /[\\/]/ : "/");
+          const last = segs[segs.length - 1];
+          if (last === "") {
+            return segs[segs.length - 2];
+          }
+          return last;
+        };
+      }
+    });
     var require_scan = __commonJS2({
+      "node_modules/picomatch/lib/scan.js"(exports22, module22) {
+        "use strict";
+        var utils = require_utils5();
+        var {
+          CHAR_ASTERISK,
+          /* * */
+          CHAR_AT,
+          /* @ */
+          CHAR_BACKWARD_SLASH,
+          /* \ */
+          CHAR_COMMA,
+          /* , */
+          CHAR_DOT,
+          /* . */
+          CHAR_EXCLAMATION_MARK,
+          /* ! */
+          CHAR_FORWARD_SLASH,
+          /* / */
+          CHAR_LEFT_CURLY_BRACE,
+          /* { */
+          CHAR_LEFT_PARENTHESES,
+          /* ( */
+          CHAR_LEFT_SQUARE_BRACKET,
+          /* [ */
+          CHAR_PLUS,
+          /* + */
+          CHAR_QUESTION_MARK,
+          /* ? */
+          CHAR_RIGHT_CURLY_BRACE,
+          /* } */
+          CHAR_RIGHT_PARENTHESES,
+          /* ) */
+          CHAR_RIGHT_SQUARE_BRACKET
+          /* ] */
+        } = require_constants();
+        var isPathSeparator = (code) => {
+          return code === CHAR_FORWARD_SLASH || code === CHAR_BACKWARD_SLASH;
+        };
+        var depth = (token) => {
+          if (token.isPrefix !== true) {
+            token.depth = token.isGlobstar ? Infinity : 1;
+          }
+        };
+        var scan2 = (input, options) => {
+          const opts = options || {};
+          const length = input.length - 1;
+          const scanToEnd = opts.parts === true || opts.scanToEnd === true;
+          const slashes = [];
+          const tokens = [];
+          const parts = [];
+          let str = input;
+          let index = -1;
+          let start = 0;
+          let lastIndex = 0;
+          let isBrace = false;
+          let isBracket = false;
+          let isGlob = false;
+          let isExtglob = false;
+          let isGlobstar = false;
+          let braceEscaped = false;
+          let backslashes = false;
+          let negated = false;
+          let negatedExtglob = false;
+          let finished = false;
+          let braces = 0;
+          let prev;
+          let code;
+          let token = { value: "", depth: 0, isGlob: false };
+          const eos = () => index >= length;
+          const peek = () => str.charCodeAt(index + 1);
+          const advance = () => {
+            prev = code;
+            return str.charCodeAt(++index);
+          };
+          while (index < length) {
+            code = advance();
+            let next;
+            if (code === CHAR_BACKWARD_SLASH) {
+              backslashes = token.backslashes = true;
+              code = advance();
+              if (code === CHAR_LEFT_CURLY_BRACE) {
+                braceEscaped = true;
+              }
+              continue;
+            }
+            if (braceEscaped === true || code === CHAR_LEFT_CURLY_BRACE) {
+              braces++;
+              while (eos() !== true && (code = advance())) {
+                if (code === CHAR_BACKWARD_SLASH) {
+                  backslashes = token.backslashes = true;
+                  advance();
+                  continue;
+                }
+                if (code === CHAR_LEFT_CURLY_BRACE) {
+                  braces++;
+                  continue;
+                }
+                if (braceEscaped !== true && code === CHAR_DOT && (code = advance()) === CHAR_DOT) {
+                  isBrace = token.isBrace = true;
+                  isGlob = token.isGlob = true;
+                  finished = true;
+                  if (scanToEnd === true) {
+                    continue;
+                  }
+                  break;
+                }
+                if (braceEscaped !== true && code === CHAR_COMMA) {
+                  isBrace = token.isBrace = true;
+                  isGlob = token.isGlob = true;
+                  finished = true;
+                  if (scanToEnd === true) {
+                    continue;
+                  }
+                  break;
+                }
+                if (code === CHAR_RIGHT_CURLY_BRACE) {
+                  braces--;
+                  if (braces === 0) {
+                    braceEscaped = false;
+                    isBrace = token.isBrace = true;
+                    finished = true;
+                    break;
+                  }
+                }
+              }
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (code === CHAR_FORWARD_SLASH) {
+              slashes.push(index);
+              tokens.push(token);
+              token = { value: "", depth: 0, isGlob: false };
+              if (finished === true) continue;
+              if (prev === CHAR_DOT && index === start + 1) {
+                start += 2;
+                continue;
+              }
+              lastIndex = index + 1;
+              continue;
+            }
+            if (opts.noext !== true) {
+              const isExtglobChar = code === CHAR_PLUS || code === CHAR_AT || code === CHAR_ASTERISK || code === CHAR_QUESTION_MARK || code === CHAR_EXCLAMATION_MARK;
+              if (isExtglobChar === true && peek() === CHAR_LEFT_PARENTHESES) {
+                isGlob = token.isGlob = true;
+                isExtglob = token.isExtglob = true;
+                finished = true;
+                if (code === CHAR_EXCLAMATION_MARK && index === start) {
+                  negatedExtglob = true;
+                }
+                if (scanToEnd === true) {
+                  while (eos() !== true && (code = advance())) {
+                    if (code === CHAR_BACKWARD_SLASH) {
+                      backslashes = token.backslashes = true;
+                      code = advance();
+                      continue;
+                    }
+                    if (code === CHAR_RIGHT_PARENTHESES) {
+                      isGlob = token.isGlob = true;
+                      finished = true;
+                      break;
+                    }
+                  }
+                  continue;
+                }
+                break;
+              }
+            }
+            if (code === CHAR_ASTERISK) {
+              if (prev === CHAR_ASTERISK) isGlobstar = token.isGlobstar = true;
+              isGlob = token.isGlob = true;
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (code === CHAR_QUESTION_MARK) {
+              isGlob = token.isGlob = true;
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (code === CHAR_LEFT_SQUARE_BRACKET) {
+              while (eos() !== true && (next = advance())) {
+                if (next === CHAR_BACKWARD_SLASH) {
+                  backslashes = token.backslashes = true;
+                  advance();
+                  continue;
+                }
+                if (next === CHAR_RIGHT_SQUARE_BRACKET) {
+                  isBracket = token.isBracket = true;
+                  isGlob = token.isGlob = true;
+                  finished = true;
+                  break;
+                }
+              }
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+            if (opts.nonegate !== true && code === CHAR_EXCLAMATION_MARK && index === start) {
+              negated = token.negated = true;
+              start++;
+              continue;
+            }
+            if (opts.noparen !== true && code === CHAR_LEFT_PARENTHESES) {
+              isGlob = token.isGlob = true;
+              if (scanToEnd === true) {
+                while (eos() !== true && (code = advance())) {
+                  if (code === CHAR_LEFT_PARENTHESES) {
+                    backslashes = token.backslashes = true;
+                    code = advance();
+                    continue;
+                  }
+                  if (code === CHAR_RIGHT_PARENTHESES) {
+                    finished = true;
+                    break;
+                  }
+                }
+                continue;
+              }
+              break;
+            }
+            if (isGlob === true) {
+              finished = true;
+              if (scanToEnd === true) {
+                continue;
+              }
+              break;
+            }
+          }
+          if (opts.noext === true) {
+            isExtglob = false;
+            isGlob = false;
+          }
+          let base = str;
+          let prefix = "";
+          let glob = "";
+          if (start > 0) {
+            prefix = str.slice(0, start);
+            str = str.slice(start);
+            lastIndex -= start;
+          }
+          if (base && isGlob === true && lastIndex > 0) {
+            base = str.slice(0, lastIndex);
+            glob = str.slice(lastIndex);
+          } else if (isGlob === true) {
+            base = "";
+            glob = str;
+          } else {
+            base = str;
+          }
+          if (base && base !== "" && base !== "/" && base !== str) {
+            if (isPathSeparator(base.charCodeAt(base.length - 1))) {
+              base = base.slice(0, -1);
+            }
+          }
+          if (opts.unescape === true) {
+            if (glob) glob = utils.removeBackslashes(glob);
+            if (base && backslashes === true) {
+              base = utils.removeBackslashes(base);
+            }
+          }
+          const state = {
+            prefix,
+            input,
+            start,
+            base,
+            glob,
+            isBrace,
+            isBracket,
+            isGlob,
+            isExtglob,
+            isGlobstar,
+            negated,
+            negatedExtglob
+          };
+          if (opts.tokens === true) {
+            state.maxDepth = 0;
+            if (!isPathSeparator(code)) {
+              tokens.push(token);
+            }
+            state.tokens = tokens;
+          }
+          if (opts.parts === true || opts.tokens === true) {
+            let prevIndex;
+            for (let idx = 0; idx < slashes.length; idx++) {
+              const n = prevIndex ? prevIndex + 1 : start;
+              const i = slashes[idx];
+              const value = input.slice(n, i);
+              if (opts.tokens) {
+                if (idx === 0 && start !== 0) {
+                  tokens[idx].isPrefix = true;
+                  tokens[idx].value = prefix;
+                } else {
+                  tokens[idx].value = value;
+                }
+                depth(tokens[idx]);
+                state.maxDepth += tokens[idx].depth;
+              }
+              if (idx !== 0 || value !== "") {
+                parts.push(value);
+              }
+              prevIndex = i;
+            }
+            if (prevIndex && prevIndex + 1 < input.length) {
+              const value = input.slice(prevIndex + 1);
+              parts.push(value);
+              if (opts.tokens) {
+                tokens[tokens.length - 1].value = value;
+                depth(tokens[tokens.length - 1]);
+                state.maxDepth += tokens[tokens.length - 1].depth;
+              }
+            }
+            state.slashes = slashes;
+            state.parts = parts;
+          }
+          return state;
+        };
+        module22.exports = scan2;
+      }
+    });
+    var require_parse = __commonJS2({
+      "node_modules/picomatch/lib/parse.js"(exports22, module22) {
+        "use strict";
+        var constants = require_constants();
+        var utils = require_utils5();
+        var {
+          MAX_LENGTH,
+          POSIX_REGEX_SOURCE,
+          REGEX_NON_SPECIAL_CHARS,
+          REGEX_SPECIAL_CHARS_BACKREF,
+          REPLACEMENTS
+        } = constants;
+        var expandRange = (args, options) => {
+          if (typeof options.expandRange === "function") {
+            return options.expandRange(...args, options);
+          }
+          args.sort();
+          const value = `[${args.join("-")}]`;
+          try {
+            new RegExp(value);
+          } catch (ex) {
+            return args.map((v) => utils.escapeRegex(v)).join("..");
+          }
+          return value;
+        };
+        var syntaxError = (type, char) => {
+          return `Missing ${type}: "${char}" - use "\\\\${char}" to match literal characters`;
+        };
+        var splitTopLevel = (input) => {
+          const parts = [];
+          let bracket = 0;
+          let paren = 0;
+          let quote = 0;
+          let value = "";
+          let escaped = false;
+          for (const ch of input) {
+            if (escaped === true) {
+              value += ch;
+              escaped = false;
+              continue;
+            }
+            if (ch === "\\") {
+              value += ch;
+              escaped = true;
+              continue;
+            }
+            if (ch === '"') {
+              quote = quote === 1 ? 0 : 1;
+              value += ch;
+              continue;
+            }
+            if (quote === 0) {
+              if (ch === "[") {
+                bracket++;
+              } else if (ch === "]" && bracket > 0) {
+                bracket--;
+              } else if (bracket === 0) {
+                if (ch === "(") {
+                  paren++;
+                } else if (ch === ")" && paren > 0) {
+                  paren--;
+                } else if (ch === "|" && paren === 0) {
+                  parts.push(value);
+                  value = "";
+                  continue;
+                }
+              }
+            }
+            value += ch;
+          }
+          parts.push(value);
+          return parts;
+        };
+        var isPlainBranch = (branch) => {
+          let escaped = false;
+          for (const ch of branch) {
+            if (escaped === true) {
+              escaped = false;
+              continue;
+            }
+            if (ch === "\\") {
+              escaped = true;
+              continue;
+            }
+            if (/[?*+@!()[\]{}]/.test(ch)) {
+              return false;
+            }
+          }
+          return true;
+        };
+        var normalizeSimpleBranch = (branch) => {
+          let value = branch.trim();
+          let changed = true;
+          while (changed === true) {
+            changed = false;
+            if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
+              value = value.slice(2, -1);
+              changed = true;
+            }
+          }
+          if (!isPlainBranch(value)) {
+            return;
+          }
+          return value.replace(/\\(.)/g, "$1");
+        };
+        var hasRepeatedCharPrefixOverlap = (branches) => {
+          const values = branches.map(normalizeSimpleBranch).filter(Boolean);
+          for (let i = 0; i < values.length; i++) {
+            for (let j = i + 1; j < values.length; j++) {
+              const a = values[i];
+              const b = values[j];
+              const char = a[0];
+              if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) {
+                continue;
+              }
+              if (a === b || a.startsWith(b) || b.startsWith(a)) {
+                return true;
+              }
+            }
+          }
+          return false;
+        };
+        var parseRepeatedExtglob = (pattern, requireEnd = true) => {
+          if (pattern[0] !== "+" && pattern[0] !== "*" || pattern[1] !== "(") {
+            return;
+          }
+          let bracket = 0;
+          let paren = 0;
+          let quote = 0;
+          let escaped = false;
+          for (let i = 1; i < pattern.length; i++) {
+            const ch = pattern[i];
+            if (escaped === true) {
+              escaped = false;
+              continue;
+            }
+            if (ch === "\\") {
+              escaped = true;
+              continue;
+            }
+            if (ch === '"') {
+              quote = quote === 1 ? 0 : 1;
+              continue;
+            }
+            if (quote === 1) {
+              continue;
+            }
+            if (ch === "[") {
+              bracket++;
+              continue;
+            }
+            if (ch === "]" && bracket > 0) {
+              bracket--;
+              continue;
+            }
+            if (bracket > 0) {
+              continue;
+            }
+            if (ch === "(") {
+              paren++;
+              continue;
+            }
+            if (ch === ")") {
+              paren--;
+              if (paren === 0) {
+                if (requireEnd === true && i !== pattern.length - 1) {
+                  return;
+                }
+                return {
+                  type: pattern[0],
+                  body: pattern.slice(2, i),
+                  end: i
+                };
+              }
+            }
+          }
+        };
+        var getStarExtglobSequenceOutput = (pattern) => {
+          let index = 0;
+          const chars = [];
+          while (index < pattern.length) {
+            const match2 = parseRepeatedExtglob(pattern.slice(index), false);
+            if (!match2 || match2.type !== "*") {
+              return;
+            }
+            const branches = splitTopLevel(match2.body).map((branch2) => branch2.trim());
+            if (branches.length !== 1) {
+              return;
+            }
+            const branch = normalizeSimpleBranch(branches[0]);
+            if (!branch || branch.length !== 1) {
+              return;
+            }
+            chars.push(branch);
+            index += match2.end + 1;
+          }
+          if (chars.length < 1) {
+            return;
+          }
+          const source = chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`;
+          return `${source}*`;
+        };
+        var repeatedExtglobRecursion = (pattern) => {
+          let depth = 0;
+          let value = pattern.trim();
+          let match2 = parseRepeatedExtglob(value);
+          while (match2) {
+            depth++;
+            value = match2.body.trim();
+            match2 = parseRepeatedExtglob(value);
+          }
+          return depth;
+        };
+        var analyzeRepeatedExtglob = (body, options) => {
+          if (options.maxExtglobRecursion === false) {
+            return { risky: false };
+          }
+          const max = typeof options.maxExtglobRecursion === "number" ? options.maxExtglobRecursion : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
+          const branches = splitTopLevel(body).map((branch) => branch.trim());
+          if (branches.length > 1) {
+            if (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) {
+              return { risky: true };
+            }
+          }
+          for (const branch of branches) {
+            const safeOutput = getStarExtglobSequenceOutput(branch);
+            if (safeOutput) {
+              return { risky: true, safeOutput };
+            }
+            if (repeatedExtglobRecursion(branch) > max) {
+              return { risky: true };
+            }
+          }
+          return { risky: false };
+        };
+        var parse2 = (input, options) => {
+          if (typeof input !== "string") {
+            throw new TypeError("Expected a string");
+          }
+          input = REPLACEMENTS[input] || input;
+          const opts = { ...options };
+          const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+          let len = input.length;
+          if (len > max) {
+            throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+          }
+          const bos = { type: "bos", value: "", output: opts.prepend || "" };
+          const tokens = [bos];
+          const capture = opts.capture ? "" : "?:";
+          const PLATFORM_CHARS = constants.globChars(opts.windows);
+          const EXTGLOB_CHARS = constants.extglobChars(PLATFORM_CHARS);
+          const {
+            DOT_LITERAL,
+            PLUS_LITERAL,
+            SLASH_LITERAL,
+            ONE_CHAR,
+            DOTS_SLASH,
+            NO_DOT,
+            NO_DOT_SLASH,
+            NO_DOTS_SLASH,
+            QMARK,
+            QMARK_NO_DOT,
+            STAR,
+            START_ANCHOR
+          } = PLATFORM_CHARS;
+          const globstar = (opts2) => {
+            return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+          };
+          const nodot = opts.dot ? "" : NO_DOT;
+          const qmarkNoDot = opts.dot ? QMARK : QMARK_NO_DOT;
+          let star = opts.bash === true ? globstar(opts) : STAR;
+          if (opts.capture) {
+            star = `(${star})`;
+          }
+          if (typeof opts.noext === "boolean") {
+            opts.noextglob = opts.noext;
+          }
+          const state = {
+            input,
+            index: -1,
+            start: 0,
+            dot: opts.dot === true,
+            consumed: "",
+            output: "",
+            prefix: "",
+            backtrack: false,
+            negated: false,
+            brackets: 0,
+            braces: 0,
+            parens: 0,
+            quotes: 0,
+            globstar: false,
+            tokens
+          };
+          input = utils.removePrefix(input, state);
+          len = input.length;
+          const extglobs = [];
+          const braces = [];
+          const stack = [];
+          let prev = bos;
+          let value;
+          const eos = () => state.index === len - 1;
+          const peek = state.peek = (n = 1) => input[state.index + n];
+          const advance = state.advance = () => input[++state.index] || "";
+          const remaining = () => input.slice(state.index + 1);
+          const consume = (value2 = "", num = 0) => {
+            state.consumed += value2;
+            state.index += num;
+          };
+          const append = (token) => {
+            state.output += token.output != null ? token.output : token.value;
+            consume(token.value);
+          };
+          const negate = () => {
+            let count = 1;
+            while (peek() === "!" && (peek(2) !== "(" || peek(3) === "?")) {
+              advance();
+              state.start++;
+              count++;
+            }
+            if (count % 2 === 0) {
+              return false;
+            }
+            state.negated = true;
+            state.start++;
+            return true;
+          };
+          const increment = (type) => {
+            state[type]++;
+            stack.push(type);
+          };
+          const decrement = (type) => {
+            state[type]--;
+            stack.pop();
+          };
+          const push = (tok) => {
+            if (prev.type === "globstar") {
+              const isBrace = state.braces > 0 && (tok.type === "comma" || tok.type === "brace");
+              const isExtglob = tok.extglob === true || extglobs.length && (tok.type === "pipe" || tok.type === "paren");
+              if (tok.type !== "slash" && tok.type !== "paren" && !isBrace && !isExtglob) {
+                state.output = state.output.slice(0, -prev.output.length);
+                prev.type = "star";
+                prev.value = "*";
+                prev.output = star;
+                state.output += prev.output;
+              }
+            }
+            if (extglobs.length && tok.type !== "paren") {
+              extglobs[extglobs.length - 1].inner += tok.value;
+            }
+            if (tok.value || tok.output) append(tok);
+            if (prev && prev.type === "text" && tok.type === "text") {
+              prev.output = (prev.output || prev.value) + tok.value;
+              prev.value += tok.value;
+              return;
+            }
+            tok.prev = prev;
+            tokens.push(tok);
+            prev = tok;
+          };
+          const extglobOpen = (type, value2) => {
+            const token = { ...EXTGLOB_CHARS[value2], conditions: 1, inner: "" };
+            token.prev = prev;
+            token.parens = state.parens;
+            token.output = state.output;
+            token.startIndex = state.index;
+            token.tokensIndex = tokens.length;
+            const output = (opts.capture ? "(" : "") + token.open;
+            increment("parens");
+            push({ type, value: value2, output: state.output ? "" : ONE_CHAR });
+            push({ type: "paren", extglob: true, value: advance(), output });
+            extglobs.push(token);
+          };
+          const extglobClose = (token) => {
+            const literal = input.slice(token.startIndex, state.index + 1);
+            const body = input.slice(token.startIndex + 2, state.index);
+            const analysis = analyzeRepeatedExtglob(body, opts);
+            if ((token.type === "plus" || token.type === "star") && analysis.risky) {
+              const safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : void 0;
+              const open = tokens[token.tokensIndex];
+              open.type = "text";
+              open.value = literal;
+              open.output = safeOutput || utils.escapeRegex(literal);
+              for (let i = token.tokensIndex + 1; i < tokens.length; i++) {
+                tokens[i].value = "";
+                tokens[i].output = "";
+                delete tokens[i].suffix;
+              }
+              state.output = token.output + open.output;
+              state.backtrack = true;
+              push({ type: "paren", extglob: true, value, output: "" });
+              decrement("parens");
+              return;
+            }
+            let output = token.close + (opts.capture ? ")" : "");
+            let rest;
+            if (token.type === "negate") {
+              let extglobStar = star;
+              if (token.inner && token.inner.length > 1 && token.inner.includes("/")) {
+                extglobStar = globstar(opts);
+              }
+              if (extglobStar !== star || eos() || /^\)+$/.test(remaining())) {
+                output = token.close = `)$))${extglobStar}`;
+              }
+              if (token.inner.includes("*") && (rest = remaining()) && /^\.[^\\/.]+$/.test(rest)) {
+                const expression = parse2(rest, { ...options, fastpaths: false }).output;
+                output = token.close = `)${expression})${extglobStar})`;
+              }
+              if (token.prev.type === "bos") {
+                state.negatedExtglob = true;
+              }
+            }
+            push({ type: "paren", extglob: true, value, output });
+            decrement("parens");
+          };
+          if (opts.fastpaths !== false && !/(^[*!]|[/()[\]{}"])/.test(input)) {
+            let backslashes = false;
+            let output = input.replace(REGEX_SPECIAL_CHARS_BACKREF, (m, esc, chars, first, rest, index) => {
+              if (first === "\\") {
+                backslashes = true;
+                return m;
+              }
+              if (first === "?") {
+                if (esc) {
+                  return esc + first + (rest ? QMARK.repeat(rest.length) : "");
+                }
+                if (index === 0) {
+                  return qmarkNoDot + (rest ? QMARK.repeat(rest.length) : "");
+                }
+                return QMARK.repeat(chars.length);
+              }
+              if (first === ".") {
+                return DOT_LITERAL.repeat(chars.length);
+              }
+              if (first === "*") {
+                if (esc) {
+                  return esc + first + (rest ? star : "");
+                }
+                return star;
+              }
+              return esc ? m : `\\${m}`;
+            });
+            if (backslashes === true) {
+              if (opts.unescape === true) {
+                output = output.replace(/\\/g, "");
+              } else {
+                output = output.replace(/\\+/g, (m) => {
+                  return m.length % 2 === 0 ? "\\\\" : m ? "\\" : "";
+                });
+              }
+            }
+            if (output === input && opts.contains === true) {
+              state.output = input;
+              return state;
+            }
+            state.output = utils.wrapOutput(output, state, options);
+            return state;
+          }
+          while (!eos()) {
+            value = advance();
+            if (value === "\0") {
+              continue;
+            }
+            if (value === "\\") {
+              const next = peek();
+              if (next === "/" && opts.bash !== true) {
+                continue;
+              }
+              if (next === "." || next === ";") {
+                continue;
+              }
+              if (!next) {
+                value += "\\";
+                push({ type: "text", value });
+                continue;
+              }
+              const match2 = /^\\+/.exec(remaining());
+              let slashes = 0;
+              if (match2 && match2[0].length > 2) {
+                slashes = match2[0].length;
+                state.index += slashes;
+                if (slashes % 2 !== 0) {
+                  value += "\\";
+                }
+              }
+              if (opts.unescape === true) {
+                value = advance();
+              } else {
+                value += advance();
+              }
+              if (state.brackets === 0) {
+                push({ type: "text", value });
+                continue;
+              }
+            }
+            if (state.brackets > 0 && (value !== "]" || prev.value === "[" || prev.value === "[^")) {
+              if (opts.posix !== false && value === ":") {
+                const inner = prev.value.slice(1);
+                if (inner.includes("[")) {
+                  prev.posix = true;
+                  if (inner.includes(":")) {
+                    const idx = prev.value.lastIndexOf("[");
+                    const pre = prev.value.slice(0, idx);
+                    const rest2 = prev.value.slice(idx + 2);
+                    const posix = POSIX_REGEX_SOURCE[rest2];
+                    if (posix) {
+                      prev.value = pre + posix;
+                      state.backtrack = true;
+                      advance();
+                      if (!bos.output && tokens.indexOf(prev) === 1) {
+                        bos.output = ONE_CHAR;
+                      }
+                      continue;
+                    }
+                  }
+                }
+              }
+              if (value === "[" && peek() !== ":" || value === "-" && peek() === "]") {
+                value = `\\${value}`;
+              }
+              if (value === "]" && (prev.value === "[" || prev.value === "[^")) {
+                value = `\\${value}`;
+              }
+              if (opts.posix === true && value === "!" && prev.value === "[") {
+                value = "^";
+              }
+              prev.value += value;
+              append({ value });
+              continue;
+            }
+            if (state.quotes === 1 && value !== '"') {
+              value = utils.escapeRegex(value);
+              prev.value += value;
+              append({ value });
+              continue;
+            }
+            if (value === '"') {
+              state.quotes = state.quotes === 1 ? 0 : 1;
+              if (opts.keepQuotes === true) {
+                push({ type: "text", value });
+              }
+              continue;
+            }
+            if (value === "(") {
+              increment("parens");
+              push({ type: "paren", value });
+              continue;
+            }
+            if (value === ")") {
+              if (state.parens === 0 && opts.strictBrackets === true) {
+                throw new SyntaxError(syntaxError("opening", "("));
+              }
+              const extglob = extglobs[extglobs.length - 1];
+              if (extglob && state.parens === extglob.parens + 1) {
+                extglobClose(extglobs.pop());
+                continue;
+              }
+              push({ type: "paren", value, output: state.parens ? ")" : "\\)" });
+              decrement("parens");
+              continue;
+            }
+            if (value === "[") {
+              if (opts.nobracket === true || !remaining().includes("]")) {
+                if (opts.nobracket !== true && opts.strictBrackets === true) {
+                  throw new SyntaxError(syntaxError("closing", "]"));
+                }
+                value = `\\${value}`;
+              } else {
+                increment("brackets");
+              }
+              push({ type: "bracket", value });
+              continue;
+            }
+            if (value === "]") {
+              if (opts.nobracket === true || prev && prev.type === "bracket" && prev.value.length === 1) {
+                push({ type: "text", value, output: `\\${value}` });
+                continue;
+              }
+              if (state.brackets === 0) {
+                if (opts.strictBrackets === true) {
+                  throw new SyntaxError(syntaxError("opening", "["));
+                }
+                push({ type: "text", value, output: `\\${value}` });
+                continue;
+              }
+              decrement("brackets");
+              const prevValue = prev.value.slice(1);
+              if (prev.posix !== true && prevValue[0] === "^" && !prevValue.includes("/")) {
+                value = `/${value}`;
+              }
+              prev.value += value;
+              append({ value });
+              if (opts.literalBrackets === false || utils.hasRegexChars(prevValue)) {
+                continue;
+              }
+              const escaped = utils.escapeRegex(prev.value);
+              state.output = state.output.slice(0, -prev.value.length);
+              if (opts.literalBrackets === true) {
+                state.output += escaped;
+                prev.value = escaped;
+                continue;
+              }
+              prev.value = `(${capture}${escaped}|${prev.value})`;
+              state.output += prev.value;
+              continue;
+            }
+            if (value === "{" && opts.nobrace !== true) {
+              increment("braces");
+              const open = {
+                type: "brace",
+                value,
+                output: "(",
+                outputIndex: state.output.length,
+                tokensIndex: state.tokens.length
+              };
+              braces.push(open);
+              push(open);
+              continue;
+            }
+            if (value === "}") {
+              const brace = braces[braces.length - 1];
+              if (opts.nobrace === true || !brace) {
+                push({ type: "text", value, output: value });
+                continue;
+              }
+              let output = ")";
+              if (brace.dots === true) {
+                const arr = tokens.slice();
+                const range = [];
+                for (let i = arr.length - 1; i >= 0; i--) {
+                  tokens.pop();
+                  if (arr[i].type === "brace") {
+                    break;
+                  }
+                  if (arr[i].type !== "dots") {
+                    range.unshift(arr[i].value);
+                  }
+                }
+                output = expandRange(range, opts);
+                state.backtrack = true;
+              }
+              if (brace.comma !== true && brace.dots !== true) {
+                const out = state.output.slice(0, brace.outputIndex);
+                const toks = state.tokens.slice(brace.tokensIndex);
+                brace.value = brace.output = "\\{";
+                value = output = "\\}";
+                state.output = out;
+                for (const t of toks) {
+                  state.output += t.output || t.value;
+                }
+              }
+              push({ type: "brace", value, output });
+              decrement("braces");
+              braces.pop();
+              continue;
+            }
+            if (value === "|") {
+              if (extglobs.length > 0) {
+                extglobs[extglobs.length - 1].conditions++;
+              }
+              push({ type: "text", value });
+              continue;
+            }
+            if (value === ",") {
+              let output = value;
+              const brace = braces[braces.length - 1];
+              if (brace && stack[stack.length - 1] === "braces") {
+                brace.comma = true;
+                output = "|";
+              }
+              push({ type: "comma", value, output });
+              continue;
+            }
+            if (value === "/") {
+              if (prev.type === "dot" && state.index === state.start + 1) {
+                state.start = state.index + 1;
+                state.consumed = "";
+                state.output = "";
+                tokens.pop();
+                prev = bos;
+                continue;
+              }
+              push({ type: "slash", value, output: SLASH_LITERAL });
+              continue;
+            }
+            if (value === ".") {
+              if (state.braces > 0 && prev.type === "dot") {
+                if (prev.value === ".") prev.output = DOT_LITERAL;
+                const brace = braces[braces.length - 1];
+                prev.type = "dots";
+                prev.output += value;
+                prev.value += value;
+                brace.dots = true;
+                continue;
+              }
+              if (state.braces + state.parens === 0 && prev.type !== "bos" && prev.type !== "slash") {
+                push({ type: "text", value, output: DOT_LITERAL });
+                continue;
+              }
+              push({ type: "dot", value, output: DOT_LITERAL });
+              continue;
+            }
+            if (value === "?") {
+              const isGroup = prev && prev.value === "(";
+              if (!isGroup && opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+                extglobOpen("qmark", value);
+                continue;
+              }
+              if (prev && prev.type === "paren") {
+                const next = peek();
+                let output = value;
+                if (prev.value === "(" && !/[!=<:]/.test(next) || next === "<" && !/<([!=]|\w+>)/.test(remaining())) {
+                  output = `\\${value}`;
+                }
+                push({ type: "text", value, output });
+                continue;
+              }
+              if (opts.dot !== true && (prev.type === "slash" || prev.type === "bos")) {
+                push({ type: "qmark", value, output: QMARK_NO_DOT });
+                continue;
+              }
+              push({ type: "qmark", value, output: QMARK });
+              continue;
+            }
+            if (value === "!") {
+              if (opts.noextglob !== true && peek() === "(") {
+                if (peek(2) !== "?" || !/[!=<:]/.test(peek(3))) {
+                  extglobOpen("negate", value);
+                  continue;
+                }
+              }
+              if (opts.nonegate !== true && state.index === 0) {
+                negate();
+                continue;
+              }
+            }
+            if (value === "+") {
+              if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+                extglobOpen("plus", value);
+                continue;
+              }
+              if (prev && prev.value === "(" || opts.regex === false) {
+                push({ type: "plus", value, output: PLUS_LITERAL });
+                continue;
+              }
+              if (prev && (prev.type === "bracket" || prev.type === "paren" || prev.type === "brace") || state.parens > 0) {
+                push({ type: "plus", value });
+                continue;
+              }
+              push({ type: "plus", value: PLUS_LITERAL });
+              continue;
+            }
+            if (value === "@") {
+              if (opts.noextglob !== true && peek() === "(" && peek(2) !== "?") {
+                push({ type: "at", extglob: true, value, output: "" });
+                continue;
+              }
+              push({ type: "text", value });
+              continue;
+            }
+            if (value !== "*") {
+              if (value === "$" || value === "^") {
+                value = `\\${value}`;
+              }
+              const match2 = REGEX_NON_SPECIAL_CHARS.exec(remaining());
+              if (match2) {
+                value += match2[0];
+                state.index += match2[0].length;
+              }
+              push({ type: "text", value });
+              continue;
+            }
+            if (prev && (prev.type === "globstar" || prev.star === true)) {
+              prev.type = "star";
+              prev.star = true;
+              prev.value += value;
+              prev.output = star;
+              state.backtrack = true;
+              state.globstar = true;
+              consume(value);
+              continue;
+            }
+            let rest = remaining();
+            if (opts.noextglob !== true && /^\([^?]/.test(rest)) {
+              extglobOpen("star", value);
+              continue;
+            }
+            if (prev.type === "star") {
+              if (opts.noglobstar === true) {
+                consume(value);
+                continue;
+              }
+              const prior = prev.prev;
+              const before = prior.prev;
+              const isStart = prior.type === "slash" || prior.type === "bos";
+              const afterStar = before && (before.type === "star" || before.type === "globstar");
+              if (opts.bash === true && (!isStart || rest[0] && rest[0] !== "/")) {
+                push({ type: "star", value, output: "" });
+                continue;
+              }
+              const isBrace = state.braces > 0 && (prior.type === "comma" || prior.type === "brace");
+              const isExtglob = extglobs.length && (prior.type === "pipe" || prior.type === "paren");
+              if (!isStart && prior.type !== "paren" && !isBrace && !isExtglob) {
+                push({ type: "star", value, output: "" });
+                continue;
+              }
+              while (rest.slice(0, 3) === "/**") {
+                const after = input[state.index + 4];
+                if (after && after !== "/") {
+                  break;
+                }
+                rest = rest.slice(3);
+                consume("/**", 3);
+              }
+              if (prior.type === "bos" && eos()) {
+                prev.type = "globstar";
+                prev.value += value;
+                prev.output = globstar(opts);
+                state.output = prev.output;
+                state.globstar = true;
+                consume(value);
+                continue;
+              }
+              if (prior.type === "slash" && prior.prev.type !== "bos" && !afterStar && eos()) {
+                state.output = state.output.slice(0, -(prior.output + prev.output).length);
+                prior.output = `(?:${prior.output}`;
+                prev.type = "globstar";
+                prev.output = globstar(opts) + (opts.strictSlashes ? ")" : "|$)");
+                prev.value += value;
+                state.globstar = true;
+                state.output += prior.output + prev.output;
+                consume(value);
+                continue;
+              }
+              if (prior.type === "slash" && prior.prev.type !== "bos" && rest[0] === "/") {
+                const end = rest[1] !== void 0 ? "|$" : "";
+                state.output = state.output.slice(0, -(prior.output + prev.output).length);
+                prior.output = `(?:${prior.output}`;
+                prev.type = "globstar";
+                prev.output = `${globstar(opts)}${SLASH_LITERAL}|${SLASH_LITERAL}${end})`;
+                prev.value += value;
+                state.output += prior.output + prev.output;
+                state.globstar = true;
+                consume(value + advance());
+                push({ type: "slash", value: "/", output: "" });
+                continue;
+              }
+              if (prior.type === "bos" && rest[0] === "/") {
+                prev.type = "globstar";
+                prev.value += value;
+                prev.output = `(?:^|${SLASH_LITERAL}|${globstar(opts)}${SLASH_LITERAL})`;
+                state.output = prev.output;
+                state.globstar = true;
+                consume(value + advance());
+                push({ type: "slash", value: "/", output: "" });
+                continue;
+              }
+              state.output = state.output.slice(0, -prev.output.length);
+              prev.type = "globstar";
+              prev.output = globstar(opts);
+              prev.value += value;
+              state.output += prev.output;
+              state.globstar = true;
+              consume(value);
+              continue;
+            }
+            const token = { type: "star", value, output: star };
+            if (opts.bash === true) {
+              token.output = ".*?";
+              if (prev.type === "bos" || prev.type === "slash") {
+                token.output = nodot + token.output;
+              }
+              push(token);
+              continue;
+            }
+            if (prev && (prev.type === "bracket" || prev.type === "paren") && opts.regex === true) {
+              token.output = value;
+              push(token);
+              continue;
+            }
+            if (state.index === state.start || prev.type === "slash" || prev.type === "dot") {
+              if (prev.type === "dot") {
+                state.output += NO_DOT_SLASH;
+                prev.output += NO_DOT_SLASH;
+              } else if (opts.dot === true) {
+                state.output += NO_DOTS_SLASH;
+                prev.output += NO_DOTS_SLASH;
+              } else {
+                state.output += nodot;
+                prev.output += nodot;
+              }
+              if (peek() !== "*") {
+                state.output += ONE_CHAR;
+                prev.output += ONE_CHAR;
+              }
+            }
+            push(token);
+          }
+          while (state.brackets > 0) {
+            if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "]"));
+            state.output = utils.escapeLast(state.output, "[");
+            decrement("brackets");
+          }
+          while (state.parens > 0) {
+            if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", ")"));
+            state.output = utils.escapeLast(state.output, "(");
+            decrement("parens");
+          }
+          while (state.braces > 0) {
+            if (opts.strictBrackets === true) throw new SyntaxError(syntaxError("closing", "}"));
+            state.output = utils.escapeLast(state.output, "{");
+            decrement("braces");
+          }
+          if (opts.strictSlashes !== true && (prev.type === "star" || prev.type === "bracket")) {
+            push({ type: "maybe_slash", value: "", output: `${SLASH_LITERAL}?` });
+          }
+          if (state.backtrack === true) {
+            state.output = "";
+            for (const token of state.tokens) {
+              state.output += token.output != null ? token.output : token.value;
+              if (token.suffix) {
+                state.output += token.suffix;
+              }
+            }
+          }
+          return state;
+        };
+        parse2.fastpaths = (input, options) => {
+          const opts = { ...options };
+          const max = typeof opts.maxLength === "number" ? Math.min(MAX_LENGTH, opts.maxLength) : MAX_LENGTH;
+          const len = input.length;
+          if (len > max) {
+            throw new SyntaxError(`Input length: ${len}, exceeds maximum allowed length: ${max}`);
+          }
+          input = REPLACEMENTS[input] || input;
+          const {
+            DOT_LITERAL,
+            SLASH_LITERAL,
+            ONE_CHAR,
+            DOTS_SLASH,
+            NO_DOT,
+            NO_DOTS,
+            NO_DOTS_SLASH,
+            STAR,
+            START_ANCHOR
+          } = constants.globChars(opts.windows);
+          const nodot = opts.dot ? NO_DOTS : NO_DOT;
+          const slashDot = opts.dot ? NO_DOTS_SLASH : NO_DOT;
+          const capture = opts.capture ? "" : "?:";
+          const state = { negated: false, prefix: "" };
+          let star = opts.bash === true ? ".*?" : STAR;
+          if (opts.capture) {
+            star = `(${star})`;
+          }
+          const globstar = (opts2) => {
+            if (opts2.noglobstar === true) return star;
+            return `(${capture}(?:(?!${START_ANCHOR}${opts2.dot ? DOTS_SLASH : DOT_LITERAL}).)*?)`;
+          };
+          const create = (str) => {
+            switch (str) {
+              case "*":
+                return `${nodot}${ONE_CHAR}${star}`;
+              case ".*":
+                return `${DOT_LITERAL}${ONE_CHAR}${star}`;
+              case "*.*":
+                return `${nodot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+              case "*/*":
+                return `${nodot}${star}${SLASH_LITERAL}${ONE_CHAR}${slashDot}${star}`;
+              case "**":
+                return nodot + globstar(opts);
+              case "**/*":
+                return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${ONE_CHAR}${star}`;
+              case "**/*.*":
+                return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${slashDot}${star}${DOT_LITERAL}${ONE_CHAR}${star}`;
+              case "**/.*":
+                return `(?:${nodot}${globstar(opts)}${SLASH_LITERAL})?${DOT_LITERAL}${ONE_CHAR}${star}`;
+              default: {
+                const match2 = /^(.*?)\.(\w+)$/.exec(str);
+                if (!match2) return;
+                const source2 = create(match2[1]);
+                if (!source2) return;
+                return source2 + DOT_LITERAL + match2[2];
+              }
+            }
+          };
+          const output = utils.removePrefix(input, state);
+          let source = create(output);
+          if (source && opts.strictSlashes !== true) {
+            source += `${SLASH_LITERAL}?`;
+          }
+          return source;
+        };
+        module22.exports = parse2;
+      }
+    });
+    var require_picomatch = __commonJS2({
+      "node_modules/picomatch/lib/picomatch.js"(exports22, module22) {
+        "use strict";
+        var scan2 = require_scan();
+        var parse2 = require_parse();
+        var utils = require_utils5();
+        var constants = require_constants();
+        var isObject = (val) => val && typeof val === "object" && !Array.isArray(val);
+        var picomatch = (glob, options, returnState = false) => {
+          if (Array.isArray(glob)) {
+            const fns = glob.map((input) => picomatch(input, options, returnState));
+            const arrayMatcher = (str) => {
+              for (const isMatch of fns) {
+                const state2 = isMatch(str);
+                if (state2) return state2;
+              }
+              return false;
+            };
+            return arrayMatcher;
+          }
+          const isState = isObject(glob) && glob.tokens && glob.input;
+          if (glob === "" || typeof glob !== "string" && !isState) {
+            throw new TypeError("Expected pattern to be a non-empty string");
+          }
+          const opts = options || {};
+          const posix = opts.windows;
+          const regex = isState ? picomatch.compileRe(glob, options) : picomatch.makeRe(glob, options, false, true);
+          const state = regex.state;
+          delete regex.state;
+          let isIgnored = () => false;
+          if (opts.ignore) {
+            const ignoreOpts = { ...options, ignore: null, onMatch: null, onResult: null };
+            isIgnored = picomatch(opts.ignore, ignoreOpts, returnState);
+          }
+          const matcher = (input, returnObject = false) => {
+            const { isMatch, match: match2, output } = picomatch.test(input, regex, options, { glob, posix });
+            const result = { glob, state, regex, posix, input, output, match: match2, isMatch };
+            if (typeof opts.onResult === "function") {
+              opts.onResult(result);
+            }
+            if (isMatch === false) {
+              result.isMatch = false;
+              return returnObject ? result : false;
+            }
+            if (isIgnored(input)) {
+              if (typeof opts.onIgnore === "function") {
+                opts.onIgnore(result);
+              }
+              result.isMatch = false;
+              return returnObject ? result : false;
+            }
+            if (typeof opts.onMatch === "function") {
+              opts.onMatch(result);
+            }
+            return returnObject ? result : true;
+          };
+          if (returnState) {
+            matcher.state = state;
+          }
+          return matcher;
+        };
+        picomatch.test = (input, regex, options, { glob, posix } = {}) => {
+          if (typeof input !== "string") {
+            throw new TypeError("Expected input to be a string");
+          }
+          if (input === "") {
+            return { isMatch: false, output: "" };
+          }
+          const opts = options || {};
+          const format = opts.format || (posix ? utils.toPosixSlashes : null);
+          let match2 = input === glob;
+          let output = match2 && format ? format(input) : input;
+          if (match2 === false) {
+            output = format ? format(input) : input;
+            match2 = output === glob;
+          }
+          if (match2 === false || opts.capture === true) {
+            if (opts.matchBase === true || opts.basename === true) {
+              match2 = picomatch.matchBase(input, regex, options, posix);
+            } else {
+              match2 = regex.exec(output);
+            }
+          }
+          return { isMatch: Boolean(match2), match: match2, output };
+        };
+        picomatch.matchBase = (input, glob, options) => {
+          const regex = glob instanceof RegExp ? glob : picomatch.makeRe(glob, options);
+          return regex.test(utils.basename(input));
+        };
+        picomatch.isMatch = (str, patterns, options) => picomatch(patterns, options)(str);
+        picomatch.parse = (pattern, options) => {
+          if (Array.isArray(pattern)) return pattern.map((p) => picomatch.parse(p, options));
+          return parse2(pattern, { ...options, fastpaths: false });
+        };
+        picomatch.scan = (input, options) => scan2(input, options);
+        picomatch.compileRe = (state, options, returnOutput = false, returnState = false) => {
+          if (returnOutput === true) {
+            return state.output;
+          }
+          const opts = options || {};
+          const prepend = opts.contains ? "" : "^";
+          const append = opts.contains ? "" : "$";
+          let source = `${prepend}(?:${state.output})${append}`;
+          if (state && state.negated === true) {
+            source = `^(?!${source}).*$`;
+          }
+          const regex = picomatch.toRegex(source, options);
+          if (returnState === true) {
+            regex.state = state;
+          }
+          return regex;
+        };
+        picomatch.makeRe = (input, options = {}, returnOutput = false, returnState = false) => {
+          if (!input || typeof input !== "string") {
+            throw new TypeError("Expected a non-empty string");
+          }
+          let parsed = { negated: false, fastpaths: true };
+          if (options.fastpaths !== false && (input[0] === "." || input[0] === "*")) {
+            parsed.output = parse2.fastpaths(input, options);
+          }
+          if (!parsed.output) {
+            parsed = parse2(input, options);
+          }
+          return picomatch.compileRe(parsed, options, returnOutput, returnState);
+        };
+        picomatch.toRegex = (source, options) => {
+          try {
+            const opts = options || {};
+            return new RegExp(source, opts.flags || (opts.nocase ? "i" : ""));
+          } catch (err) {
+            if (options && options.debug === true) throw err;
+            return /$^/;
+          }
+        };
+        picomatch.constants = constants;
+        module22.exports = picomatch;
+      }
+    });
+    var require_picomatch2 = __commonJS2({
+      "node_modules/picomatch/index.js"(exports22, module22) {
+        "use strict";
+        var pico = require_picomatch();
+        var utils = require_utils5();
+        function picomatch(glob, options, returnState = false) {
+          if (options && (options.windows === null || options.windows === void 0)) {
+            options = { ...options, windows: utils.isWindows() };
+          }
+          return pico(glob, options, returnState);
+        }
+        Object.assign(picomatch, pico);
+        module22.exports = picomatch;
+      }
+    });
+    var require_match = __commonJS2({
+      "src/match.js"(exports22, module22) {
+        var picomatch = require_picomatch2();
+        function match2(patterns, options) {
+          return picomatch(patterns, options);
+        }
+        module22.exports = match2;
+      }
+    });
+    var require_scan2 = __commonJS2({
       "src/scan.js"(exports22, module22) {
+        var createMatch = require_match();
+        function list(value) {
+          if (value === void 0 || value === null) {
+            return [];
+          }
+          if (!Array.isArray(value)) {
+            return [value];
+          }
+          return value;
+        }
         function trimmer(value) {
           return (value || "").trim();
         }
@@ -6085,16 +7850,23 @@ var require_dist = __commonJS({
             transform = options;
             options = {};
           }
+          const ik = list(options.ik);
+          const ek = list(options.ek);
+          const include = createMatch(ik, { ignore: ek });
+          const exclude = createMatch(ek);
           const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
           const parsed = {};
           let lines = (src || "").toString();
           if (options.convertWindowsNewlines !== false) {
             lines = lines.replace(/\r\n?/mg, "\n");
           }
-          let match;
-          while ((match = LINE.exec(lines)) !== null) {
-            const name = match[1];
-            const raw = match[2];
+          let match2;
+          while ((match2 = LINE.exec(lines)) !== null) {
+            const name = match2[1];
+            if (exclude(name) || ik.length > 0 && !include(name)) {
+              continue;
+            }
+            const raw = match2[2];
             const quote = getQuote(raw);
             const value = clean(raw, quote, options);
             let parsedValue = value;
@@ -6119,7 +7891,7 @@ var require_dist = __commonJS({
       "src/keyring.js"(exports22, module22) {
         var fs2 = require("fs");
         var derive2 = require_derive();
-        var scan2 = require_scan();
+        var scan2 = require_scan2();
         async function keysFromFile(filepath = ".env.keys") {
           try {
             const src = await fs2.promises.readFile(filepath, "utf8");
@@ -6127,7 +7899,13 @@ var require_dist = __commonJS({
             const result = [];
             for (const name in parsed) {
               if (name.startsWith("DOTENV_PRIVATE_KEY")) {
-                result.push(parsed[name][parsed[name].length - 1]);
+                const values = parsed[name];
+                for (const value of values) {
+                  const splits = value.split(",");
+                  for (const split of splits) {
+                    result.push(split);
+                  }
+                }
               }
             }
             return result;
@@ -6142,7 +7920,13 @@ var require_dist = __commonJS({
             const result = [];
             for (const name in parsed) {
               if (name.startsWith("DOTENV_PRIVATE_KEY")) {
-                result.push(parsed[name][parsed[name].length - 1]);
+                const values = parsed[name];
+                for (const value of values) {
+                  const splits = value.split(",");
+                  for (const split of splits) {
+                    result.push(split);
+                  }
+                }
               }
             }
             return result;
@@ -6160,6 +7944,10 @@ var require_dist = __commonJS({
             privateKeyValues.push(...await keysFromFile(filepath));
           }
           for (const name in processEnv2) {
+            if (name.startsWith("DOTENV_PUBLIC_KEY")) {
+              const publicKeyHex = processEnv2[name];
+              ring[publicKeyHex] ||= "";
+            }
             if (name.startsWith("DOTENV_PRIVATE_KEY")) {
               privateKeyValues.push(processEnv2[name]);
             }
@@ -6176,9 +7964,12 @@ var require_dist = __commonJS({
               if (ring[publicKeyHex]) {
                 continue;
               }
-              const privateKeyHex = await provider(publicKeyHex);
-              if (privateKeyHex) {
-                ring[publicKeyHex] = privateKeyHex;
+              const providerRing = await provider(publicKeyHex);
+              for (const providerPublicKeyHex in providerRing || {}) {
+                const providerPrivateKeyHex = providerRing[providerPublicKeyHex];
+                if (providerPrivateKeyHex) {
+                  ring[providerPublicKeyHex] = providerPrivateKeyHex;
+                }
               }
             }
           }
@@ -6193,6 +7984,10 @@ var require_dist = __commonJS({
             return acc.concat(keysFromFileSync(filepath));
           }, []);
           for (const name in processEnv2) {
+            if (name.startsWith("DOTENV_PUBLIC_KEY")) {
+              const publicKeyHex = processEnv2[name];
+              ring[publicKeyHex] ||= "";
+            }
             if (name.startsWith("DOTENV_PRIVATE_KEY")) {
               privateKeyValues.push(processEnv2[name]);
             }
@@ -6209,9 +8004,12 @@ var require_dist = __commonJS({
               if (ring[publicKeyHex]) {
                 continue;
               }
-              const privateKeyHex = provider(publicKeyHex);
-              if (privateKeyHex) {
-                ring[publicKeyHex] = privateKeyHex;
+              const providerRing = provider(publicKeyHex);
+              for (const providerPublicKeyHex in providerRing || {}) {
+                const providerPrivateKeyHex = providerRing[providerPublicKeyHex];
+                if (providerPrivateKeyHex) {
+                  ring[providerPublicKeyHex] = providerPrivateKeyHex;
+                }
               }
             }
           }
@@ -6223,7 +8021,7 @@ var require_dist = __commonJS({
     });
     var require_publickeys = __commonJS2({
       "src/publickeys.js"(exports22, module22) {
-        var scan2 = require_scan();
+        var scan2 = require_scan2();
         function publickeys2(src) {
           const { parsed } = scan2(src);
           const result = [];
@@ -6237,16 +8035,27 @@ var require_dist = __commonJS({
         module22.exports = publickeys2;
       }
     });
-    var require_parse = __commonJS2({
+    var require_parse2 = __commonJS2({
       "src/parse.js"(exports22, module22) {
         var decrypt2 = require_decrypt();
+        var Errors = require_errors();
         var keyring2 = require_keyring();
         var keyringSync2 = require_keyring().sync;
         var encrypted2 = require_encrypted();
         var evaluate2 = require_evaluate();
         var expand2 = require_expand();
+        var match2 = require_match();
         var publickeys2 = require_publickeys();
-        var scan2 = require_scan();
+        var scan2 = require_scan2();
+        function list(value) {
+          if (value === void 0 || value === null) {
+            return [];
+          }
+          if (!Array.isArray(value)) {
+            return [value];
+          }
+          return value;
+        }
         function resolveEscapeSequences(value) {
           return value.replace(/\\\$/g, "$");
         }
@@ -6274,18 +8083,32 @@ var require_dist = __commonJS({
           }
           return value;
         }
+        function unresolvedEncryptedError(unresolved) {
+          const keys = Object.keys(unresolved);
+          if (keys.length === 0) {
+            return null;
+          }
+          const error = new Errors({ message: `could not decrypt ${keys.join(", ")}` }).decryptionFailed();
+          return {
+            code: error.code,
+            message: error.message
+          };
+        }
         async function parse2(src, options = {}) {
-          const { overload, processEnv: processEnv2, fk, provider, publicKeyHexes, ring: initialRing } = keyringOptions(src, options);
+          const { overload, array, ik, ek, processEnv: processEnv2, fk, provider, publicKeyHexes, ring: initialRing } = keyringOptions(src, options);
           const ring = await keyring2({ processEnv: processEnv2, ring: initialRing, fk, provider });
-          return parseWithRing(src, { overload, processEnv: processEnv2, ring, publicKeyHexes });
+          return parseWithRing(src, { overload, array, ik, ek, processEnv: processEnv2, ring, publicKeyHexes });
         }
         function parseSync22(src, options = {}) {
-          const { overload, processEnv: processEnv2, fk, provider, publicKeyHexes, ring: initialRing } = keyringOptions(src, options);
+          const { overload, array, ik, ek, processEnv: processEnv2, fk, provider, publicKeyHexes, ring: initialRing } = keyringOptions(src, options);
           const ring = keyringSync2({ processEnv: processEnv2, ring: initialRing, fk, provider });
-          return parseWithRing(src, { overload, processEnv: processEnv2, ring, publicKeyHexes });
+          return parseWithRing(src, { overload, array, ik, ek, processEnv: processEnv2, ring, publicKeyHexes });
         }
         function keyringOptions(src, options = {}) {
           const overload = options.overload;
+          const array = options.array;
+          const ik = list(options.ik);
+          const ek = list(options.ek);
           const processEnv2 = options.processEnv || process.env;
           const fk = options.fk;
           const provider = options.provider;
@@ -6294,13 +8117,18 @@ var require_dist = __commonJS({
           for (const publicKeyHex of publicKeyHexes) {
             ring[publicKeyHex] = "";
           }
-          return { overload, processEnv: processEnv2, fk, provider, publicKeyHexes, ring };
+          return { overload, array, ik, ek, processEnv: processEnv2, fk, provider, publicKeyHexes, ring };
         }
         function parseWithRing(src, options = {}) {
           const overload = options.overload;
+          const array = options.array;
+          const ik = options.ik || [];
+          const ek = options.ek || [];
           const processEnv2 = options.processEnv || process.env;
           const ring = options.ring || {};
           const publicKeyHexes = options.publicKeyHexes || [];
+          const include = match2(ik, { ignore: ek });
+          const exclude = match2(ek);
           function inProcessEnv(name) {
             return Object.prototype.hasOwnProperty.call(processEnv2, name);
           }
@@ -6309,12 +8137,19 @@ var require_dist = __commonJS({
           const parsed = {};
           const injected = {};
           const existed = {};
+          const unresolvedEncrypted = {};
           scan2(src, ({ name, value, quote }) => {
             let parsedValue = value;
             if (!overload && inProcessEnv(name)) {
               parsedValue = processEnv2[name];
             }
-            parsedValue = decryptWithKeyring(ring, parsedValue, publicKeyHexes);
+            const encryptedBefore = encrypted2(parsedValue);
+            if (!exclude(name) && (ik.length === 0 || include(name))) {
+              parsedValue = decryptWithKeyring(ring, parsedValue, publicKeyHexes);
+              if (encryptedBefore && encrypted2(parsedValue)) {
+                unresolvedEncrypted[name] = true;
+              }
+            }
             const encryptedPrefixed = encrypted2(parsedValue);
             let evaled = false;
             if (!encryptedPrefixed && quote !== "'" && (!inProcessEnv(name) || processEnv2[name] === parsedValue)) {
@@ -6334,18 +8169,39 @@ var require_dist = __commonJS({
               literals[name] = parsedValue;
             }
             runningParsed[name] = parsedValue;
-            parsed[name] = parsedValue;
+            if (array) {
+              parsed[name] = parsed[name] || [];
+              parsed[name].push(parsedValue);
+            } else {
+              parsed[name] = parsedValue;
+            }
             if (Object.prototype.hasOwnProperty.call(processEnv2, name) && !overload) {
-              existed[name] = processEnv2[name];
+              if (array) {
+                existed[name] = existed[name] || [];
+                existed[name].push(processEnv2[name]);
+              } else {
+                existed[name] = processEnv2[name];
+              }
             } else {
-              injected[name] = parsed[name];
+              if (array) {
+                injected[name] = injected[name] || [];
+                injected[name].push(parsedValue);
+              } else {
+                injected[name] = parsed[name];
+              }
             }
             return parsedValue;
           });
+          const errors = [];
+          const error = unresolvedEncryptedError(unresolvedEncrypted);
+          if (error) {
+            errors.push(error);
+          }
           return {
             parsed,
             injected,
-            existed
+            existed,
+            errors
           };
         }
         module22.exports = parse2;
@@ -6355,15 +8211,21 @@ var require_dist = __commonJS({
     var require_sealed = __commonJS2({
       "src/sealed.js"(exports22, module22) {
         var encrypted2 = require_encrypted();
-        var scan2 = require_scan();
+        var scan2 = require_scan2();
         function publicKey(name) {
           return name.startsWith("DOTENV_PUBLIC_KEY");
         }
+        function plainKey(name) {
+          return name.endsWith("_PLAIN");
+        }
         function sealed2(src) {
           const { parsed } = scan2(src);
           for (const [name, values] of Object.entries(parsed)) {
+            if (publicKey(name) || plainKey(name)) {
+              continue;
+            }
             for (const value of values) {
-              if (!encrypted2(value) && !publicKey(name)) {
+              if (!encrypted2(value)) {
                 return false;
               }
             }
@@ -6373,6 +8235,68 @@ var require_dist = __commonJS({
         module22.exports = sealed2;
       }
     });
+    var require_upsert = __commonJS2({
+      "src/upsert.js"(exports22, module22) {
+        var scan2 = require_scan2();
+        function escapeForRegex(str) {
+          return str.replace(/[|\\{}()[\]^$+*?.]/g, "\\$&").replace(/-/g, "\\x2d");
+        }
+        function replaceExistingValue(src, key, originalValue, replaceValue) {
+          const escapedKey = escapeForRegex(key);
+          const escapedOriginalValue = escapeForRegex(originalValue);
+          let enforceEndOfLine = "";
+          if (escapedOriginalValue === "") {
+            enforceEndOfLine = "$";
+          }
+          const currentPart = new RegExp(
+            "^(\\s*)?(export\\s+)?" + escapedKey + "\\s*=\\s*([\"'`]?)" + escapedOriginalValue + "\\3" + enforceEndOfLine,
+            "m"
+          );
+          return src.replace(currentPart, function(match2, spaces = "", exportPart = "", quote = "") {
+            let newPart = `${key}=${quote}${replaceValue}${quote}`;
+            const newlineMatch = src.match(new RegExp(`${escapedKey}\\s*=\\s*
+
+`, "m"));
+            if (escapedOriginalValue === "" && quote === "" && newlineMatch) {
+              const newlineCount = newlineMatch[0].match(/\n/g).length - 1;
+              for (let i = 0; i < newlineCount; i++) {
+                newPart += "\n";
+              }
+            }
+            return `${spaces}${exportPart}${newPart}`;
+          });
+        }
+        function upsert2(src, key, replaceValue) {
+          let output;
+          let newPart = "";
+          const { parsed } = scan2(src, { expandDoubleQuotedNewlines: false, convertWindowsNewlines: false });
+          if (Object.prototype.hasOwnProperty.call(parsed, key)) {
+            const allValues = parsed[key];
+            let duplicateOutput = src;
+            const replacements = Array.isArray(replaceValue) ? replaceValue : allValues.map(() => replaceValue);
+            allValues.forEach((value, index) => {
+              duplicateOutput = replaceExistingValue(duplicateOutput, key, value, `\0DOTENVX_UPSERT_${index}\0`);
+            });
+            replacements.forEach((replacement, index) => {
+              duplicateOutput = duplicateOutput.split(`\0DOTENVX_UPSERT_${index}\0`).join(replacement);
+            });
+            return duplicateOutput;
+          } else {
+            newPart += `${key}="${replaceValue}"`;
+            if (src === "") {
+              newPart = newPart + "\n";
+            } else if (src.endsWith("\n")) {
+              newPart = newPart + "\n";
+            } else {
+              newPart = "\n" + newPart;
+            }
+            output = src + newPart;
+          }
+          return output;
+        }
+        module22.exports = upsert2;
+      }
+    });
     var decrypt = require_decrypt();
     var derive = require_derive();
     var encrypt = require_encrypt();
@@ -6382,11 +8306,13 @@ var require_dist = __commonJS({
     var keypair = require_keypair();
     var keyring = require_keyring();
     var keyringSync = require_keyring().sync;
-    var parse = require_parse();
-    var parseSync2 = require_parse().sync;
+    var match = require_match();
+    var parse = require_parse2();
+    var parseSync2 = require_parse2().sync;
     var publickeys = require_publickeys();
-    var scan = require_scan();
+    var scan = require_scan2();
     var sealed = require_sealed();
+    var upsert = require_upsert();
     module2.exports = {
       decrypt,
       derive,
@@ -6397,11 +8323,13 @@ var require_dist = __commonJS({
       keypair,
       keyring,
       keyringSync,
+      match,
       parse,
       parseSync: parseSync2,
       publickeys,
       scan,
-      sealed
+      sealed,
+      upsert
     };
   }
 });