@socketsecurity/lib 5.25.1 → 5.26.1

package/dist/external/yargs-parser.js

@@ -1,4 +1,4 @@
-const { ArrayIsArray: _p_ArrayIsArray, ObjectCreate: _p_ObjectCreate } = require('../primordials.js')
+const { ArrayIsArray: _p_ArrayIsArray, JSONParse: _p_JSONParse, MathFloor: _p_MathFloor, MathMin: _p_MathMin, NumberIsSafeInteger: _p_NumberIsSafeInteger, ObjectAssign: _p_ObjectAssign, ObjectCreate: _p_ObjectCreate, ObjectDefineProperty: _p_ObjectDefineProperty, ObjectEntries: _p_ObjectEntries, ObjectKeys: _p_ObjectKeys, RegExpCtor: _p_RegExpCtor, SetCtor: _p_SetCtor, StringPrototypeCharAt: _p_StringPrototypeCharAt, StringPrototypeSubstring: _p_StringPrototypeSubstring } = require('../primordials.js')
 "use strict";
 /**
  * Bundled from yargs-parser
@@ -40,7 +40,7 @@ function camelCase(str) {
     let nextChrUpper = false;
     const leadingHyphens = str.match(/^-+/);
     for (let i = leadingHyphens ? leadingHyphens[0].length : 0; i < str.length; i++) {
-      let chr = str.charAt(i);
+      let chr = _p_StringPrototypeCharAt(str, i);
       if (nextChrUpper) {
         nextChrUpper = false;
         chr = chr.toUpperCase();
@@ -59,10 +59,10 @@ function decamelize(str, joinString) {
   joinString = joinString || "-";
   let notCamelcase = "";
   for (let i = 0; i < str.length; i++) {
-    const chrLower = lowercase.charAt(i);
-    const chrString = str.charAt(i);
+    const chrLower = _p_StringPrototypeCharAt(lowercase, i);
+    const chrString = _p_StringPrototypeCharAt(str, i);
     if (chrLower !== chrString && i > 0) {
-      notCamelcase += `${joinString}${lowercase.charAt(i)}`;
+      notCamelcase += `${joinString}${_p_StringPrototypeCharAt(lowercase, i)}`;
     } else {
       notCamelcase += chrString;
     }
@@ -101,7 +101,7 @@ function tokenizeArgString(argString) {
   const args = [];
   for (let ii = 0; ii < argString.length; ii++) {
     prevC = c;
-    c = argString.charAt(ii);
+    c = _p_StringPrototypeCharAt(argString, ii);
     if (c === " " && !opening) {
       if (!(prevC === " ")) {
         i++;
@@ -143,7 +143,7 @@ function combineAliases(aliases) {
   const aliasArrays = [];
   const combined = /* @__PURE__ */ _p_ObjectCreate(null);
   let change = true;
