@jsenv/https-local 3.0.7 → 3.1.1

package/src/internal/mac/nss_mac.js

@@ -1,37 +1,36 @@
-import { fileURLToPath } from "node:url"
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { UNICODE } from "@jsenv/log"
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem";
+import { UNICODE } from "@jsenv/humanize";
+import { fileURLToPath } from "node:url";
+import { commandExists } from "../command.js";
+import { exec } from "../exec.js";
+import { memoize } from "../memoize.js";
 
-import { memoize } from "../memoize.js"
-import { exec } from "../exec.js"
-import { commandExists } from "../command.js"
-
-export const nssCommandName = "nss"
+export const nssCommandName = "nss";
 
 export const detectIfNSSIsInstalled = async ({ logger }) => {
-  logger.debug(`Detecting if nss is installed....`)
-  const brewListCommand = `brew list --versions nss`
+  logger.debug(`Detecting if nss is installed....`);
+  const brewListCommand = `brew list --versions nss`;
 
   try {
-    await exec(brewListCommand)
-    logger.debug(`${UNICODE.OK} nss is installed`)
-    return true
-  } catch (e) {
-    logger.debug(`${UNICODE.INFO} nss not installed`)
-    return false
+    await exec(brewListCommand);
+    logger.debug(`${UNICODE.OK} nss is installed`);
+    return true;
+  } catch {
+    logger.debug(`${UNICODE.INFO} nss not installed`);
+    return false;
   }
-}
+};
 
 export const getCertutilBinPath = memoize(async () => {
-  const brewCommand = `brew --prefix nss`
-  const brewCommandOutput = await exec(brewCommand)
+  const brewCommand = `brew --prefix nss`;
+  const brewCommandOutput = await exec(brewCommand);
   const nssCommandDirectoryUrl = assertAndNormalizeDirectoryUrl(
     brewCommandOutput.trim(),
-  )
-  const certutilBinUrl = new URL(`./bin/certutil`, nssCommandDirectoryUrl).href
-  const certutilBinPath = fileURLToPath(certutilBinUrl)
-  return certutilBinPath
-})
+  );
+  const certutilBinUrl = new URL(`./bin/certutil`, nssCommandDirectoryUrl).href;
+  const certutilBinPath = fileURLToPath(certutilBinUrl);
+  return certutilBinPath;
+});
 
 export const getNSSDynamicInstallInfo = () => {
   return {
@@ -39,12 +38,12 @@ export const getNSSDynamicInstallInfo = () => {
     notInstallableReason: `"brew" is not available`,
     suggestion: `install "brew" on this mac`,
     install: async ({ logger }) => {
-      const brewInstallCommand = `brew install nss`
+      const brewInstallCommand = `brew install nss`;
       logger.info(
         `"nss" is not installed, trying to install "nss" via Homebrew`,
-      )
-      logger.info(`${UNICODE.COMMAND} ${brewInstallCommand}`)
-      await exec(brewInstallCommand)
+      );
+      logger.info(`${UNICODE.COMMAND} ${brewInstallCommand}`);
+      await exec(brewInstallCommand);
     },
-  }
-}
+  };
+};

package/src/internal/mac/safari.js

@@ -2,5 +2,5 @@ export const executeTrustQueryOnSafari = ({ macTrustInfo }) => {
   return {
     status: macTrustInfo.status,
     reason: macTrustInfo.reason,
-  }
-}
+  };
+};

package/src/internal/memoize.js

@@ -1,24 +1,24 @@
 export const memoize = (compute) => {
-  let memoized = false
-  let memoizedValue
+  let memoized = false;
+  let memoizedValue;
 
   const fnWithMemoization = (...args) => {
     if (memoized) {
-      return memoizedValue
+      return memoizedValue;
     }
     // if compute is recursive wait for it to be fully done before storing the lockValue
     // so set locked later
-    memoizedValue = compute(...args)
-    memoized = true
-    return memoizedValue
-  }
+    memoizedValue = compute(...args);
+    memoized = true;
+    return memoizedValue;
+  };
 
   fnWithMemoization.forget = () => {
-    const value = memoizedValue
-    memoized = false
-    memoizedValue = undefined
-    return value
-  }
+    const value = memoizedValue;
+    memoized = false;
+    memoizedValue = undefined;
+    return value;
+  };
 
-  return fnWithMemoization
-}
+  return fnWithMemoization;
+};

package/src/internal/nssdb_browser.js

