npm-pkg-lint 4.0.1 → 4.0.3

package/dist/index.js

@@ -3229,33 +3229,31 @@ var require_tmp = __commonJS({
     }
     function tmpName(options, callback) {
       const args = _parseArguments(options, callback), opts = args[0], cb = args[1];
-      try {
-        _assertAndSanitizeOptions(opts);
-      } catch (err) {
-        return cb(err);
-      }
-      let tries = opts.tries;
-      (function _getUniqueName() {
-        try {
-          const name2 = _generateTmpName(opts);
-          fs16.stat(name2, function(err) {
-            if (!err) {
-              if (tries-- > 0) return _getUniqueName();
-              return cb(new Error("Could not get a unique tmp filename, max tries reached " + name2));
-            }
-            cb(null, name2);
-          });
-        } catch (err) {
-          cb(err);
-        }
-      })();
+      _assertAndSanitizeOptions(opts, function(err, sanitizedOptions) {
+        if (err) return cb(err);
+        let tries = sanitizedOptions.tries;
+        (function _getUniqueName() {
+          try {
+            const name2 = _generateTmpName(sanitizedOptions);
+            fs16.stat(name2, function(err2) {
+              if (!err2) {
+                if (tries-- > 0) return _getUniqueName();
+                return cb(new Error("Could not get a unique tmp filename, max tries reached " + name2));
+              }
+              cb(null, name2);
+            });
+          } catch (err2) {
+            cb(err2);
+          }
+        })();
+      });
     }
     function tmpNameSync(options) {
       const args = _parseArguments(options), opts = args[0];
-      _assertAndSanitizeOptions(opts);
-      let tries = opts.tries;
+      const sanitizedOptions = _assertAndSanitizeOptionsSync(opts);
+      let tries = sanitizedOptions.tries;
       do {
-        const name2 = _generateTmpName(opts);
+        const name2 = _generateTmpName(sanitizedOptions);
         try {
           fs16.statSync(name2);
         } catch (e) {
@@ -3285,7 +3283,7 @@ var require_tmp = __commonJS({
       const args = _parseArguments(options), opts = args[0];
       const discardOrDetachDescriptor = opts.discardDescriptor || opts.detachDescriptor;
       const name2 = tmpNameSync(opts);
-      var fd = fs16.openSync(name2, CREATE_FLAGS, opts.mode || FILE_MODE);
+      let fd = fs16.openSync(name2, CREATE_FLAGS, opts.mode || FILE_MODE);
       if (opts.discardDescriptor) {
         fs16.closeSync(fd);
         fd = void 0;
@@ -3392,14 +3390,11 @@ var require_tmp = __commonJS({
       } catch (e) {
         rnd = crypto2.pseudoRandomBytes(howMany);
       }
-      for (var i = 0; i < howMany; i++) {
+      for (let i = 0; i < howMany; i++) {
         value.push(RANDOM_CHARS[rnd[i] % RANDOM_CHARS.length]);
       }
       return value.join("");
     }
-    function _isBlank(s) {
-      return s === null || _isUndefined(s) || !s.trim();
-    }
     function _isUndefined(obj) {
       return typeof obj === "undefined";
     }
@@ -3416,12 +3411,37 @@ var require_tmp = __commonJS({
       }
       return [actualOptions, callback];
     }
+    function _resolvePath(name2, tmpDir, cb) {
+      const pathToResolve = path15.isAbsolute(name2) ? name2 : path15.join(tmpDir, name2);
+      fs16.stat(pathToResolve, function(err) {
+        if (err) {
+          fs16.realpath(path15.dirname(pathToResolve), function(err2, parentDir) {
+            if (err2) return cb(err2);
+            cb(null, path15.join(parentDir, path15.basename(pathToResolve)));
+          });
+        } else {
+          fs16.realpath(pathToResolve, cb);
+        }
+      });
+    }
+    function _resolvePathSync(name2, tmpDir) {
+      const pathToResolve = path15.isAbsolute(name2) ? name2 : path15.join(tmpDir, name2);
+      try {
+        fs16.statSync(pathToResolve);
+        return fs16.realpathSync(pathToResolve);
+      } catch (_err) {
+        const parentDir = fs16.realpathSync(path15.dirname(pathToResolve));
+        return path15.join(parentDir, path15.basename(pathToResolve));
+      }
+    }
     function _generateTmpName(opts) {
       const tmpDir = opts.tmpdir;
-      if (!_isUndefined(opts.name))
+      if (!_isUndefined(opts.name)) {
         return path15.join(tmpDir, opts.dir, opts.name);
-      if (!_isUndefined(opts.template))
+      }
+      if (!_isUndefined(opts.template)) {
         return path15.join(tmpDir, opts.dir, opts.template).replace(TEMPLATE_PATTERN, _randomChars(6));
+      }
       const name2 = [
         opts.prefix ? opts.prefix : "tmp",
         "-",
@@ -3432,54 +3452,75 @@ var require_tmp = __commonJS({
       ].join("");
       return path15.join(tmpDir, opts.dir, name2);
     }
-    function _assertAndSanitizeOptions(options) {
-      options.tmpdir = _getTmpDir(options);
-      const tmpDir = options.tmpdir;
-      if (!_isUndefined(options.name))
-        _assertIsRelative(options.name, "name", tmpDir);
-      if (!_isUndefined(options.dir))
-        _assertIsRelative(options.dir, "dir", tmpDir);
-      if (!_isUndefined(options.template)) {
-        _assertIsRelative(options.template, "template", tmpDir);
-        if (!options.template.match(TEMPLATE_PATTERN))
-          throw new Error(`Invalid template, found "${options.template}".`);
-      }
-      if (!_isUndefined(options.tries) && isNaN(options.tries) || options.tries < 0)
+    function _assertOptionsBase(options) {
+      if (!_isUndefined(options.name)) {
+        const name2 = options.name;
+        if (path15.isAbsolute(name2)) throw new Error(`name option must not contain an absolute path, found "${name2}".`);
+        const basename2 = path15.basename(name2);
+        if (basename2 === ".." || basename2 === "." || basename2 !== name2)
+          throw new Error(`name option must not contain a path, found "${name2}".`);
+      }
+      if (!_isUndefined(options.template) && !options.template.match(TEMPLATE_PATTERN)) {
+        throw new Error(`Invalid template, found "${options.template}".`);
+      }
+      if (!_isUndefined(options.tries) && isNaN(options.tries) || options.tries < 0) {
         throw new Error(`Invalid tries, found "${options.tries}".`);
+      }
       options.tries = _isUndefined(options.name) ? options.tries || DEFAULT_TRIES : 1;
       options.keep = !!options.keep;
       options.detachDescriptor = !!options.detachDescriptor;
       options.discardDescriptor = !!options.discardDescriptor;
       options.unsafeCleanup = !!options.unsafeCleanup;
-      options.dir = _isUndefined(options.dir) ? "" : path15.relative(tmpDir, _resolvePath(options.dir, tmpDir));
-      options.template = _isUndefined(options.template) ? void 0 : path15.relative(tmpDir, _resolvePath(options.template, tmpDir));
-      options.template = _isBlank(options.template) ? void 0 : path15.relative(options.dir, options.template);
-      options.name = _isUndefined(options.name) ? void 0 : options.name;
       options.prefix = _isUndefined(options.prefix) ? "" : options.prefix;
       options.postfix = _isUndefined(options.postfix) ? "" : options.postfix;
     }
-    function _resolvePath(name2, tmpDir) {
-      if (name2.startsWith(tmpDir)) {
-        return path15.resolve(name2);
-      } else {
-        return path15.resolve(path15.join(tmpDir, name2));
+    function _getRelativePath(option, name2, tmpDir, cb) {
+      if (_isUndefined(name2)) return cb(null);
+      _resolvePath(name2, tmpDir, function(err, resolvedPath) {
+        if (err) return cb(err);
+        const relativePath = path15.relative(tmpDir, resolvedPath);
+        if (!resolvedPath.startsWith(tmpDir)) {
+          return cb(new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`));
+        }
+        cb(null, relativePath);
+      });
+    }
+    function _getRelativePathSync(option, name2, tmpDir) {
+      if (_isUndefined(name2)) return;
+      const resolvedPath = _resolvePathSync(name2, tmpDir);
+      const relativePath = path15.relative(tmpDir, resolvedPath);
+      if (!resolvedPath.startsWith(tmpDir)) {
+        throw new Error(`${option} option must be relative to "${tmpDir}", found "${relativePath}".`);
       }
+      return relativePath;
     }
-    function _assertIsRelative(name2, option, tmpDir) {
-      if (option === "name") {
-        if (path15.isAbsolute(name2))
-          throw new Error(`${option} option must not contain an absolute path, found "${name2}".`);
-        let basename2 = path15.basename(name2);
-        if (basename2 === ".." || basename2 === "." || basename2 !== name2)
-          throw new Error(`${option} option must not contain a path, found "${name2}".`);
-      } else {
-        if (path15.isAbsolute(name2) && !name2.startsWith(tmpDir)) {
-          throw new Error(`${option} option must be relative to "${tmpDir}", found "${name2}".`);
+    function _assertAndSanitizeOptions(options, cb) {
+      _getTmpDir(options, function(err, tmpDir) {
+        if (err) return cb(err);
+        options.tmpdir = tmpDir;
+        try {
+          _assertOptionsBase(options, tmpDir);
+        } catch (err2) {
+          return cb(err2);
         }
-        let resolvedPath = _resolvePath(name2, tmpDir);
-        if (!resolvedPath.startsWith(tmpDir))
-          throw new Error(`${option} option must be relative to "${tmpDir}", found "${resolvedPath}".`);
-      }
+        _getRelativePath("dir", options.dir, tmpDir, function(err2, dir2) {
+          if (err2) return cb(err2);
+          options.dir = _isUndefined(dir2) ? "" : dir2;
+          _getRelativePath("template", options.template, tmpDir, function(err3, template) {
+            if (err3) return cb(err3);
+            options.template = template;
+            cb(null, options);
+          });
+        });
+      });
+    }
+    function _assertAndSanitizeOptionsSync(options) {
+      const tmpDir = options.tmpdir = _getTmpDirSync(options);
+      _assertOptionsBase(options, tmpDir);
+      const dir2 = _getRelativePathSync("dir", options.dir, tmpDir);
+      options.dir = _isUndefined(dir2) ? "" : dir2;
+      options.template = _getRelativePathSync("template", options.template, tmpDir);
+      return options;
     }
     function _isEBADF(error) {
       return _isExpectedError(error, -EBADF, "EBADF");
@@ -3493,15 +3534,18 @@ var require_tmp = __commonJS({
     function setGracefulCleanup() {
       _gracefulCleanup = true;
     }
-    function _getTmpDir(options) {
-      return path15.resolve(options && options.tmpdir || os2.tmpdir());
+    function _getTmpDir(options, cb) {
+      return fs16.realpath(options && options.tmpdir || os2.tmpdir(), cb);
+    }
+    function _getTmpDirSync(options) {
+      return fs16.realpathSync(options && options.tmpdir || os2.tmpdir());
     }
     process.addListener(EXIT, _garbageCollector);
     Object.defineProperty(module.exports, "tmpdir", {
       enumerable: true,
       configurable: false,
       get: function() {
-        return _getTmpDir();
+        return _getTmpDirSync();
       }
     });
     module.exports.dir = dir;
@@ -6473,6 +6517,30 @@ function normalizeIdentifier(identifier) {
     return String.fromCharCode(parseInt(unicodeEscape.slice(2), 16));
   });
 }
+function getEndLocation(text) {
+  let line = 1;
+  let column = 1;
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i];
+    if (char === "\n") {
+      line++;
+      column = 1;
+    } else if (char === "\r") {
+      if (text[i + 1] === "\n") {
+        i++;
+      }
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return {
+    line,
+    column,
+    offset: text.length
+  };
+}
 function getStringValue(value, token, json5 = false) {
   let result = "";
   let escapeIndex = value.indexOf("\\");
@@ -6838,6 +6906,7 @@ function parse(text, options) {
   if (unexpectedToken) {
     throw new UnexpectedToken(tokenizer.token);
   }
+  const textEndLocation = getEndLocation(text);
   const docParts = {
     loc: {
       start: {
@@ -6846,7 +6915,7 @@ function parse(text, options) {
         offset: 0
       },
       end: {
-        ...docBody.loc.end
+        ...textEndLocation
       }
     }
   };