-  Object.keys(aliases).forEach(function(key) {
+  _p_ObjectKeys(aliases).forEach(function(key) {
     aliasArrays.push([].concat(aliases[key], key));
   });
   while (change) {
@@ -198,7 +198,7 @@ var init_yargs_parser = __esm({
         mixin = _mixin;
       }
       parse(argsInput, options) {
-        const opts = Object.assign({
+        const opts = _p_ObjectAssign({
           alias: void 0,
           array: void 0,
           boolean: void 0,
@@ -218,8 +218,8 @@ var init_yargs_parser = __esm({
         }, options);
         const args = tokenizeArgString(argsInput);
         const inputIsString = typeof argsInput === "string";
-        const aliases = combineAliases(Object.assign(/* @__PURE__ */ Object.create(null), opts.alias));
-        const configuration = Object.assign({
+        const aliases = combineAliases(_p_ObjectAssign(/* @__PURE__ */ _p_ObjectCreate(null), opts.alias));
+        const configuration = _p_ObjectAssign({
           "boolean-negation": true,
           "camel-case-expansion": true,
           "combine-arrays": false,
@@ -239,32 +239,32 @@ var init_yargs_parser = __esm({
           "strip-dashed": false,
           "unknown-options-as-args": false
         }, opts.configuration);
-        const defaults = Object.assign(/* @__PURE__ */ Object.create(null), opts.default);
+        const defaults = _p_ObjectAssign(/* @__PURE__ */ _p_ObjectCreate(null), opts.default);
         const configObjects = opts.configObjects || [];
         const envPrefix = opts.envPrefix;
         const notFlagsOption = configuration["populate--"];
         const notFlagsArgv = notFlagsOption ? "--" : "_";
-        const newAliases = /* @__PURE__ */ Object.create(null);
-        const defaulted = /* @__PURE__ */ Object.create(null);
+        const newAliases = /* @__PURE__ */ _p_ObjectCreate(null);
+        const defaulted = /* @__PURE__ */ _p_ObjectCreate(null);
         const __ = opts.__ || mixin.format;
         const flags = {
-          aliases: /* @__PURE__ */ Object.create(null),
-          arrays: /* @__PURE__ */ Object.create(null),
-          bools: /* @__PURE__ */ Object.create(null),
-          strings: /* @__PURE__ */ Object.create(null),
-          numbers: /* @__PURE__ */ Object.create(null),
-          counts: /* @__PURE__ */ Object.create(null),
-          normalize: /* @__PURE__ */ Object.create(null),
-          configs: /* @__PURE__ */ Object.create(null),
-          nargs: /* @__PURE__ */ Object.create(null),
-          coercions: /* @__PURE__ */ Object.create(null),
+          aliases: /* @__PURE__ */ _p_ObjectCreate(null),
+          arrays: /* @__PURE__ */ _p_ObjectCreate(null),
+          bools: /* @__PURE__ */ _p_ObjectCreate(null),
+          strings: /* @__PURE__ */ _p_ObjectCreate(null),
+          numbers: /* @__PURE__ */ _p_ObjectCreate(null),
+          counts: /* @__PURE__ */ _p_ObjectCreate(null),
+          normalize: /* @__PURE__ */ _p_ObjectCreate(null),
+          configs: /* @__PURE__ */ _p_ObjectCreate(null),
+          nargs: /* @__PURE__ */ _p_ObjectCreate(null),
+          coercions: /* @__PURE__ */ _p_ObjectCreate(null),
           keys: []
         };
         const negative = /^-([0-9]+(\.[0-9]+)?|\.[0-9]+)$/;
-        const negatedBoolean = new RegExp("^--" + configuration["negation-prefix"] + "(.+)");
+        const negatedBoolean = new _p_RegExpCtor("^--" + configuration["negation-prefix"] + "(.+)");
         [].concat(opts.array || []).filter(Boolean).forEach(function(opt) {
           const key = typeof opt === "object" ? opt.key : opt;
-          const assignment = Object.keys(opt).map(function(key2) {
+          const assignment = _p_ObjectKeys(opt).map(function(key2) {
             const arrayFlagKeys = {
               boolean: "bools",
               string: "strings",
@@ -299,7 +299,7 @@ var init_yargs_parser = __esm({
           flags.keys.push(key);
         });
         if (typeof opts.narg === "object") {
-          Object.entries(opts.narg).forEach(([key, value]) => {
+          _p_ObjectEntries(opts.narg).forEach(([key, value]) => {
             if (typeof value === "number") {
               flags.nargs[key] = value;
               flags.keys.push(key);
@@ -307,7 +307,7 @@ var init_yargs_parser = __esm({
           });
         }
         if (typeof opts.coerce === "object") {
-          Object.entries(opts.coerce).forEach(([key, value]) => {
+          _p_ObjectEntries(opts.coerce).forEach(([key, value]) => {
             if (typeof value === "function") {
               flags.coercions[key] = value;
               flags.keys.push(key);
@@ -315,13 +315,13 @@ var init_yargs_parser = __esm({
           });
         }
         if (typeof opts.config !== "undefined") {
-          if (Array.isArray(opts.config) || typeof opts.config === "string") {
+          if (_p_ArrayIsArray(opts.config) || typeof opts.config === "string") {
             ;
             [].concat(opts.config).filter(Boolean).forEach(function(key) {
               flags.configs[key] = true;
             });
           } else if (typeof opts.config === "object") {
-            Object.entries(opts.config).forEach(([key, value]) => {
+            _p_ObjectEntries(opts.config).forEach(([key, value]) => {
               if (typeof value === "boolean" || typeof value === "function") {
                 flags.configs[key] = value;
               }
@@ -329,7 +329,7 @@ var init_yargs_parser = __esm({
           }
         }
         extendAliases(opts.key, aliases, opts.default, flags.arrays);
-        Object.keys(defaults).forEach(function(key) {
+        _p_ObjectKeys(defaults).forEach(function(key) {
           (flags.aliases[key] || []).forEach(function(alias) {
             defaults[alias] = defaults[key];
           });
@@ -337,7 +337,7 @@ var init_yargs_parser = __esm({
         let error = null;
         checkConfiguration();
         let notFlags = [];
-        const argv = Object.assign(/* @__PURE__ */ Object.create(null), { _: [] });
+        const argv = _p_ObjectAssign(/* @__PURE__ */ _p_ObjectCreate(null), { _: [] });
         const argvReturn = {};
         for (let i = 0; i < args.length; i++) {
           const arg = args[i];
@@ -355,7 +355,7 @@ var init_yargs_parser = __esm({
             continue;
           } else if (arg.match(/^--.+=/) || !configuration["short-option-groups"] && arg.match(/^-.+=/)) {
             m = arg.match(/^--?([^=]+)=([\s\S]*)$/);
-            if (m !== null && Array.isArray(m) && m.length >= 3) {
+            if (m !== null && _p_ArrayIsArray(m) && m.length >= 3) {
               if (checkAllAliases(m[1], flags.arrays)) {
                 i = eatArray(i, m[1], args, m[2]);
               } else if (checkAllAliases(m[1], flags.nargs) !== false) {
@@ -366,13 +366,13 @@ var init_yargs_parser = __esm({
             }
           } else if (arg.match(negatedBoolean) && configuration["boolean-negation"]) {
             m = arg.match(negatedBoolean);
-            if (m !== null && Array.isArray(m) && m.length >= 2) {
+            if (m !== null && _p_ArrayIsArray(m) && m.length >= 2) {
               key = m[1];
               setArg(key, checkAllAliases(key, flags.arrays) ? [false] : false);
             }
           } else if (arg.match(/^--.+/) || !configuration["short-option-groups"] && arg.match(/^-[^-]+/)) {
             m = arg.match(/^--?(.+)/);
-            if (m !== null && Array.isArray(m) && m.length >= 2) {
+            if (m !== null && _p_ArrayIsArray(m) && m.length >= 2) {
               key = m[1];
               if (checkAllAliases(key, flags.arrays)) {
                 i = eatArray(i, key, args);
@@ -393,13 +393,13 @@ var init_yargs_parser = __esm({
             }
           } else if (arg.match(/^-.\..+=/)) {
             m = arg.match(/^-([^=]+)=([\s\S]*)$/);
-            if (m !== null && Array.isArray(m) && m.length >= 3) {
+            if (m !== null && _p_ArrayIsArray(m) && m.length >= 3) {
               setArg(m[1], m[2]);
             }
           } else if (arg.match(/^-.\..+/) && !arg.match(negative)) {
             next = args[i + 1];
             m = arg.match(/^-(.\..+)/);
-            if (m !== null && Array.isArray(m) && m.length >= 2) {
+            if (m !== null && _p_ArrayIsArray(m) && m.length >= 2) {
               key = m[1];
               if (next !== void 0 && !next.match(/^-/) && !checkAllAliases(key, flags.bools) && !checkAllAliases(key, flags.counts)) {
                 setArg(key, next);
@@ -483,7 +483,7 @@ var init_yargs_parser = __esm({
         applyCoercions(argv);
         if (configuration["set-placeholder-key"])
           setPlaceholderKeys(argv);
-        Object.keys(flags.counts).forEach(function(key) {
+        _p_ObjectKeys(flags.counts).forEach(function(key) {
           if (!hasKey(argv, key.split(".")))
             setArg(key, 0);
         });
@@ -493,13 +493,13 @@ var init_yargs_parser = __esm({
           argv[notFlagsArgv].push(key);
         });
         if (configuration["camel-case-expansion"] && configuration["strip-dashed"]) {
-          Object.keys(argv).filter((key) => key !== "--" && key.includes("-")).forEach((key) => {
+          _p_ObjectKeys(argv).filter((key) => key !== "--" && key.includes("-")).forEach((key) => {
             delete argv[key];
           });
         }
         if (configuration["strip-aliased"]) {
           ;
-          [].concat(...Object.keys(aliases).map((k) => aliases[k])).forEach((alias) => {
+          [].concat(..._p_ObjectKeys(aliases).map((k) => aliases[k])).forEach((alias) => {
             if (configuration["camel-case-expansion"] && alias.includes("-")) {
               delete argv[alias.split(".").map((prop) => camelCase(prop)).join(".")];
             }
@@ -540,7 +540,7 @@ var init_yargs_parser = __esm({
             if (available < toEat)
               error = Error(__("Not enough arguments following: %s", key));
           }
-          let consumed = Math.min(available, toEat);
+          let consumed = _p_MathMin(available, toEat);
           if (!isUndefined(argAfterEqualSign) && consumed > 0) {
             setArg(key, argAfterEqualSign);
             consumed--;
@@ -560,7 +560,7 @@ var init_yargs_parser = __esm({
           } else if (isUndefined(next) || isUndefined(argAfterEqualSign) && /^-/.test(next) && !negative.test(next) && !isUnknownOptionAsArg(next)) {
             if (defaults[key] !== void 0) {
               const defVal = defaults[key];
-              argsToSet = Array.isArray(defVal) ? defVal : [defVal];
+              argsToSet = _p_ArrayIsArray(defVal) ? defVal : [defVal];
             }
           } else {
             if (!isUndefined(argAfterEqualSign)) {
@@ -614,7 +614,7 @@ var init_yargs_parser = __esm({
           if (checkAllAliases(key, flags.normalize) && !checkAllAliases(key, flags.arrays)) {
             const keys = [key].concat(flags.aliases[key] || []);
             keys.forEach(function(key2) {
-              Object.defineProperty(argvReturn, key2, {
+              _p_ObjectDefineProperty(argvReturn, key2, {
                 enumerable: true,
                 get() {
                   return val;
@@ -645,14 +645,14 @@ var init_yargs_parser = __esm({
             if (typeof val === "string")
               val = val === "true";
           }
-          let value = Array.isArray(val) ? val.map(function(v) {
+          let value = _p_ArrayIsArray(val) ? val.map(function(v) {
             return maybeCoerceNumber(key, v);
           }) : maybeCoerceNumber(key, val);
           if (checkAllAliases(key, flags.counts) && (isUndefined(value) || typeof value === "boolean")) {
             value = increment();
           }
           if (checkAllAliases(key, flags.normalize) && checkAllAliases(key, flags.arrays)) {
-            if (Array.isArray(val))
+            if (_p_ArrayIsArray(val))
               value = val.map((val2) => {
                 return mixin.normalize(val2);
               });
@@ -665,8 +665,8 @@ var init_yargs_parser = __esm({
         function maybeCoerceNumber(key, value) {
           if (!configuration["parse-positional-numbers"] && key === "_")
             return value;
-          if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !Array.isArray(value)) {
-            const shouldCoerceNumber = looksLikeNumber(value) && configuration["parse-numbers"] && Number.isSafeInteger(Math.floor(parseFloat(`${value}`)));
+          if (!checkAllAliases(key, flags.strings) && !checkAllAliases(key, flags.bools) && !_p_ArrayIsArray(value)) {
+            const shouldCoerceNumber = looksLikeNumber(value) && configuration["parse-numbers"] && _p_NumberIsSafeInteger(_p_MathFloor(parseFloat(`${value}`)));
             if (shouldCoerceNumber || !isUndefined(value) && checkAllAliases(key, flags.numbers)) {
               value = Number(value);
             }
@@ -675,9 +675,9 @@ var init_yargs_parser = __esm({
         }
         __name(maybeCoerceNumber, "maybeCoerceNumber");
         function setConfig(argv2) {
-          const configLookup = /* @__PURE__ */ Object.create(null);
+          const configLookup = /* @__PURE__ */ _p_ObjectCreate(null);
           applyDefaultsAndAliases(configLookup, flags.aliases, defaults);
-          Object.keys(flags.configs).forEach(function(configKey) {
+          _p_ObjectKeys(flags.configs).forEach(function(configKey) {
             const configPath = argv2[configKey] || configLookup[configKey];
             if (configPath) {
               try {
@@ -709,10 +709,10 @@ var init_yargs_parser = __esm({
         }
         __name(setConfig, "setConfig");
         function setConfigObject(config, prev) {
-          Object.keys(config).forEach(function(key) {
+          _p_ObjectKeys(config).forEach(function(key) {
             const value = config[key];
             const fullKey = prev ? prev + "." + key : key;
-            if (typeof value === "object" && value !== null && !Array.isArray(value) && configuration["dot-notation"]) {
+            if (typeof value === "object" && value !== null && !_p_ArrayIsArray(value) && configuration["dot-notation"]) {
               setConfigObject(value, fullKey);
             } else {
               if (!hasKey(argv, fullKey.split(".")) || checkAllAliases(fullKey, flags.arrays) && configuration["combine-arrays"]) {
@@ -735,11 +735,11 @@ var init_yargs_parser = __esm({
             return;
           const prefix = typeof envPrefix === "string" ? envPrefix : "";
           const env2 = mixin.env();
-          Object.keys(env2).forEach(function(envVar) {
+          _p_ObjectKeys(env2).forEach(function(envVar) {
             if (prefix === "" || envVar.lastIndexOf(prefix, 0) === 0) {
               const keys = envVar.split("__").map(function(key, i) {
                 if (i === 0) {
-                  key = key.substring(prefix.length);
+                  key = _p_StringPrototypeSubstring(key, prefix.length);
                 }
                 return camelCase(key);
               });
@@ -752,8 +752,8 @@ var init_yargs_parser = __esm({
         __name(applyEnvVars, "applyEnvVars");
         function applyCoercions(argv2) {
           let coerce;
-          const applied = /* @__PURE__ */ new Set();
-          Object.keys(argv2).forEach(function(key) {
+          const applied = /* @__PURE__ */ new _p_SetCtor();
+          _p_ObjectKeys(argv2).forEach(function(key) {
             if (!applied.has(key)) {
               coerce = checkAllAliases(key, flags.coercions);
               if (typeof coerce === "function") {
@@ -782,7 +782,7 @@ var init_yargs_parser = __esm({
         }
         __name(setPlaceholderKeys, "setPlaceholderKeys");
         function applyDefaultsAndAliases(obj, aliases2, defaults2, canLog = false) {
-          Object.keys(defaults2).forEach(function(key) {
+          _p_ObjectKeys(defaults2).forEach(function(key) {
             if (!hasKey(obj, key.split("."))) {
               setKey(obj, key.split("."), defaults2[key]);
               if (canLog)
@@ -819,8 +819,8 @@ var init_yargs_parser = __esm({
             if (typeof o === "object" && o[key2] === void 0) {
               o[key2] = {};
             }
-            if (typeof o[key2] !== "object" || Array.isArray(o[key2])) {
-              if (Array.isArray(o[key2])) {
+            if (typeof o[key2] !== "object" || _p_ArrayIsArray(o[key2])) {
+              if (_p_ArrayIsArray(o[key2])) {
                 o[key2].push({});
               } else {
                 o[key2] = [o[key2], {}];
@@ -832,19 +832,19 @@ var init_yargs_parser = __esm({
           });
           const key = sanitizeKey(keys[keys.length - 1]);
           const isTypeArray = checkAllAliases(keys.join("."), flags.arrays);
-          const isValueArray = Array.isArray(value);
+          const isValueArray = _p_ArrayIsArray(value);
           let duplicate = configuration["duplicate-arguments-array"];
           if (!duplicate && checkAllAliases(key, flags.nargs)) {
             duplicate = true;
-            if (!isUndefined(o[key]) && flags.nargs[key] === 1 || Array.isArray(o[key]) && o[key].length === flags.nargs[key]) {
+            if (!isUndefined(o[key]) && flags.nargs[key] === 1 || _p_ArrayIsArray(o[key]) && o[key].length === flags.nargs[key]) {
               o[key] = void 0;
             }
           }
           if (value === increment()) {
             o[key] = increment(o[key]);
-          } else if (Array.isArray(o[key])) {
+          } else if (_p_ArrayIsArray(o[key])) {
             if (duplicate && isTypeArray && isValueArray) {
-              o[key] = configuration["flatten-duplicate-arrays"] ? o[key].concat(value) : (Array.isArray(o[key][0]) ? o[key] : [o[key]]).concat([value]);
+              o[key] = configuration["flatten-duplicate-arrays"] ? o[key].concat(value) : (_p_ArrayIsArray(o[key][0]) ? o[key] : [o[key]]).concat([value]);
             } else if (!duplicate && Boolean(isTypeArray) === Boolean(isValueArray)) {
               o[key] = value;
             } else {
@@ -861,7 +861,7 @@ var init_yargs_parser = __esm({
         __name(setKey, "setKey");
         function extendAliases(...args2) {
           args2.forEach(function(obj) {
-            Object.keys(obj || {}).forEach(function(key) {
+            _p_ObjectKeys(obj || {}).forEach(function(key) {
               if (flags.aliases[key])
                 return;
               flags.aliases[key] = [].concat(aliases[key] || []);
@@ -894,16 +894,16 @@ var init_yargs_parser = __esm({
         __name(extendAliases, "extendAliases");
         function checkAllAliases(key, flag) {
           const toCheck = [].concat(flags.aliases[key] || [], key);
-          const keys = Object.keys(flag);
+          const keys = _p_ObjectKeys(flag);
           const setAlias = toCheck.find((key2) => keys.includes(key2));
           return setAlias ? flag[setAlias] : false;
         }
         __name(checkAllAliases, "checkAllAliases");
         function hasAnyFlag(key) {
-          const flagsKeys = Object.keys(flags);
+          const flagsKeys = _p_ObjectKeys(flags);
           const toCheck = [].concat(flagsKeys.map((k) => flags[k]));
           return toCheck.some(function(flag) {
-            return Array.isArray(flag) ? flag.includes(key) : flag[key];
+            return _p_ArrayIsArray(flag) ? flag.includes(key) : flag[key];
           });
         }
         __name(hasAnyFlag, "hasAnyFlag");
@@ -991,7 +991,7 @@ var init_yargs_parser = __esm({
         }
         __name(isUndefined, "isUndefined");
         function checkConfiguration() {
-          Object.keys(flags.counts).find((key) => {
+          _p_ObjectKeys(flags.counts).find((key) => {
             if (checkAllAliases(key, flags.arrays)) {
               error = Error(__("Invalid configuration: %s, opts.count excludes opts.array.", key));
               return true;
@@ -1004,12 +1004,12 @@ var init_yargs_parser = __esm({
         }
         __name(checkConfiguration, "checkConfiguration");
         return {
-          aliases: Object.assign({}, flags.aliases),
-          argv: Object.assign(argvReturn, argv),
+          aliases: _p_ObjectAssign({}, flags.aliases),
+          argv: _p_ObjectAssign(argvReturn, argv),
           configuration,
-          defaulted: Object.assign({}, defaulted),
+          defaulted: _p_ObjectAssign({}, defaulted),
           error,
-          newAliases: Object.assign({}, newAliases)
+          newAliases: _p_ObjectAssign({}, newAliases)
         };
       }
     };
@@ -1057,7 +1057,7 @@ var init_lib = __esm({
         if (typeof require2 !== "undefined") {
           return require2(path);
         } else if (path.match(/\.json$/)) {
-          return JSON.parse((0, import_fs.readFileSync)(path, "utf8"));
+          return _p_JSONParse((0, import_fs.readFileSync)(path, "utf8"));
         } else {
           throw Error("only .json config files are supported in ESM");
         }

package/dist/fs.js

@@ -73,6 +73,7 @@ var import_rewire = require("./paths/rewire");
 var import_socket = require("./paths/socket");
 var import_promises = require("./promises");
 var import_sorts = require("./sorts");
+var import_primordials = require("./primordials");
 const abortSignal = (0, import_process.getAbortSignal)();
 const NEWLINE_REGEX = /\n/g;
 const defaultRemoveOptions = (0, import_objects.objectFreeze)({
@@ -84,7 +85,6 @@ const defaultRemoveOptions = (0, import_objects.objectFreeze)({
 });
 let _del;
 let _cachedAllowedDirs;
-let _buffer;
 let _fs;
 let _path;
 function getAllowedDirectories() {
@@ -99,13 +99,6 @@ function getAllowedDirectories() {
   return _cachedAllowedDirs;
 }
 // @__NO_SIDE_EFFECTS__
-function getBuffer() {
-  if (_buffer === void 0) {
-    _buffer = require("node:buffer");
-  }
-  return _buffer;
-}
-// @__NO_SIDE_EFFECTS__
 function getDel() {
   if (_del === void 0) {
     _del = require("./external/del");
@@ -144,8 +137,8 @@ function innerReadDirNames(dirents, dirname, options) {
 // @__NO_SIDE_EFFECTS__
 function stringify(json, EOL, finalEOL, replacer, spaces = 2) {
   const EOF = finalEOL ? EOL : "";
-  const str = JSON.stringify(json, replacer, spaces);
-  return `${str.replace(NEWLINE_REGEX, EOL)}${EOF}`;
+  const str = (0, import_primordials.JSONStringify)(json, replacer, spaces);
+  return `${(0, import_primordials.StringPrototypeReplace)(str, NEWLINE_REGEX, EOL)}${EOF}`;
 }
 // @__NO_SIDE_EFFECTS__
 async function findUp(name, options) {
@@ -465,14 +458,14 @@ async function readJson(filepath, options) {
     if (shouldThrow) {
       const code = e.code;
       if (code === "ENOENT") {
-        throw new Error(
+        throw new import_primordials.ErrorCtor(
           `JSON file not found: ${filepath}
 Ensure the file exists or create it with the expected structure.`,
           { cause: e }
         );
       }
       if (code === "EACCES" || code === "EPERM") {
-        throw new Error(
+        throw new import_primordials.ErrorCtor(
           `Permission denied reading JSON file: ${filepath}
 Check file permissions or run with appropriate access.`,
           { cause: e }
@@ -508,14 +501,14 @@ function readJsonSync(filepath, options) {
     if (shouldThrow) {
       const code = e.code;
       if (code === "ENOENT") {
-        throw new Error(
+        throw new import_primordials.ErrorCtor(
           `JSON file not found: ${filepath}
 Ensure the file exists or create it with the expected structure.`,
           { cause: e }
         );
       }
       if (code === "EACCES" || code === "EPERM") {
-        throw new Error(
+        throw new import_primordials.ErrorCtor(
           `Permission denied reading JSON file: ${filepath}
 Check file permissions or run with appropriate access.`,
           { cause: e }
@@ -541,9 +534,9 @@ async function safeDelete(filepath, options) {
     const allInAllowedDirs = patterns.every((pattern) => {
       const resolvedPath = path.resolve(pattern);
       for (const allowedDir of allowedDirs) {
-        const isInAllowedDir = resolvedPath.startsWith(allowedDir + path.sep) || resolvedPath === allowedDir;
+        const isInAllowedDir = (0, import_primordials.StringPrototypeStartsWith)(resolvedPath, allowedDir + path.sep) || resolvedPath === allowedDir;
         const relativePath = path.relative(allowedDir, resolvedPath);
-        const isGoingBackward = relativePath.startsWith("..");
+        const isGoingBackward = (0, import_primordials.StringPrototypeStartsWith)(relativePath, "..");
         if (isInAllowedDir && !isGoingBackward) {
           return true;
         }
@@ -583,9 +576,9 @@ function safeDeleteSync(filepath, options) {
     const allInAllowedDirs = patterns.every((pattern) => {
       const resolvedPath = path.resolve(pattern);
       for (const allowedDir of allowedDirs) {
-        const isInAllowedDir = resolvedPath.startsWith(allowedDir + path.sep) || resolvedPath === allowedDir;
+        const isInAllowedDir = (0, import_primordials.StringPrototypeStartsWith)(resolvedPath, allowedDir + path.sep) || resolvedPath === allowedDir;
         const relativePath = path.relative(allowedDir, resolvedPath);
-        const isGoingBackward = relativePath.startsWith("..");
+        const isGoingBackward = (0, import_primordials.StringPrototypeStartsWith)(relativePath, "..");
         if (isInAllowedDir && !isGoingBackward) {
           return true;
         }
@@ -613,7 +606,12 @@ function safeDeleteSync(filepath, options) {
       lastError = e;
       if (attempt < maxRetries) {
         const waitMs = delay;
-        Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, waitMs);
+        (0, import_primordials.AtomicsWait)(
+          new import_primordials.Int32ArrayCtor(new import_primordials.SharedArrayBufferCtor(4)),
+          0,
+          0,
+          waitMs
+        );
         delay *= 2;
       }
     }
@@ -665,8 +663,7 @@ async function safeReadFile(filepath, options) {
     return void 0;
   }
   if (shouldReturnBuffer) {
-    const { Buffer: Buffer2 } = /* @__PURE__ */ getBuffer();
-    return Buffer2.isBuffer(defaultValue) ? defaultValue : void 0;
+    return (0, import_primordials.BufferIsBuffer)(defaultValue) ? defaultValue : void 0;
   }
   return typeof defaultValue === "string" ? defaultValue : String(defaultValue);
 }
@@ -690,8 +687,7 @@ function safeReadFileSync(filepath, options) {
     return void 0;
   }
   if (shouldReturnBuffer) {
-    const { Buffer: Buffer2 } = /* @__PURE__ */ getBuffer();
-    return Buffer2.isBuffer(defaultValue) ? defaultValue : void 0;
+    return (0, import_primordials.BufferIsBuffer)(defaultValue) ? defaultValue : void 0;
   }
   return typeof defaultValue === "string" ? defaultValue : String(defaultValue);
 }