@@ -3,20 +3,22 @@
  * Certutil command documentation: https://developer.mozilla.org/en-US/docs/Mozilla/Projects/NSS/tools/NSS_Tools_certutil
  */
 
-import { existsSync } from "node:fs"
-import { fileURLToPath } from "node:url"
-import { urlToFilename } from "@jsenv/urls"
-import { createDetailedMessage, UNICODE } from "@jsenv/log"
-import { assertAndNormalizeDirectoryUrl, collectFiles } from "@jsenv/filesystem"
-
-import { detectBrowser } from "./browser_detection.js"
-import { exec } from "./exec.js"
-import { searchCertificateInCommandOutput } from "./search_certificate_in_command_output.js"
 import {
-  VERB_CHECK_TRUST,
+  assertAndNormalizeDirectoryUrl,
+  collectFiles,
+} from "@jsenv/filesystem";
+import { createDetailedMessage, UNICODE } from "@jsenv/humanize";
+import { urlToFilename } from "@jsenv/urls";
+import { existsSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { detectBrowser } from "./browser_detection.js";
+import { exec } from "./exec.js";
+import { searchCertificateInCommandOutput } from "./search_certificate_in_command_output.js";
+import {
   VERB_ADD_TRUST,
+  VERB_CHECK_TRUST,
   VERB_ENSURE_TRUST,
-} from "./trust_query.js"
+} from "./trust_query.js";
 
 export const executeTrustQueryOnBrowserNSSDB = async ({
   logger,
@@ -37,34 +39,34 @@ export const executeTrustQueryOnBrowserNSSDB = async ({
   browserNSSDBDirectoryUrls,
   getBrowserClosedPromise,
 }) => {
-  logger.debug(`Detecting ${browserName}...`)
+  logger.debug(`Detecting ${browserName}...`);
 
-  const browserDetected = detectBrowser(browserPaths)
+  const browserDetected = detectBrowser(browserPaths);
   if (!browserDetected) {
-    logger.debug(`${UNICODE.INFO} ${browserName} not detected`)
+    logger.debug(`${UNICODE.INFO} ${browserName} not detected`);
     return {
       status: "other",
       reason: `${browserName} not detected`,
-    }
+    };
   }
-  logger.debug(`${UNICODE.OK} ${browserName} detected`)
+  logger.debug(`${UNICODE.OK} ${browserName} detected`);
 
   if (verb === VERB_CHECK_TRUST && certificateIsNew) {
-    logger.info(`${UNICODE.INFO} You should add certificate to ${browserName}`)
+    logger.info(`${UNICODE.INFO} You should add certificate to ${browserName}`);
     return {
       status: "not_trusted",
       reason: "certificate is new and tryToTrust is disabled",
-    }
+    };
   }
 
-  logger.info(`Check if certificate is in ${browserName}...`)
-  const nssIsInstalled = await detectIfNSSIsInstalled({ logger })
-  const cannotCheckMessage = `${UNICODE.FAILURE} cannot check if certificate is in ${browserName}`
+  logger.info(`Check if certificate is in ${browserName}...`);
+  const nssIsInstalled = await detectIfNSSIsInstalled({ logger });
+  const cannotCheckMessage = `${UNICODE.FAILURE} cannot check if certificate is in ${browserName}`;
   if (!nssIsInstalled) {
     if (verb === VERB_ADD_TRUST || verb === VERB_ENSURE_TRUST) {
-      const nssDynamicInstallInfo = await getNSSDynamicInstallInfo({ logger })
+      const nssDynamicInstallInfo = await getNSSDynamicInstallInfo({ logger });
       if (!nssDynamicInstallInfo.isInstallable) {
-        const reason = `"${nssCommandName}" is not installed and not cannot be installed`
+        const reason = `"${nssCommandName}" is not installed and not cannot be installed`;
         logger.warn(
           createDetailedMessage(cannotCheckMessage, {
             reason,
@@ -72,244 +74,247 @@ export const executeTrustQueryOnBrowserNSSDB = async ({
               nssDynamicInstallInfo.notInstallableReason,
             "suggested solution": nssDynamicInstallInfo.suggestion,
           }),
-        )
+        );
         return {
           status: "unknown",
           reason,
-        }
+        };
       }
 
       if (!NSSDynamicInstall) {
-        const reason = `"${nssCommandName}" is not installed and NSSDynamicInstall is false`
+        const reason = `"${nssCommandName}" is not installed and NSSDynamicInstall is false`;
         logger.warn(
           createDetailedMessage(cannotCheckMessage, {
             reason,
             "suggested solution": `Allow "${nssCommandName}" dynamic install with NSSDynamicInstall: true`,
           }),
-        )
+        );
         return {
           status: "unknown",
           reason,
-        }
+        };
       }
 
       try {
-        await nssDynamicInstallInfo.install({ logger })
+        await nssDynamicInstallInfo.install({ logger });
       } catch (e) {
         logger.error(
           createDetailedMessage(cannotCheckMessage, {
             "reason": `error while trying to install "${nssCommandName}"`,
             "error stack": e.stack,
           }),
-        )
+        );
         return {
           status: "unknown",
           reason: `"${nssCommandName}" installation failed`,
-        }
+        };
       }
     } else {
-      const reason = `"${nssCommandName}" is not installed`
+      const reason = `"${nssCommandName}" is not installed`;
       logger.info(
         createDetailedMessage(cannotCheckMessage, {
           reason,
         }),
-      )
+      );
       return {
         status: "unknown",
         reason,
-      }
+      };
     }
   }
 
