@jsenv/github-release-package 1.2.0 → 1.3.0

package/dist/commonjs/main.cjs

@@ -1,1415 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-var url$1 = require('url');
-var fs = require('fs');
-var crypto = require('crypto');
-var path = require('path');
-var util = require('util');
-var module$1 = require('module');
-require('net');
-require('http');
-require('https');
-require('stream');
-
-const LOG_LEVEL_OFF = "off";
-const LOG_LEVEL_DEBUG = "debug";
-const LOG_LEVEL_INFO = "info";
-const LOG_LEVEL_WARN = "warn";
-const LOG_LEVEL_ERROR = "error";
-
-const createLogger = ({
-  logLevel = LOG_LEVEL_INFO
-} = {}) => {
-  if (logLevel === LOG_LEVEL_DEBUG) {
-    return {
-      debug,
-      info,
-      warn,
-      error
-    };
-  }
-
-  if (logLevel === LOG_LEVEL_INFO) {
-    return {
-      debug: debugDisabled,
-      info,
-      warn,
-      error
-    };
-  }
-
-  if (logLevel === LOG_LEVEL_WARN) {
-    return {
-      debug: debugDisabled,
-      info: infoDisabled,
-      warn,
-      error
-    };
-  }
-
-  if (logLevel === LOG_LEVEL_ERROR) {
-    return {
-      debug: debugDisabled,
-      info: infoDisabled,
-      warn: warnDisabled,
-      error
-    };
-  }
-
-  if (logLevel === LOG_LEVEL_OFF) {
-    return {
-      debug: debugDisabled,
-      info: infoDisabled,
-      warn: warnDisabled,
-      error: errorDisabled
-    };
-  }
-
-  throw new Error(`unexpected logLevel.
---- logLevel ---
-${logLevel}
---- allowed log levels ---
-${LOG_LEVEL_OFF}
-${LOG_LEVEL_ERROR}
-${LOG_LEVEL_WARN}
-${LOG_LEVEL_INFO}
-${LOG_LEVEL_DEBUG}`);
-};
-const debug = console.debug;
-
-const debugDisabled = () => {};
-
-const info = console.info;
-
-const infoDisabled = () => {};
-
-const warn = console.warn;
-
-const warnDisabled = () => {};
-
-const error = console.error;
-
-const errorDisabled = () => {};
-
-const ensureUrlTrailingSlash = url => {
-  return url.endsWith("/") ? url : `${url}/`;
-};
-
-const isFileSystemPath = value => {
-  if (typeof value !== "string") {
-    throw new TypeError(`isFileSystemPath first arg must be a string, got ${value}`);
-  }
-
-  if (value[0] === "/") return true;
-  return startsWithWindowsDriveLetter(value);
-};
-
-const startsWithWindowsDriveLetter = string => {
-  const firstChar = string[0];
-  if (!/[a-zA-Z]/.test(firstChar)) return false;
-  const secondChar = string[1];
-  if (secondChar !== ":") return false;
-  return true;
-};
-
-const fileSystemPathToUrl = value => {
-  if (!isFileSystemPath(value)) {
-    throw new Error(`received an invalid value for fileSystemPath: ${value}`);
-  }
-
-  return String(url$1.pathToFileURL(value));
-};
-
-const assertAndNormalizeDirectoryUrl = value => {
-  let urlString;
-
-  if (value instanceof URL) {
-    urlString = value.href;
-  } else if (typeof value === "string") {
-    if (isFileSystemPath(value)) {
-      urlString = fileSystemPathToUrl(value);
-    } else {
-      try {
-        urlString = String(new URL(value));
-      } catch (e) {
-        throw new TypeError(`directoryUrl must be a valid url, received ${value}`);
-      }
-    }
-  } else {
-    throw new TypeError(`directoryUrl must be a string or an url, received ${value}`);
-  }
-
-  if (!urlString.startsWith("file://")) {
-    throw new Error(`directoryUrl must starts with file://, received ${value}`);
-  }
-
-  return ensureUrlTrailingSlash(urlString);
-};
-
-const assertAndNormalizeFileUrl = (value, baseUrl) => {
-  let urlString;
-
-  if (value instanceof URL) {
-    urlString = value.href;
-  } else if (typeof value === "string") {
-    if (isFileSystemPath(value)) {
-      urlString = fileSystemPathToUrl(value);
-    } else {
-      try {
-        urlString = String(new URL(value, baseUrl));
-      } catch (e) {
-        throw new TypeError(`fileUrl must be a valid url, received ${value}`);
-      }
-    }
-  } else {
-    throw new TypeError(`fileUrl must be a string or an url, received ${value}`);
-  }
-
-  if (!urlString.startsWith("file://")) {
-    throw new Error(`fileUrl must starts with file://, received ${value}`);
-  }
-
-  return urlString;
-};
-
-const urlToFileSystemPath = fileUrl => {
-  if (fileUrl[fileUrl.length - 1] === "/") {
-    // remove trailing / so that nodejs path becomes predictable otherwise it logs
-    // the trailing slash on linux but does not on windows
-    fileUrl = fileUrl.slice(0, -1);
-  }
-
-  const fileSystemPath = url$1.fileURLToPath(fileUrl);
-  return fileSystemPath;
-};
-
-const isWindows = process.platform === "win32";
-
-const createCancelError = reason => {
-  const cancelError = new Error(`canceled because ${reason}`);
-  cancelError.name = "CANCEL_ERROR";
-  cancelError.reason = reason;
-  return cancelError;
-};
-const isCancelError = value => {
-  return value && typeof value === "object" && value.name === "CANCEL_ERROR";
-};
-
-const arrayWithout = (array, item) => {
-  const arrayWithoutItem = [];
-  let i = 0;
-
-  while (i < array.length) {
-    const value = array[i];
-    i++;
-
-    if (value === item) {
-      continue;
-    }
-
-    arrayWithoutItem.push(value);
-  }
-
-  return arrayWithoutItem;
-};
-
-// https://github.com/tc39/proposal-cancellation/tree/master/stage0
-const createCancellationSource = () => {
-  let requested = false;
-  let cancelError;
-  let registrationArray = [];
-
-  const cancel = reason => {
-    if (requested) return;
-    requested = true;
-    cancelError = createCancelError(reason);
-    const registrationArrayCopy = registrationArray.slice();
-    registrationArray.length = 0;
-    registrationArrayCopy.forEach(registration => {
-      registration.callback(cancelError); // const removedDuringCall = registrationArray.indexOf(registration) === -1
-    });
-  };
-
-  const register = callback => {
-    if (typeof callback !== "function") {
-      throw new Error(`callback must be a function, got ${callback}`);
-    }
-
-    const existingRegistration = registrationArray.find(registration => {
-      return registration.callback === callback;
-    }); // don't register twice
-
-    if (existingRegistration) {
-      return existingRegistration;
-    }
-
-    const registration = {
-      callback,
-      unregister: () => {
-        registrationArray = arrayWithout(registrationArray, registration);
-      }
-    };
-    registrationArray = [registration, ...registrationArray];
-    return registration;
-  };
-
-  const throwIfRequested = () => {
-    if (requested) {
-      throw cancelError;
-    }
-  };
-
-  return {
-    token: {
-      register,
-
-      get cancellationRequested() {
-        return requested;
-      },
-
-      throwIfRequested
-    },
-    cancel
-  };
-};
-
-const createCancellationTokenForProcessSIGINT = () => {
-  const SIGINTCancelSource = createCancellationSource();
-  process.on("SIGINT", () => SIGINTCancelSource.cancel("process interruption"));
-  return SIGINTCancelSource.token;
-};
-
-const resolveUrl = (specifier, baseUrl) => {
-  if (typeof baseUrl === "undefined") {
-    throw new TypeError(`baseUrl missing to resolve ${specifier}`);
-  }
-
-  return String(new URL(specifier, baseUrl));
-};
-
-const isWindows$1 = process.platform === "win32";
-const baseUrlFallback = fileSystemPathToUrl(process.cwd());
-
-const isWindows$2 = process.platform === "win32";
-
-const readFilePromisified = util.promisify(fs.readFile);
-const readFile = async value => {
-  const fileUrl = assertAndNormalizeFileUrl(value);
-  const filePath = urlToFileSystemPath(fileUrl);
-  const buffer = await readFilePromisified(filePath);
-  return buffer.toString();
-};
-
-const isWindows$3 = process.platform === "win32";
-
-/* eslint-disable import/max-dependencies */
-const isLinux = process.platform === "linux"; // linux does not support recursive option
-
-const wrapAsyncFunction = (asyncFunction, {
-  updateProcessExitCode = true
-} = {}) => {
-  return asyncFunction().catch(error => {
-    if (isCancelError(error)) {
-      // it means consume of the function will resolve with a cancelError
-      // but when you cancel it means you're not interested in the result anymore
-      // thanks to this it avoid unhandledRejection
-      return error;
-    } // this is required to ensure unhandledRejection will still
-    // set process.exitCode to 1 marking the process execution as errored
-    // preventing further command to run
-
-
-    if (updateProcessExitCode) {
-      process.exitCode = 1;
-    }
-
-    throw error;
-  });
-};
-
-const readProjectPackage = async ({
-  projectDirectoryUrl
-}) => {
-  const packageFileUrl = resolveUrl("./package.json", projectDirectoryUrl);
-  let packageInProject;
-
-  try {
-    const packageString = await readFile(packageFileUrl);
-
-    try {
-      packageInProject = JSON.parse(packageString);
-    } catch (e) {
-      if (e.name === "SyntaxError") {
-        throw new Error(`syntax error while parsing project package.json
---- syntax error stack ---
-${e.stack}
---- package.json path ---
-${urlToFileSystemPath(packageFileUrl)}`);
-      }
-
-      throw e;
-    }
-  } catch (e) {
-    if (e.code === "ENOENT") {
-      throw new Error(`cannot find project package.json
---- package.json path ---
-${urlToFileSystemPath(packageFileUrl)}`);
-    }
-
-    throw e;
-  }
-
-  return packageInProject;
-};
-
-const convertFileSystemErrorToResponseProperties = error => {
-  // https://iojs.org/api/errors.html#errors_eacces_permission_denied
-  if (isErrorWithCode(error, "EACCES")) {
-    return {
-      status: 403,
-      statusText: "no permission to read file"
-    };
-  }
-
-  if (isErrorWithCode(error, "EPERM")) {
-    return {
-      status: 403,
-      statusText: "no permission to read file"
-    };
-  }
-
-  if (isErrorWithCode(error, "ENOENT")) {
-    return {
-      status: 404,
-      statusText: "file not found"
-    };
-  } // file access may be temporarily blocked
-  // (by an antivirus scanning it because recently modified for instance)
-
-
-  if (isErrorWithCode(error, "EBUSY")) {
-    return {
-      status: 503,
-      statusText: "file is busy",
-      headers: {
-        "retry-after": 0.01 // retry in 10ms
-
-      }
-    };
-  } // emfile means there is too many files currently opened
-
-
-  if (isErrorWithCode(error, "EMFILE")) {
-    return {
-      status: 503,
-      statusText: "too many file opened",
-      headers: {
-        "retry-after": 0.1 // retry in 100ms
-
-      }
-    };
-  }
-
-  if (isErrorWithCode(error, "EISDIR")) {
-    return {
-      status: 500,
-      statusText: "Unexpected directory operation"
-    };
-  }
-
-  return Promise.reject(error);
-};
-
-const isErrorWithCode = (error, code) => {
-  return typeof error === "object" && error.code === code;
-};
-
-if ("observable" in Symbol === false) {
-  Symbol.observable = Symbol.for("observable");
-}
-
-/* global require, __filename */
-const nodeRequire = require;
-const filenameContainsBackSlashes = __filename.indexOf("\\") > -1;
-const url = filenameContainsBackSlashes ? `file:///${__filename.replace(/\\/g, "/")}` : `file://${__filename}`;
-
-const createCancellationToken = () => {
-  const register = callback => {
-    if (typeof callback !== "function") {
-      throw new Error(`callback must be a function, got ${callback}`);
-    }
-
-    return {
-      callback,
-      unregister: () => {}
-    };
-  };
-
-  const throwIfRequested = () => undefined;
-
-  return {
-    register,
-    cancellationRequested: false,
-    throwIfRequested
-  };
-};
-
-const createOperation = ({
-  cancellationToken = createCancellationToken(),
-  start,
-  ...rest
-}) => {
-  const unknownArgumentNames = Object.keys(rest);
-
-  if (unknownArgumentNames.length) {
-    throw new Error(`createOperation called with unknown argument names.
---- unknown argument names ---
-${unknownArgumentNames}
---- possible argument names ---
-cancellationToken
-start`);
-  }
-
-  cancellationToken.throwIfRequested();
-  const promise = new Promise(resolve => {
-    resolve(start());
-  });
-  const cancelPromise = new Promise((resolve, reject) => {
-    const cancelRegistration = cancellationToken.register(cancelError => {
-      cancelRegistration.unregister();
-      reject(cancelError);
-    });
-    promise.then(cancelRegistration.unregister, () => {});
-  });
-  const operationPromise = Promise.race([promise, cancelPromise]);
-  return operationPromise;
-};
-
-const ensureUrlTrailingSlash$1 = url => {
-  return url.endsWith("/") ? url : `${url}/`;
-};
-
-const isFileSystemPath$1 = value => {
-  if (typeof value !== "string") {
-    throw new TypeError(`isFileSystemPath first arg must be a string, got ${value}`);
-  }
-
-  if (value[0] === "/") return true;
-  return startsWithWindowsDriveLetter$1(value);
-};
-
-const startsWithWindowsDriveLetter$1 = string => {
-  const firstChar = string[0];
-  if (!/[a-zA-Z]/.test(firstChar)) return false;
-  const secondChar = string[1];
-  if (secondChar !== ":") return false;
-  return true;
-};
-
-const fileSystemPathToUrl$1 = value => {
-  if (!isFileSystemPath$1(value)) {
-    throw new Error(`received an invalid value for fileSystemPath: ${value}`);
-  }
-
-  return String(url$1.pathToFileURL(value));
-};
-
-const assertAndNormalizeDirectoryUrl$1 = value => {
-  let urlString;
-
-  if (value instanceof URL) {
-    urlString = value.href;
-  } else if (typeof value === "string") {
-    if (isFileSystemPath$1(value)) {
-      urlString = fileSystemPathToUrl$1(value);
-    } else {
-      try {
-        urlString = String(new URL(value));
-      } catch (e) {
-        throw new TypeError(`directoryUrl must be a valid url, received ${value}`);
-      }
-    }
-  } else {
-    throw new TypeError(`directoryUrl must be a string or an url, received ${value}`);
-  }
-
-  if (!urlString.startsWith("file://")) {
-    throw new Error(`directoryUrl must starts with file://, received ${value}`);
-  }
-
-  return ensureUrlTrailingSlash$1(urlString);
-};
-
-const assertAndNormalizeFileUrl$1 = (value, baseUrl) => {
-  let urlString;
-
-  if (value instanceof URL) {
-    urlString = value.href;
-  } else if (typeof value === "string") {
-    if (isFileSystemPath$1(value)) {
-      urlString = fileSystemPathToUrl$1(value);
-    } else {
-      try {
-        urlString = String(new URL(value, baseUrl));
-      } catch (e) {
-        throw new TypeError(`fileUrl must be a valid url, received ${value}`);
-      }
-    }
-  } else {
-    throw new TypeError(`fileUrl must be a string or an url, received ${value}`);
-  }
-
-  if (!urlString.startsWith("file://")) {
-    throw new Error(`fileUrl must starts with file://, received ${value}`);
-  }
-
-  return urlString;
-};
-
-const urlToFileSystemPath$1 = fileUrl => {
-  if (fileUrl[fileUrl.length - 1] === "/") {
-    // remove trailing / so that nodejs path becomes predictable otherwise it logs
-    // the trailing slash on linux but does not on windows
-    fileUrl = fileUrl.slice(0, -1);
-  }
-
-  const fileSystemPath = url$1.fileURLToPath(fileUrl);
-  return fileSystemPath;
-};
-
-// https://github.com/coderaiser/cloudcmd/issues/63#issuecomment-195478143
-// https://nodejs.org/api/fs.html#fs_file_modes
-// https://github.com/TooTallNate/stat-mode
-// cannot get from fs.constants because they are not available on windows
-const S_IRUSR = 256;
-/* 0000400 read permission, owner */
-
-const S_IWUSR = 128;
-/* 0000200 write permission, owner */
-
-const S_IXUSR = 64;
-/* 0000100 execute/search permission, owner */
-
-const S_IRGRP = 32;
-/* 0000040 read permission, group */
-
-const S_IWGRP = 16;
-/* 0000020 write permission, group */
-
-const S_IXGRP = 8;
-/* 0000010 execute/search permission, group */
-
-const S_IROTH = 4;
-/* 0000004 read permission, others */
-
-const S_IWOTH = 2;
-/* 0000002 write permission, others */
-
-const S_IXOTH = 1;
-const permissionsToBinaryFlags = ({
-  owner,
-  group,
-  others
-}) => {
-  let binaryFlags = 0;
-  if (owner.read) binaryFlags |= S_IRUSR;
-  if (owner.write) binaryFlags |= S_IWUSR;
-  if (owner.execute) binaryFlags |= S_IXUSR;
-  if (group.read) binaryFlags |= S_IRGRP;
-  if (group.write) binaryFlags |= S_IWGRP;
-  if (group.execute) binaryFlags |= S_IXGRP;
-  if (others.read) binaryFlags |= S_IROTH;
-  if (others.write) binaryFlags |= S_IWOTH;
-  if (others.execute) binaryFlags |= S_IXOTH;
-  return binaryFlags;
-};
-
-const writeFileSystemNodePermissions = async (source, permissions) => {
-  const sourceUrl = assertAndNormalizeFileUrl$1(source);
-  const sourcePath = urlToFileSystemPath$1(sourceUrl);
-  let binaryFlags;
-
-  if (typeof permissions === "object") {
-    permissions = {
-      owner: {
-        read: getPermissionOrComputeDefault("read", "owner", permissions),
-        write: getPermissionOrComputeDefault("write", "owner", permissions),
-        execute: getPermissionOrComputeDefault("execute", "owner", permissions)
-      },
-      group: {
-        read: getPermissionOrComputeDefault("read", "group", permissions),
-        write: getPermissionOrComputeDefault("write", "group", permissions),
-        execute: getPermissionOrComputeDefault("execute", "group", permissions)
-      },
-      others: {
-        read: getPermissionOrComputeDefault("read", "others", permissions),
-        write: getPermissionOrComputeDefault("write", "others", permissions),
-        execute: getPermissionOrComputeDefault("execute", "others", permissions)
-      }
-    };
-    binaryFlags = permissionsToBinaryFlags(permissions);
-  } else {
-    binaryFlags = permissions;
-  }
-
-  return chmodNaive(sourcePath, binaryFlags);
-};
-
-const chmodNaive = (fileSystemPath, binaryFlags) => {
-  return new Promise((resolve, reject) => {
-    fs.chmod(fileSystemPath, binaryFlags, error => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve();
-      }
-    });
-  });
-};
-
-const actionLevels = {
-  read: 0,
-  write: 1,
-  execute: 2
-};
-const subjectLevels = {
-  others: 0,
-  group: 1,
-  owner: 2
-};
-
-const getPermissionOrComputeDefault = (action, subject, permissions) => {
-  if (subject in permissions) {
-    const subjectPermissions = permissions[subject];
-
-    if (action in subjectPermissions) {
-      return subjectPermissions[action];
-    }
-
-    const actionLevel = actionLevels[action];
-    const actionFallback = Object.keys(actionLevels).find(actionFallbackCandidate => actionLevels[actionFallbackCandidate] > actionLevel && actionFallbackCandidate in subjectPermissions);
-
-    if (actionFallback) {
-      return subjectPermissions[actionFallback];
-    }
-  }
-
-  const subjectLevel = subjectLevels[subject]; // do we have a subject with a stronger level (group or owner)
-  // where we could read the action permission ?
-
-  const subjectFallback = Object.keys(subjectLevels).find(subjectFallbackCandidate => subjectLevels[subjectFallbackCandidate] > subjectLevel && subjectFallbackCandidate in permissions);
-
-  if (subjectFallback) {
-    const subjectPermissions = permissions[subjectFallback];
-    return action in subjectPermissions ? subjectPermissions[action] : getPermissionOrComputeDefault(action, subjectFallback, permissions);
-  }
-
-  return false;
-};
-
-const isWindows$4 = process.platform === "win32";
-const readFileSystemNodeStat = async (source, {
-  nullIfNotFound = false,
-  followLink = true
-} = {}) => {
-  if (source.endsWith("/")) source = source.slice(0, -1);
-  const sourceUrl = assertAndNormalizeFileUrl$1(source);
-  const sourcePath = urlToFileSystemPath$1(sourceUrl);
-  const handleNotFoundOption = nullIfNotFound ? {
-    handleNotFoundError: () => null
-  } : {};
-  return readStat(sourcePath, {
-    followLink,
-    ...handleNotFoundOption,
-    ...(isWindows$4 ? {
-      // Windows can EPERM on stat
-      handlePermissionDeniedError: async error => {
-        // unfortunately it means we mutate the permissions
-        // without being able to restore them to the previous value
-        // (because reading current permission would also throw)
-        try {
-          await writeFileSystemNodePermissions(sourceUrl, 0o666);
-          const stats = await readStat(sourcePath, {
-            followLink,
-            ...handleNotFoundOption,
-            // could not fix the permission error, give up and throw original error
-            handlePermissionDeniedError: () => {
-              throw error;
-            }
-          });
-          return stats;
-        } catch (e) {
-          // failed to write permission or readState, throw original error as well
-          throw error;
-        }
-      }
-    } : {})
-  });
-};
-
-const readStat = (sourcePath, {
-  followLink,
-  handleNotFoundError = null,
-  handlePermissionDeniedError = null
-} = {}) => {
-  const nodeMethod = followLink ? fs.stat : fs.lstat;
-  return new Promise((resolve, reject) => {
-    nodeMethod(sourcePath, (error, statsObject) => {
-      if (error) {
-        if (handlePermissionDeniedError && (error.code === "EPERM" || error.code === "EACCES")) {
-          resolve(handlePermissionDeniedError(error));
-        } else if (handleNotFoundError && error.code === "ENOENT") {
-          resolve(handleNotFoundError(error));
-        } else {
-          reject(error);
-        }
-      } else {
-        resolve(statsObject);
-      }
-    });
-  });
-};
-
-const ETAG_FOR_EMPTY_CONTENT = '"0-2jmj7l5rSw0yVb/vlWAYkK/YBwk"';
-const bufferToEtag = buffer => {
-  if (!Buffer.isBuffer(buffer)) {
-    throw new TypeError(`buffer expected, got ${buffer}`);
-  }
-
-  if (buffer.length === 0) {
-    return ETAG_FOR_EMPTY_CONTENT;
-  }
-
-  const hash = crypto.createHash("sha1");
-  hash.update(buffer, "utf8");
-  const hashBase64String = hash.digest("base64");
-  const hashBase64StringSubset = hashBase64String.slice(0, 27);
-  const length = buffer.length;
-  return `"${length.toString(16)}-${hashBase64StringSubset}"`;
-};
-
-const readDirectory = async (url, {
-  emfileMaxWait = 1000
-} = {}) => {
-  const directoryUrl = assertAndNormalizeDirectoryUrl$1(url);
-  const directoryPath = urlToFileSystemPath$1(directoryUrl);
-  const startMs = Date.now();
-  let attemptCount = 0;
-
-  const attempt = () => {
-    return readdirNaive(directoryPath, {
-      handleTooManyFilesOpenedError: async error => {
-        attemptCount++;
-        const nowMs = Date.now();
-        const timeSpentWaiting = nowMs - startMs;
-
-        if (timeSpentWaiting > emfileMaxWait) {
-          throw error;
-        }
-
-        return new Promise(resolve => {
-          setTimeout(() => {
-            resolve(attempt());
-          }, attemptCount);
-        });
-      }
-    });
-  };
-
-  return attempt();
-};
-
-const readdirNaive = (directoryPath, {
-  handleTooManyFilesOpenedError = null
-} = {}) => {
-  return new Promise((resolve, reject) => {
-    fs.readdir(directoryPath, (error, names) => {
-      if (error) {
-        // https://nodejs.org/dist/latest-v13.x/docs/api/errors.html#errors_common_system_errors
-        if (handleTooManyFilesOpenedError && (error.code === "EMFILE" || error.code === "ENFILE")) {
-          resolve(handleTooManyFilesOpenedError(error));
-        } else {
-          reject(error);
-        }
-      } else {
-        resolve(names);
-      }
-    });
-  });
-};
-
-const isWindows$5 = process.platform === "win32";
-const baseUrlFallback$1 = fileSystemPathToUrl$1(process.cwd());
-
-const isWindows$6 = process.platform === "win32";
-
-const readFilePromisified$1 = util.promisify(fs.readFile);
-
-const isWindows$7 = process.platform === "win32";
-
-/* eslint-disable import/max-dependencies */
-const isLinux$1 = process.platform === "linux"; // linux does not support recursive option
-
-const jsenvContentTypeMap = {
-  "application/javascript": {
-    extensions: ["js", "cjs", "mjs", "ts", "jsx"]
-  },
-  "application/json": {
-    extensions: ["json"]
-  },
-  "application/octet-stream": {},
-  "application/pdf": {
-    extensions: ["pdf"]
-  },
-  "application/xml": {
-    extensions: ["xml"]
-  },
-  "application/x-gzip": {
-    extensions: ["gz"]
-  },
-  "application/wasm": {
-    extensions: ["wasm"]
-  },
-  "application/zip": {
-    extensions: ["zip"]
-  },
-  "audio/basic": {
-    extensions: ["au", "snd"]
-  },
-  "audio/mpeg": {
-    extensions: ["mpga", "mp2", "mp2a", "mp3", "m2a", "m3a"]
-  },
-  "audio/midi": {
-    extensions: ["midi", "mid", "kar", "rmi"]
-  },
-  "audio/mp4": {
-    extensions: ["m4a", "mp4a"]
-  },
-  "audio/ogg": {
-    extensions: ["oga", "ogg", "spx"]
-  },
-  "audio/webm": {
-    extensions: ["weba"]
-  },
-  "audio/x-wav": {
-    extensions: ["wav"]
-  },
-  "font/ttf": {
-    extensions: ["ttf"]
-  },
-  "font/woff": {
-    extensions: ["woff"]
-  },
-  "font/woff2": {
-    extensions: ["woff2"]
-  },
-  "image/png": {
-    extensions: ["png"]
-  },
-  "image/gif": {
-    extensions: ["gif"]
-  },
-  "image/jpeg": {
-    extensions: ["jpg"]
-  },
-  "image/svg+xml": {
-    extensions: ["svg", "svgz"]
-  },
-  "text/plain": {
-    extensions: ["txt"]
-  },
-  "text/html": {
-    extensions: ["html"]
-  },
-  "text/css": {
-    extensions: ["css"]
-  },
-  "text/cache-manifest": {
-    extensions: ["appcache"]
-  },
-  "video/mp4": {
-    extensions: ["mp4", "mp4v", "mpg4"]
-  },
-  "video/mpeg": {
-    extensions: ["mpeg", "mpg", "mpe", "m1v", "m2v"]
-  },
-  "video/ogg": {
-    extensions: ["ogv"]
-  },
-  "video/webm": {
-    extensions: ["webm"]
-  }
-};
-
-// https://github.com/jshttp/mime-db/blob/master/src/apache-types.json
-const urlToContentType = (url, contentTypeMap = jsenvContentTypeMap, contentTypeDefault = "application/octet-stream") => {
-  if (typeof contentTypeMap !== "object") {
-    throw new TypeError(`contentTypeMap must be an object, got ${contentTypeMap}`);
-  }
-
-  const pathname = new URL(url).pathname;
-  const extensionWithDot = path.extname(pathname);
-
-  if (!extensionWithDot || extensionWithDot === ".") {
-    return contentTypeDefault;
-  }
-
-  const extension = extensionWithDot.slice(1);
-  const availableContentTypes = Object.keys(contentTypeMap);
-  const contentTypeForExtension = availableContentTypes.find(contentTypeName => {
-    const contentType = contentTypeMap[contentTypeName];
-    return contentType.extensions && contentType.extensions.indexOf(extension) > -1;
-  });
-  return contentTypeForExtension || contentTypeDefault;
-};
-
-const {
-  readFile: readFile$1
-} = fs.promises;
-const serveFile = async (source, {
-  cancellationToken = createCancellationToken(),
-  method = "GET",
-  headers = {},
-  canReadDirectory = false,
-  cacheStrategy = "etag",
-  contentTypeMap = jsenvContentTypeMap
-} = {}) => {
-  if (method !== "GET" && method !== "HEAD") {
-    return {
-      status: 501
-    };
-  }
-
-  const sourceUrl = assertAndNormalizeFileUrl$1(source);
-  const clientCacheDisabled = headers["cache-control"] === "no-cache";
-
-  try {
-    const cacheWithMtime = !clientCacheDisabled && cacheStrategy === "mtime";
-    const cacheWithETag = !clientCacheDisabled && cacheStrategy === "etag";
-    const cachedDisabled = clientCacheDisabled || cacheStrategy === "none";
-    const sourceStat = await createOperation({
-      cancellationToken,
-      start: () => readFileSystemNodeStat(sourceUrl)
-    });
-
-    if (sourceStat.isDirectory()) {
-      if (canReadDirectory === false) {
-        return {
-          status: 403,
-          statusText: "not allowed to read directory",
-          headers: { ...(cachedDisabled ? {
-              "cache-control": "no-store"
-            } : {})
-          }
-        };
-      }
-
-      const directoryContentArray = await createOperation({
-        cancellationToken,
-        start: () => readDirectory(sourceUrl)
-      });
-      const directoryContentJson = JSON.stringify(directoryContentArray);
-      return {
-        status: 200,
-        headers: { ...(cachedDisabled ? {
-            "cache-control": "no-store"
-          } : {}),
-          "content-type": "application/json",
-          "content-length": directoryContentJson.length
-        },
-        body: directoryContentJson
-      };
-    } // not a file, give up
-
-
-    if (!sourceStat.isFile()) {
-      return {
-        status: 404,
-        headers: { ...(cachedDisabled ? {
-            "cache-control": "no-store"
-          } : {})
-        }
-      };
-    }
-
-    if (cacheWithETag) {
-      const fileContentAsBuffer = await createOperation({
-        cancellationToken,
-        start: () => readFile$1(urlToFileSystemPath$1(sourceUrl))
-      });
-      const fileContentEtag = bufferToEtag(fileContentAsBuffer);
-
-      if ("if-none-match" in headers && headers["if-none-match"] === fileContentEtag) {
-        return {
-          status: 304,
-          headers: { ...(cachedDisabled ? {
-              "cache-control": "no-store"
-            } : {})
-          }
-        };
-      }
-
-      return {
-        status: 200,
-        headers: { ...(cachedDisabled ? {
-            "cache-control": "no-store"
-          } : {}),
-          "content-length": sourceStat.size,
-          "content-type": urlToContentType(sourceUrl, contentTypeMap),
-          "etag": fileContentEtag
-        },
-        body: fileContentAsBuffer
-      };
-    }
-
-    if (cacheWithMtime && "if-modified-since" in headers) {
-      let cachedModificationDate;
-
-      try {
-        cachedModificationDate = new Date(headers["if-modified-since"]);
-      } catch (e) {
-        return {
-          status: 400,
-          statusText: "if-modified-since header is not a valid date"
-        };
-      }
-
-      const actualModificationDate = dateToSecondsPrecision(sourceStat.mtime);
-
-      if (Number(cachedModificationDate) >= Number(actualModificationDate)) {
-        return {
-          status: 304
-        };
-      }
-    }
-
-    return {
-      status: 200,
-      headers: { ...(cachedDisabled ? {
-          "cache-control": "no-store"
-        } : {}),
-        ...(cacheWithMtime ? {
-          "last-modified": dateToUTCString(sourceStat.mtime)
-        } : {}),
-        "content-length": sourceStat.size,
-        "content-type": urlToContentType(sourceUrl, contentTypeMap)
-      },
-      body: fs.createReadStream(urlToFileSystemPath$1(sourceUrl))
-    };
-  } catch (e) {
-    return convertFileSystemErrorToResponseProperties(e);
-  }
-}; // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toUTCString
-
-const dateToUTCString = date => date.toUTCString();
-
-const dateToSecondsPrecision = date => {
-  const dateWithSecondsPrecision = new Date(date);
-  dateWithSecondsPrecision.setMilliseconds(0);
-  return dateWithSecondsPrecision;
-};
-
-const require$1 = module$1.createRequire(url);
-
-const nodeFetch = require$1("node-fetch");
-
-const AbortController = require$1("abort-controller");
-
-const {
-  Response
-} = nodeFetch;
-const fetchUrl = async (url, {
-  cancellationToken = createCancellationToken(),
-  simplified = false,
-  canReadDirectory,
-  contentTypeMap,
-  cacheStrategy,
-  ...options
-} = {}) => {
-  try {
-    url = String(new URL(url));
-  } catch (e) {
-    throw new Error(`fetchUrl first argument must be an absolute url, received ${url}`);
-  }
-
-  if (url.startsWith("file://")) {
-    const {
-      status,
-      statusText,
-      headers,
-      body
-    } = await serveFile(url, {
-      cancellationToken,
-      cacheStrategy,
-      canReadDirectory,
-      contentTypeMap,
-      ...options
-    });
-    const response = new Response(typeof body === "string" ? Buffer.from(body) : body, {
-      url,
-      status,
-      statusText,
-      headers
-    });
-    return simplified ? standardResponseToSimplifiedResponse(response) : response;
-  }
-
-  const response = await createOperation({
-    cancellationToken,
-    start: () => nodeFetch(url, {
-      signal: cancellationTokenToAbortSignal(cancellationToken),
-      ...options
-    })
-  });
-  return simplified ? standardResponseToSimplifiedResponse(response) : response;
-}; // https://github.com/bitinn/node-fetch#request-cancellation-with-abortsignal
-
-const cancellationTokenToAbortSignal = cancellationToken => {
-  const abortController = new AbortController();
-  cancellationToken.register(reason => {
-    abortController.abort(reason);
-  });
-  return abortController.signal;
-};
-
-const standardResponseToSimplifiedResponse = async response => {
-  const text = await response.text();
-  return {
-    url: response.url,
-    status: response.status,
-    statusText: response.statusText,
-    headers: responseToHeaders(response),
-    body: text
-  };
-};
-
-const responseToHeaders = response => {
-  const headers = {};
-  response.headers.forEach((value, name) => {
-    headers[name] = value;
-  });
-  return headers;
-};
-
-const require$2 = module$1.createRequire(url);
-
-const killPort = require$2("kill-port");
-
-// https://developer.github.com/v3/git/refs/#get-a-single-reference
-const getGithubRelease = async ({
-  githubToken,
-  githubRepositoryOwner,
-  githubRepositoryName,
-  githubReleaseName
-}) => {
-  const requestUrl = `https://api.github.com/repos/${githubRepositoryOwner}/${githubRepositoryName}/git/ref/tags/${githubReleaseName}`;
-  const response = await fetchUrl(requestUrl, {
-    headers: {
-      authorization: `token ${githubToken}`
-    },
-    method: "GET"
-  });
-  const responseStatus = response.status;
-
-  if (responseStatus === 404) {
-    return null;
-  }
-
-  if (responseStatus !== 200) {
-    throw new Error(writeUnexpectedResponseStatus({
-      requestUrl,
-      responseStatus,
-      responseText: await response.text()
-    }));
-  }
-
-  const responseJson = await response.json();
-  return responseJson;
-};
-
-const writeUnexpectedResponseStatus = ({
-  requestUrl,
-  responseStatus,
-  responseText
-}) => `github api response status should be 200.
---- request url ----
-${requestUrl}
---- response status ---
-${responseStatus}
---- response text ---
-${responseText}`;
-
-// https://developer.github.com/v3/git/tags/
-const createGithubRelease = async ({
-  githubToken,
-  githubRepositoryOwner,
-  githubRepositoryName,
-  githubSha,
-  githubReleaseName
-}) => {
-  const requestUrl = `https://api.github.com/repos/${githubRepositoryOwner}/${githubRepositoryName}/git/refs`;
-  const body = JSON.stringify({
-    ref: `refs/tags/${githubReleaseName}`,
-    sha: githubSha
-  });
-  const response = await fetchUrl(requestUrl, {
-    headers: {
-      "authorization": `token ${githubToken}`,
-      "content-length": Buffer.byteLength(body)
-    },
-    method: "POST",
-    body
-  });
-  const responseStatus = response.status;
-
-  if (responseStatus !== 201) {
-    throw new Error(writeUnexpectedResponseStatus$1({
-      requestUrl,
-      responseStatus,
-      responseText: await response.text()
-    }));
-  }
-
-  const responseJson = await response.json();
-  return responseJson;
-};
-
-const writeUnexpectedResponseStatus$1 = ({
-  requestUrl,
-  responseStatus,
-  responseText
-}) => `github api response status should be 201.
---- request url ----
-${requestUrl}
---- response status ---
-${responseStatus}
---- response text ---
-${responseText}`;
-
-const ensureGithubReleaseForPackage = async ({
-  cancellationToken = createCancellationTokenForProcessSIGINT(),
-  logLevel,
-  projectDirectoryUrl,
-  updateProcessExitCode
-}) => {
-  return wrapAsyncFunction(async () => {
-    const logger = createLogger({
-      logLevel
-    });
-    logger.debug(`autoReleaseOnGithub(${JSON.stringify({
-      projectDirectoryUrl,
-      logLevel
-    }, null, "  ")})`);
-    projectDirectoryUrl = assertAndNormalizeDirectoryUrl(projectDirectoryUrl);
-    const {
-      githubToken,
-      githubRepositoryOwner,
-      githubRepositoryName,
-      githubSha
-    } = getOptionsFromGithubAction();
-    logger.debug(`reading project package.json`);
-    const {
-      packageVersion
-    } = await getOptionsFromProjectPackage({
-      projectDirectoryUrl
-    });
-    cancellationToken.throwIfRequested();
-    logger.debug(`${packageVersion} found in package.json`);
-    logger.debug(`search release for ${packageVersion} on github`);
-    const githubReleaseName = `v${packageVersion}`;
-    const existingRelease = await getGithubRelease({
-      githubToken,
-      githubRepositoryOwner,
-      githubRepositoryName,
-      githubReleaseName
-    });
-    cancellationToken.throwIfRequested();
-
-    if (existingRelease) {
-      logger.info(`${packageVersion} already released at ${generateReleaseUrl({
-        githubRepositoryOwner,
-        githubRepositoryName,
-        githubReleaseName
-      })}`);
-      return;
-    }
-
-    logger.info(`creating release for ${packageVersion}`);
-    await createGithubRelease({
-      githubToken,
-      githubRepositoryOwner,
-      githubRepositoryName,
-      githubSha,
-      githubReleaseName
-    });
-    logger.info(`release created at ${generateReleaseUrl({
-      githubRepositoryOwner,
-      githubRepositoryName,
-      githubReleaseName
-    })}`);
-  }, {
-    updateProcessExitCode
-  });
-};
-
-const generateReleaseUrl = ({
-  githubRepositoryOwner,
-  githubRepositoryName,
-  githubReleaseName
-}) => {
-  return `https://github.com/${githubRepositoryOwner}/${githubRepositoryName}/releases/tag/${githubReleaseName}`;
-};
-
-const getOptionsFromGithubAction = () => {
-  const eventName = process.env.GITHUB_EVENT_NAME;
-
-  if (!eventName) {
-    throw new Error(`missing process.env.GITHUB_EVENT_NAME, we are not in a github action`);
-  }
-
-  if (eventName !== "push") {
-    throw new Error(`getOptionsFromGithubAction must be called only in a push action`);
-  }
-
-  const githubRepository = process.env.GITHUB_REPOSITORY;
-
-  if (!githubRepository) {
-    throw new Error(`missing process.env.GITHUB_REPOSITORY`);
-  }
-
-  const [githubRepositoryOwner, githubRepositoryName] = githubRepository.split("/");
-  const githubToken = process.env.GITHUB_TOKEN;
-
-  if (!githubToken) {
-    throw new Error(`missing process.env.GITHUB_TOKEN`);
-  }
-
-  const githubSha = process.env.GITHUB_SHA;
-
-  if (!githubSha) {
-    throw new Error(`missing process.env.GITHUB_SHA`);
-  }
-
-  return {
-    githubRepositoryOwner,
-    githubRepositoryName,
-    githubToken,
-    githubSha
-  };
-};
-
-const getOptionsFromProjectPackage = async ({
-  projectDirectoryUrl
-}) => {
-  const projectPackage = await readProjectPackage({
-    projectDirectoryUrl
-  });
-  return {
-    packageVersion: projectPackage.version
-  };
-};
-
-exports.ensureGithubReleaseForPackage = ensureGithubReleaseForPackage;
-//# sourceMappingURL=main.cjs.map