-  let NSSDBFiles
+  let NSSDBFiles;
   for (const browserNSSDBDirectoryUrl of browserNSSDBDirectoryUrls) {
     NSSDBFiles = await findNSSDBFiles({
       logger,
       NSSDBDirectoryUrl: browserNSSDBDirectoryUrl,
-    })
+    });
     if (NSSDBFiles.length > 0) {
-      break
+      break;
     }
   }
 
-  const fileCount = NSSDBFiles.length
+  const fileCount = NSSDBFiles.length;
   if (fileCount === 0) {
-    const reason = `could not find nss database file`
-    logger.warn(createDetailedMessage(cannotCheckMessage), { reason })
+    const reason = `could not find nss database file`;
+    logger.warn(createDetailedMessage(cannotCheckMessage), { reason });
     return {
       status: "unknown",
       reason,
-    }
+    };
   }
 
-  const certificateFilePath = fileURLToPath(certificateFileUrl)
-  const certutilBinPath = await getCertutilBinPath()
+  const certificateFilePath = fileURLToPath(certificateFileUrl);
+  const certutilBinPath = await getCertutilBinPath();
 
   const checkNSSDB = async ({ NSSDBFileUrl }) => {
-    const directoryArg = getDirectoryArgFromNSSDBFileUrl(NSSDBFileUrl)
-    const certutilListCommand = `${certutilBinPath} -L -a -d ${directoryArg} -n "${certificateCommonName}"`
-    logger.debug(`Checking if certificate is in nss database...`)
-    logger.debug(`${UNICODE.COMMAND} ${certutilListCommand}`)
+    const directoryArg = getDirectoryArgFromNSSDBFileUrl(NSSDBFileUrl);
+    const certutilListCommand = `${certutilBinPath} -L -a -d ${directoryArg} -n "${certificateCommonName}"`;
+    logger.debug(`Checking if certificate is in nss database...`);
+    logger.debug(`${UNICODE.COMMAND} ${certutilListCommand}`);
     try {
-      const output = await execCertutilCommmand(certutilListCommand)
-      const isInDatabase = searchCertificateInCommandOutput(output, certificate)
+      const output = await execCertutilCommmand(certutilListCommand);
+      const isInDatabase = searchCertificateInCommandOutput(
+        output,
+        certificate,
+      );
       if (isInDatabase) {
-        return "found"
+        return "found";
       }
-      return "outdated"
+      return "outdated";
     } catch (e) {
       if (isCertificateNotFoundError(e)) {
-        return "missing"
+        return "missing";
       }
-      throw e
+      throw e;
     }
-  }
+  };
 
   const addToNSSDB = async ({ NSSDBFileUrl }) => {
-    const directoryArg = getDirectoryArgFromNSSDBFileUrl(NSSDBFileUrl)
-    const certutilAddCommand = `${certutilBinPath} -A -d ${directoryArg} -t C,, -i "${certificateFilePath}" -n "${certificateCommonName}"`
-    logger.debug(`Adding certificate to nss database...`)
-    logger.debug(`${UNICODE.COMMAND} ${certutilAddCommand}`)
-    await execCertutilCommmand(certutilAddCommand)
-    logger.debug(`${UNICODE.OK} certificate added to nss database`)
-  }
+    const directoryArg = getDirectoryArgFromNSSDBFileUrl(NSSDBFileUrl);
+    const certutilAddCommand = `${certutilBinPath} -A -d ${directoryArg} -t C,, -i "${certificateFilePath}" -n "${certificateCommonName}"`;
+    logger.debug(`Adding certificate to nss database...`);
+    logger.debug(`${UNICODE.COMMAND} ${certutilAddCommand}`);
+    await execCertutilCommmand(certutilAddCommand);
+    logger.debug(`${UNICODE.OK} certificate added to nss database`);
+  };
 
   const removeFromNSSDB = async ({ NSSDBFileUrl }) => {
-    const directoryArg = getDirectoryArgFromNSSDBFileUrl(NSSDBFileUrl)
-    const certutilRemoveCommand = `${certutilBinPath} -D -d ${directoryArg} -t C,, -i "${certificateFilePath}" -n "${certificateCommonName}"`
-    logger.debug(`Removing certificate from nss database...`)
-    logger.debug(`${UNICODE.COMMAND} ${certutilRemoveCommand}`)
-    await execCertutilCommmand(certutilRemoveCommand)
-    logger.debug(`${UNICODE.OK} certificate removed from nss database`)
-  }
+    const directoryArg = getDirectoryArgFromNSSDBFileUrl(NSSDBFileUrl);
+    const certutilRemoveCommand = `${certutilBinPath} -D -d ${directoryArg} -t C,, -i "${certificateFilePath}" -n "${certificateCommonName}"`;
+    logger.debug(`Removing certificate from nss database...`);
+    logger.debug(`${UNICODE.COMMAND} ${certutilRemoveCommand}`);
+    await execCertutilCommmand(certutilRemoveCommand);
+    logger.debug(`${UNICODE.OK} certificate removed from nss database`);
+  };
 
-  const missings = []
-  const outdateds = []
-  const founds = []
+  const missings = [];
+  const outdateds = [];
+  const founds = [];
   await Promise.all(
     NSSDBFiles.map(async (NSSDBFileUrl) => {
-      const certificateStatus = await checkNSSDB({ NSSDBFileUrl })
+      const certificateStatus = await checkNSSDB({ NSSDBFileUrl });
 
       if (certificateStatus === "missing") {
-        logger.debug(`${UNICODE.INFO} certificate not found in nss database`)
-        missings.push(NSSDBFileUrl)
-        return
+        logger.debug(`${UNICODE.INFO} certificate not found in nss database`);
+        missings.push(NSSDBFileUrl);
+        return;
       }
 
       if (certificateStatus === "outdated") {
-        outdateds.push(NSSDBFileUrl)
-        return
+        outdateds.push(NSSDBFileUrl);
+        return;
       }
 
-      logger.debug(`${UNICODE.OK} certificate found in nss database`)
-      founds.push(NSSDBFileUrl)
+      logger.debug(`${UNICODE.OK} certificate found in nss database`);
+      founds.push(NSSDBFileUrl);
     }),
-  )
+  );
 
-  const missingCount = missings.length
-  const outdatedCount = outdateds.length
-  const foundCount = founds.length
+  const missingCount = missings.length;
+  const outdatedCount = outdateds.length;
+  const foundCount = founds.length;
 
   if (verb === VERB_CHECK_TRUST) {
     if (missingCount > 0 || outdatedCount > 0) {
-      logger.info(`${UNICODE.INFO} certificate not found in ${browserName}`)
+      logger.info(`${UNICODE.INFO} certificate not found in ${browserName}`);
       return {
         status: "not_trusted",
         reason: `missing or outdated in ${browserName} nss database file`,
-      }
+      };
     }
-    logger.info(`${UNICODE.OK} certificate found in ${browserName}`)
+    logger.info(`${UNICODE.OK} certificate found in ${browserName}`);
     return {
       status: "trusted",
       reason: `found in ${browserName} nss database file`,
-    }
+    };
   }
 
   if (verb === VERB_ADD_TRUST || verb === VERB_ENSURE_TRUST) {
     if (missingCount === 0 && outdatedCount === 0) {
-      logger.info(`${UNICODE.OK} certificate found in ${browserName}`)
+      logger.info(`${UNICODE.OK} certificate found in ${browserName}`);
       return {
         status: "trusted",
         reason: `found in all ${browserName} nss database file`,
-      }
+      };
     }
-    logger.info(`${UNICODE.INFO} certificate not found in ${browserName}`)
-    logger.info(`Adding certificate to ${browserName}...`)
-    await getBrowserClosedPromise()
+    logger.info(`${UNICODE.INFO} certificate not found in ${browserName}`);
+    logger.info(`Adding certificate to ${browserName}...`);
+    await getBrowserClosedPromise();
     await Promise.all(
       missings.map(async (missing) => {
-        await addToNSSDB({ NSSDBFileUrl: missing })
+        await addToNSSDB({ NSSDBFileUrl: missing });
       }),
-    )
+    );
     await Promise.all(
       outdateds.map(async (outdated) => {
-        await removeFromNSSDB({ NSSDBFileUrl: outdated })
-        await addToNSSDB({ NSSDBFileUrl: outdated })
+        await removeFromNSSDB({ NSSDBFileUrl: outdated });
+        await addToNSSDB({ NSSDBFileUrl: outdated });
       }),
-    )
-    logger.info(`${UNICODE.OK} certificate added to ${browserName}`)
+    );
+    logger.info(`${UNICODE.OK} certificate added to ${browserName}`);
     return {
       status: "trusted",
       reason: `added to ${browserName} nss database file`,
-    }
+    };
   }
 
   if (outdatedCount === 0 && foundCount === 0) {
-    logger.info(`${UNICODE.INFO} certificate not found in ${browserName}`)
+    logger.info(`${UNICODE.INFO} certificate not found in ${browserName}`);
     return {
       status: "not_trusted",
       reason: `not found in ${browserName} nss database file`,
-    }
+    };
   }
-  logger.info(`${UNICODE.INFO} found certificate in ${browserName}`)
-  logger.info(`Removing certificate from ${browserName}...`)
-  await getBrowserClosedPromise()
+  logger.info(`${UNICODE.INFO} found certificate in ${browserName}`);
+  logger.info(`Removing certificate from ${browserName}...`);
+  await getBrowserClosedPromise();
   await Promise.all(
     outdateds.map(async (outdated) => {
-      await removeFromNSSDB({ NSSDBFileUrl: outdated })
+      await removeFromNSSDB({ NSSDBFileUrl: outdated });
     }),
-  )
+  );
   await Promise.all(
     founds.map(async (found) => {
-      await removeFromNSSDB({ NSSDBFileUrl: found })
+      await removeFromNSSDB({ NSSDBFileUrl: found });
     }),
-  )
-  logger.info(`${UNICODE.OK} certificate removed from ${browserName}`)
+  );
+  logger.info(`${UNICODE.OK} certificate removed from ${browserName}`);
   return {
     status: "not_trusted",
     reason: `removed from ${browserName} nss database file`,
-  }
-}
+  };
+};
 
 const isCertificateNotFoundError = (error) => {
   if (error.message.includes("could not find certificate named")) {
-    return true
+    return true;
   }
   if (error.message.includes("PR_FILE_NOT_FOUND_ERROR")) {
-    return true
+    return true;
   }
-  return false
-}
+  return false;
+};
 
-const NSSDirectoryCache = {}
+const NSSDirectoryCache = {};
 const findNSSDBFiles = async ({ logger, NSSDBDirectoryUrl }) => {
-  NSSDBDirectoryUrl = String(NSSDBDirectoryUrl)
-  const resultFromCache = NSSDirectoryCache[NSSDBDirectoryUrl]
+  NSSDBDirectoryUrl = String(NSSDBDirectoryUrl);
+  const resultFromCache = NSSDirectoryCache[NSSDBDirectoryUrl];
   if (resultFromCache) {
-    return resultFromCache
+    return resultFromCache;
   }
 
-  logger.debug(`Searching nss database files in directory...`)
-  const NSSDBDirectoryPath = fileURLToPath(NSSDBDirectoryUrl)
-  const NSSDBDirectoryExists = existsSync(NSSDBDirectoryPath)
+  logger.debug(`Searching nss database files in directory...`);
+  const NSSDBDirectoryPath = fileURLToPath(NSSDBDirectoryUrl);
+  const NSSDBDirectoryExists = existsSync(NSSDBDirectoryPath);
   if (!NSSDBDirectoryExists) {
     logger.info(
       `${UNICODE.INFO} nss database directory not found on filesystem at ${NSSDBDirectoryPath}`,
-    )
-    NSSDirectoryCache[NSSDBDirectoryUrl] = []
-    return []
+    );
+    NSSDirectoryCache[NSSDBDirectoryUrl] = [];
+    return [];
   }
-  NSSDBDirectoryUrl = assertAndNormalizeDirectoryUrl(NSSDBDirectoryUrl)
+  NSSDBDirectoryUrl = assertAndNormalizeDirectoryUrl(NSSDBDirectoryUrl);
   const NSSDBFiles = await collectFiles({
     directoryUrl: NSSDBDirectoryUrl,
     associations: {
@@ -318,36 +323,36 @@ const findNSSDBFiles = async ({ logger, NSSDBDirectoryUrl }) => {
     },
     predicate: ({ isLegacyNSSDB, isModernNSSDB }) =>
       isLegacyNSSDB || isModernNSSDB,
-  })
-  const fileCount = NSSDBFiles.length
+  });
+  const fileCount = NSSDBFiles.length;
   if (fileCount === 0) {
     logger.warn(
       `${UNICODE.WARNING} could not find nss database file in ${NSSDBDirectoryUrl}`,
-    )
-    NSSDirectoryCache[NSSDBDirectoryUrl] = []
-    return []
+    );
+    NSSDirectoryCache[NSSDBDirectoryUrl] = [];
+    return [];
   }
 
   logger.debug(
     `${UNICODE.OK} found ${fileCount} nss database file in ${NSSDBDirectoryUrl}`,
-  )
+  );
   const files = NSSDBFiles.map((file) => {
-    return new URL(file.relativeUrl, NSSDBDirectoryUrl).href
-  })
-  NSSDirectoryCache[NSSDBDirectoryUrl] = files
-  return files
-}
+    return new URL(file.relativeUrl, NSSDBDirectoryUrl).href;
+  });
+  NSSDirectoryCache[NSSDBDirectoryUrl] = files;
+  return files;
+};
 
 const getDirectoryArgFromNSSDBFileUrl = (NSSDBFileUrl) => {
-  const nssDBFilename = urlToFilename(NSSDBFileUrl)
-  const nssDBDirectoryUrl = new URL("./", NSSDBFileUrl).href
-  const nssDBDirectoryPath = fileURLToPath(nssDBDirectoryUrl)
+  const nssDBFilename = urlToFilename(NSSDBFileUrl);
+  const nssDBDirectoryUrl = new URL("./", NSSDBFileUrl).href;
+  const nssDBDirectoryPath = fileURLToPath(nssDBDirectoryUrl);
   return nssDBFilename === "cert8.db"
     ? `"${nssDBDirectoryPath}"`
-    : `sql:"${nssDBDirectoryPath}"`
-}
+    : `sql:"${nssDBDirectoryPath}"`;
+};
 
 const execCertutilCommmand = async (command) => {
-  const output = await exec(command)
-  return output
-}
+  const output = await exec(command);
+  return output;
+};

package/src/internal/platform.js

@@ -1,13 +1,13 @@
 export const importPlatformMethods = async () => {
-  const { platform } = process
+  const { platform } = process;
   if (platform === "darwin") {
-    return await import("./mac/mac.js")
+    return await import("./mac/mac.js");
   }
   if (platform === "linux") {
-    return await import("./linux/linux.js")
+    return await import("./linux/linux.js");
   }
   if (platform === "win32") {
-    return await import("./windows/windows.js")
+    return await import("./windows/windows.js");
   }
-  return await import("./unsupported_platform/unsupported_platform.js")
-}
+  return await import("./unsupported_platform/unsupported_platform.js");
+};

package/src/internal/search_certificate_in_command_output.js

@@ -2,7 +2,7 @@ export const searchCertificateInCommandOutput = (
   commandOutput,
   certificateAsPEM,
 ) => {
-  commandOutput = commandOutput.replace(/\r\n/g, "\n").trim()
-  certificateAsPEM = certificateAsPEM.replace(/\r\n/g, "\n").trim()
-  return commandOutput.includes(certificateAsPEM)
-}
+  commandOutput = commandOutput.replace(/\r\n/g, "\n").trim();
+  certificateAsPEM = certificateAsPEM.replace(/\r\n/g, "\n").trim();
+  return commandOutput.includes(certificateAsPEM);
+};

package/src/internal/trust_query.js

@@ -1,4 +1,4 @@
-export const VERB_CHECK_TRUST = "CHECK_TRUST"
-export const VERB_ADD_TRUST = "ADD_TRUST"
-export const VERB_ENSURE_TRUST = "ENSURE_TRUST"
-export const VERB_REMOVE_TRUST = "REMOVE_TRUST"
+export const VERB_CHECK_TRUST = "CHECK_TRUST";
+export const VERB_ADD_TRUST = "ADD_TRUST";
+export const VERB_ENSURE_TRUST = "ENSURE_TRUST";
+export const VERB_REMOVE_TRUST = "REMOVE_TRUST";