@socketsecurity/cli-with-sentry 0.14.65 → 0.14.67

package/dist/module-sync/config.d.ts

@@ -0,0 +1,19 @@
+import config from '@socketsecurity/config';
+interface LocalConfig {
+    apiBaseUrl?: string | null | undefined;
+    apiKey?: string | null | undefined;
+    apiProxy?: string | null | undefined;
+    apiToken?: string | null | undefined;
+    defaultOrg?: string;
+    enforcedOrgs?: string[] | readonly string[] | null | undefined;
+    test?: unknown;
+}
+declare const supportedConfigKeys: Map<keyof LocalConfig, string>;
+declare const sensitiveConfigKeys: Set<keyof LocalConfig>;
+declare function findSocketYmlSync(): {
+    path: string;
+    parsed: config.SocketYml;
+} | null;
+declare function getConfigValue<Key extends keyof LocalConfig>(key: Key): LocalConfig[Key];
+declare function updateConfigValue<Key extends keyof LocalConfig>(key: keyof LocalConfig, value: LocalConfig[Key]): void;
+export { LocalConfig, supportedConfigKeys, sensitiveConfigKeys, findSocketYmlSync, getConfigValue, updateConfigValue };

package/dist/module-sync/path-resolve.d.ts

@@ -6,5 +6,5 @@ declare function findBinPathDetailsSync(binName: string): {
     shadowed: boolean;
 };
 declare function findNpmPathSync(npmBinPath: string): string | undefined;
-declare function getPackageFilesFullScans(cwd: string, inputPaths: string[], supportedFiles: SocketSdkReturnType<'getReportSupportedFiles'>['data'], config?: SocketYml | undefined): Promise<string[]>;
-export { findBinPathDetailsSync, findNpmPathSync, getPackageFilesFullScans };
+declare function getPackageFilesForScan(cwd: string, inputPaths: string[], supportedFiles: SocketSdkReturnType<'getReportSupportedFiles'>['data'], config?: SocketYml | undefined): Promise<string[]>;
+export { findBinPathDetailsSync, findNpmPathSync, getPackageFilesForScan };

package/dist/module-sync/shadow-npm-inject.js

@@ -26,51 +26,17 @@ var isInteractive = require('@socketregistry/is-interactive/index.cjs');
 var registryConstants = require('@socketsecurity/registry/lib/constants');
 var strings = require('@socketsecurity/registry/lib/strings');
 var sdk = require('@socketsecurity/sdk');
-var promises = require('node:timers/promises');
 var fs = require('node:fs');
 var os = require('node:os');
 var path = require('node:path');
 var config = require('@socketsecurity/config');
+var promises = require('node:timers/promises');
 var packages = require('@socketsecurity/registry/lib/packages');
 var sorts = require('@socketsecurity/registry/lib/sorts');
 var terminalLink = _socketInterop(require('terminal-link'));
 var colors = _socketInterop(require('yoctocolors-cjs'));
 var indentString = require('@socketregistry/indent-string/index.cjs');
 
-const {
-  kInternalsSymbol: kInternalsSymbol$1,
-  [kInternalsSymbol$1]: {
-    getSentry
-  }
-} = constants;
-class AuthError extends Error {}
-class InputError extends Error {
-  constructor(message, body) {
-    super(message);
-    this.body = body;
-  }
-}
-async function captureException(exception, hint) {
-  const result = captureExceptionSync(exception, hint);
-  // "Sleep" for a second, just in case, hopefully enough time to initiate fetch.
-  await promises.setTimeout(1000);
-  return result;
-}
-function captureExceptionSync(exception, hint) {
-  const Sentry = getSentry();
-  if (!Sentry) {
-    return '';
-  }
-  debug.debugLog('captureException: Sending exception to Sentry.');
-  return Sentry.captureException(exception, hint);
-}
-function isErrnoException(value) {
-  if (!(value instanceof Error)) {
-    return false;
-  }
-  return value.code !== undefined;
-}
-
 const {
   abortSignal
 } = constants;
@@ -143,34 +109,36 @@ function safeReadFileSync(filepath, options) {
 const LOCALAPPDATA = 'LOCALAPPDATA';
 // Default app data folder env var on Mac/Linux
 const XDG_DATA_HOME = 'XDG_DATA_HOME';
-const SOCKET_APP_DIR = 'socket/settings';
-const supportedApiKeys = new Set(['apiBaseUrl', 'apiKey', 'apiProxy', 'enforcedOrgs']);
-let settings;
-let settingsPath;
-let warnedSettingPathWin32Missing = false;
+const SOCKET_APP_DIR = 'socket/settings'; // It used to be settings...
+
+const supportedConfigKeys = new Map([['apiBaseUrl', 'Base URL of the API endpoint'], ['apiToken', 'The API token required to access most API endpoints'], ['apiProxy', 'A proxy through which to access the API'], ['enforcedOrgs', 'Orgs in this list have their security policies enforced on this machine']]);
+const sensitiveConfigKeys = new Set(['apiToken']);
+let cachedConfig;
+let configPath;
+let warnedConfigPathWin32Missing = false;
 let pendingSave = false;
-function getSettings() {
-  if (settings === undefined) {
-    settings = {};
-    const settingsPath = getSettingsPath();
-    if (settingsPath) {
-      const raw = safeReadFileSync(settingsPath);
+function getConfigValues() {
+  if (cachedConfig === undefined) {
+    cachedConfig = {};
+    const configPath = getConfigPath();
+    if (configPath) {
+      const raw = safeReadFileSync(configPath);
       if (raw) {
         try {
-          Object.assign(settings, JSON.parse(Buffer.from(raw, 'base64').toString()));
+          Object.assign(cachedConfig, JSON.parse(Buffer.from(raw, 'base64').toString()));
         } catch {
-          logger.logger.warn(`Failed to parse settings at ${settingsPath}`);
+          logger.logger.warn(`Failed to parse config at ${configPath}`);
         }
       } else {
-        fs.mkdirSync(path.dirname(settingsPath), {
+        fs.mkdirSync(path.dirname(configPath), {
           recursive: true
         });
       }
     }
   }
-  return settings;
+  return cachedConfig;
 }
-function getSettingsPath() {
+function getConfigPath() {
   // Get the OS app data folder:
   // - Win: %LOCALAPPDATA% or fail?
   // - Mac: %XDG_DATA_HOME% or fallback to "~/Library/Application Support/"
@@ -183,7 +151,7 @@ function getSettingsPath() {
   // - Mac: %XDG_DATA_HOME%/socket/settings or "~/Library/Application Support/socket/settings"
   // - Linux: %XDG_DATA_HOME%/socket/settings or "~/.local/share/socket/settings"
 
-  if (settingsPath === undefined) {
+  if (configPath === undefined) {
     // Lazily access constants.WIN32.
     const {
       WIN32
@@ -191,22 +159,22 @@ function getSettingsPath() {
     let dataHome = WIN32 ? process$1.env[LOCALAPPDATA] : process$1.env[XDG_DATA_HOME];
     if (!dataHome) {
       if (WIN32) {
-        if (!warnedSettingPathWin32Missing) {
-          warnedSettingPathWin32Missing = true;
+        if (!warnedConfigPathWin32Missing) {
+          warnedConfigPathWin32Missing = true;
           logger.logger.warn(`Missing %${LOCALAPPDATA}%`);
         }
       } else {
         dataHome = path.join(os.homedir(), ...(process$1.platform === 'darwin' ? ['Library', 'Application Support'] : ['.local', 'share']));
       }
     }
-    settingsPath = dataHome ? path.join(dataHome, SOCKET_APP_DIR) : undefined;
+    configPath = dataHome ? path.join(dataHome, SOCKET_APP_DIR) : undefined;
   }
-  return settingsPath;
+  return configPath;
 }
-function normalizeSettingsKey(key) {
+function normalizeConfigKey(key) {
   const normalizedKey = key === 'apiToken' ? 'apiKey' : key;
-  if (!supportedApiKeys.has(normalizedKey)) {
-    throw new Error(`Invalid settings key: ${normalizedKey}`);
+  if (normalizedKey !== 'apiKey' && normalizedKey !== 'test' && !supportedConfigKeys.has(normalizedKey)) {
+    throw new Error(`Invalid config key: ${normalizedKey}`);
   }
   return normalizedKey;
 }
@@ -235,37 +203,72 @@ function findSocketYmlSync() {
   }
   return null;
 }
-function getSetting(key) {
-  return getSettings()[normalizeSettingsKey(key)];
+function getConfigValue(key) {
+  return getConfigValues()[normalizeConfigKey(key)];
 }
-function updateSetting(key, value) {
-  const settings = getSettings();
-  settings[normalizeSettingsKey(key)] = value;
+function updateConfigValue(key, value) {
+  const localConfig = getConfigValues();
+  localConfig[normalizeConfigKey(key)] = value;
   if (!pendingSave) {
     pendingSave = true;
     process$1.nextTick(() => {
       pendingSave = false;
-      const settingsPath = getSettingsPath();
-      if (settingsPath) {
-        fs.writeFileSync(settingsPath, Buffer.from(JSON.stringify(settings)).toString('base64'));
+      const configPath = getConfigPath();
+      if (configPath) {
+        fs.writeFileSync(configPath, Buffer.from(JSON.stringify(localConfig)).toString('base64'));
       }
     });
   }
 }
 
 const {
-  SOCKET_CLI_NO_API_TOKEN
+  kInternalsSymbol: kInternalsSymbol$1,
+  [kInternalsSymbol$1]: {
+    getSentry
+  }
+} = constants;
+class AuthError extends Error {}
+class InputError extends Error {
+  constructor(message, body) {
+    super(message);
+    this.body = body;
+  }
+}
+async function captureException(exception, hint) {
+  const result = captureExceptionSync(exception, hint);
+  // "Sleep" for a second, just in case, hopefully enough time to initiate fetch.
+  await promises.setTimeout(1000);
+  return result;
+}
+function captureExceptionSync(exception, hint) {
+  const Sentry = getSentry();
+  if (!Sentry) {
+    return '';
+  }
+  debug.debugLog('captureException: Sending exception to Sentry.');
+  return Sentry.captureException(exception, hint);
+}
+function isErrnoException(value) {
+  if (!(value instanceof Error)) {
+    return false;
+  }
+  return value.code !== undefined;
+}
+
+const {
+  SOCKET_CLI_NO_API_TOKEN,
+  SOCKET_SECURITY_API_TOKEN
 } = constants;
 
 // The API server that should be used for operations.
 function getDefaultApiBaseUrl() {
-  const baseUrl = process$1.env['SOCKET_SECURITY_API_BASE_URL'] || getSetting('apiBaseUrl');
+  const baseUrl = process$1.env['SOCKET_SECURITY_API_BASE_URL'] || getConfigValue('apiBaseUrl');
   return strings.isNonEmptyString(baseUrl) ? baseUrl : undefined;
 }
 
 // The API server that should be used for operations.
 function getDefaultHttpProxy() {
-  const apiProxy = process$1.env['SOCKET_SECURITY_API_PROXY'] || getSetting('apiProxy');
+  const apiProxy = process$1.env['SOCKET_SECURITY_API_PROXY'] || getConfigValue('apiProxy');
   return strings.isNonEmptyString(apiProxy) ? apiProxy : undefined;
 }
 
@@ -276,16 +279,18 @@ function getDefaultToken() {
   if (constants.ENV[SOCKET_CLI_NO_API_TOKEN]) {
     _defaultToken = undefined;
   } else {
-    const key = process$1.env['SOCKET_SECURITY_API_TOKEN'] ||
-    // Keep 'SOCKET_SECURITY_API_KEY' as an alias of 'SOCKET_SECURITY_API_TOKEN'.
-    // TODO: Remove 'SOCKET_SECURITY_API_KEY' alias.
-    process$1.env['SOCKET_SECURITY_API_KEY'] || getSetting('apiToken') || _defaultToken;
+    const key =
+    // Lazily access constants.ENV[SOCKET_SECURITY_API_TOKEN].
+    constants.ENV[SOCKET_SECURITY_API_TOKEN] || getConfigValue('apiToken') || _defaultToken;
     _defaultToken = strings.isNonEmptyString(key) ? key : undefined;
   }
   return _defaultToken;
 }
 function getPublicToken() {
-  return (process$1.env['SOCKET_SECURITY_API_TOKEN'] || getDefaultToken()) ?? registryConstants.SOCKET_PUBLIC_API_TOKEN;
+  return (
+    // Lazily access constants.ENV[SOCKET_SECURITY_API_TOKEN].
+    (constants.ENV[SOCKET_SECURITY_API_TOKEN] || getDefaultToken()) ?? registryConstants.SOCKET_PUBLIC_API_TOKEN
+  );
 }
 async function setupSdk(apiToken = getDefaultToken(), apiBaseUrl = getDefaultApiBaseUrl(), proxy = getDefaultHttpProxy()) {
   if (typeof apiToken !== 'string' && isInteractive()) {
@@ -306,7 +311,7 @@ async function setupSdk(apiToken = getDefaultToken(), apiBaseUrl = getDefaultApi
       // The '@rollup/plugin-replace' will replace "process.env['INLINED_SOCKET_CLI_NAME']".
       name: "@socketsecurity/cli",
       // The '@rollup/plugin-replace' will replace "process.env['INLINED_SOCKET_CLI_VERSION']".
-      version: "0.14.65",
+      version: "0.14.67",
       // The '@rollup/plugin-replace' will replace "process.env['INLINED_SOCKET_CLI_HOMEPAGE']".
       homepage: "https://github.com/SocketDev/socket-cli"
     })
@@ -1031,6 +1036,12 @@ function isArtifactAlertCve(alert) {
   return type === ALERT_TYPE_CVE || type === ALERT_TYPE_MEDIUM_CVE || type === ALERT_TYPE_MILD_CVE || type === ALERT_TYPE_CRITICAL_CVE;
 }
 
+let ALERT_FIX_TYPE = /*#__PURE__*/function (ALERT_FIX_TYPE) {
+  ALERT_FIX_TYPE["cve"] = "cve";
+  ALERT_FIX_TYPE["upgrade"] = "upgrade";
+  return ALERT_FIX_TYPE;
+}({});
+
 const ERROR_UX = {
   block: true,
   display: true
@@ -1172,23 +1183,29 @@ async function uxLookup(settings) {
         const sockSdk = await setupSdk(getPublicToken());
         const orgResult = await sockSdk.getOrganizations();
         if (!orgResult.success) {
-          throw new Error(`Failed to fetch Socket organization info: ${orgResult.error.message}`);
+          if (orgResult.status === 429) {
+            throw new Error(`API token quota exceeded: ${orgResult.error}`);
+          }
+          throw new Error(`Failed to fetch Socket organization info: ${orgResult.error}`);
         }
+        const {
+          organizations
+        } = orgResult.data;
         const orgs = [];
-        for (const org of Object.values(orgResult.data.organizations)) {
+        for (const org of Object.values(organizations)) {
           if (org) {
             orgs.push(org);
           }
         }
-        const result = await sockSdk.postSettings(orgs.map(org => ({
+        const settingsResult = await sockSdk.postSettings(orgs.map(org => ({
           organization: org.id
         })));
-        if (!result.success) {
-          throw new Error(`Failed to fetch API key settings: ${result.error.message}`);
+        if (!settingsResult.success) {
+          throw new Error(`Failed to fetch API key settings: ${settingsResult.error}`);
         }
         return {
           orgs,
-          settings: result.data
+          settings: settingsResult.data
         };
       } catch (e) {
         const cause = objects.isObject(e) && 'cause' in e ? e['cause'] : undefined;
@@ -1201,7 +1218,7 @@ async function uxLookup(settings) {
       }
     })();
     // Remove any organizations not being enforced.
-    const enforcedOrgs = getSetting('enforcedOrgs') ?? [];
+    const enforcedOrgs = getConfigValue('enforcedOrgs') ?? [];
     for (const {
       0: i,
       1: org
@@ -1255,16 +1272,15 @@ function stringJoinWithSeparateFinalSeparator(list, separator = ' and ') {
   return `${values.join(', ')}${separator}${finalValue}`;
 }
 
-let SEVERITY = /*#__PURE__*/function (SEVERITY) {
-  SEVERITY["critical"] = "critical";
-  SEVERITY["high"] = "high";
-  SEVERITY["middle"] = "middle";
-  SEVERITY["low"] = "low";
-  return SEVERITY;
+let ALERT_SEVERITY = /*#__PURE__*/function (ALERT_SEVERITY) {
+  ALERT_SEVERITY["critical"] = "critical";
+  ALERT_SEVERITY["high"] = "high";
+  ALERT_SEVERITY["middle"] = "middle";
+  ALERT_SEVERITY["low"] = "low";
+  return ALERT_SEVERITY;
 }({});
-
 // Ordered from most severe to least.
-const SEVERITIES_BY_ORDER = ['critical', 'high', 'middle', 'low'];
+const SEVERITIES_BY_ORDER = Object.freeze(['critical', 'high', 'middle', 'low']);
 function getDesiredSeverities(lowestToInclude) {
   const result = [];
   for (const severity of SEVERITIES_BY_ORDER) {
@@ -1298,8 +1314,11 @@ function getSeverityCount(issues, lowestToInclude) {
     if (!value) {
       continue;
     }
-    if (severityCount[value.severity] !== undefined) {
-      severityCount[value.severity] += 1;
+    const {
+      severity
+    } = value;
+    if (severityCount[severity] !== undefined) {
+      severityCount[severity] += 1;
     }
   }
   return severityCount;
@@ -1359,8 +1378,6 @@ function getTranslations() {
 }
 
 const {
-  ALERT_FIX_TYPE_CVE,
-  ALERT_FIX_TYPE_UPGRADE,
   CVE_ALERT_PROPS_FIRST_PATCHED_VERSION_IDENTIFIER,
   NPM: NPM$2
 } = constants;
@@ -1368,7 +1385,7 @@ const format = new ColorOrMarkdown(false);
 async function addArtifactToAlertsMap(artifact, alertsByPkgId, options) {
   // Make TypeScript happy.
   if (!artifact.name || !artifact.version || !artifact.alerts?.length) {
-    return;
+    return alertsByPkgId;
   }
   const {
     consolidate = false,
@@ -1405,10 +1422,10 @@ async function addArtifactToAlertsMap(artifact, alertsByPkgId, options) {
       }
     });
     const fixType = alert.fix?.type ?? '';
-    const critical = alert.severity === SEVERITY.critical;
+    const critical = alert.severity === ALERT_SEVERITY.critical;
     const cve = isArtifactAlertCve(alert);
-    const fixableCve = fixType === ALERT_FIX_TYPE_CVE;
-    const fixableUpgrade = fixType === ALERT_FIX_TYPE_UPGRADE;
+    const fixableCve = fixType === ALERT_FIX_TYPE.cve;
+    const fixableUpgrade = fixType === ALERT_FIX_TYPE.upgrade;
     const fixable = fixableCve || fixableUpgrade;
     const upgrade = fixableUpgrade && !objects.hasOwn(overrides, name);
     if (include.cve && cve || include.unfixable && !fixable || include.critical && critical || include.upgrade && upgrade) {
@@ -1427,7 +1444,7 @@ async function addArtifactToAlertsMap(artifact, alertsByPkgId, options) {
     }
   }
   if (!sockPkgAlerts.length) {
-    return;
+    return alertsByPkgId;
   }
   if (consolidate) {
     const highestForCve = new Map();
@@ -1436,7 +1453,7 @@ async function addArtifactToAlertsMap(artifact, alertsByPkgId, options) {
     for (const sockPkgAlert of sockPkgAlerts) {
       const alert = sockPkgAlert.raw;
       const fixType = alert.fix?.type ?? '';
-      if (fixType === ALERT_FIX_TYPE_CVE) {
+      if (fixType === ALERT_FIX_TYPE.cve) {
         const patchedVersion = alert.props[CVE_ALERT_PROPS_FIRST_PATCHED_VERSION_IDENTIFIER];
         const patchedMajor = semver.major(patchedVersion);
         const oldHighest = highestForCve.get(patchedMajor);
@@ -1447,7 +1464,7 @@ async function addArtifactToAlertsMap(artifact, alertsByPkgId, options) {
             version: patchedVersion
           });
         }
-      } else if (fixType === ALERT_FIX_TYPE_UPGRADE) {
+      } else if (fixType === ALERT_FIX_TYPE.upgrade) {
         const oldHighest = highestForUpgrade.get(major);
         const highest = oldHighest?.version ?? '0.0.0';
         if (semver.gt(version, highest)) {
@@ -1462,11 +1479,11 @@ async function addArtifactToAlertsMap(artifact, alertsByPkgId, options) {
     }
     sockPkgAlerts = [...unfixableAlerts, ...[...highestForCve.values()].map(d => d.alert), ...[...highestForUpgrade.values()].map(d => d.alert)];
   }
-  if (!sockPkgAlerts.length) {
-    return;
+  if (sockPkgAlerts.length) {
+    sockPkgAlerts.sort((a, b) => sorts.naturalCompare(a.type, b.type));
+    alertsByPkgId.set(pkgId, sockPkgAlerts);
   }
-  sockPkgAlerts.sort((a, b) => sorts.naturalCompare(a.type, b.type));
-  alertsByPkgId.set(pkgId, sockPkgAlerts);
+  return alertsByPkgId;
 }
 function getCveInfoByAlertsMap(alertsMap, options) {
   const exclude = {
@@ -1482,7 +1499,7 @@ function getCveInfoByAlertsMap(alertsMap, options) {
     const name = packages.resolvePackageName(purlObj);
     for (const sockPkgAlert of sockPkgAlerts) {
       const alert = sockPkgAlert.raw;
-      if (alert.fix?.type !== ALERT_FIX_TYPE_CVE || exclude.upgrade && registry.getManifestData(NPM$2, name)) {
+      if (alert.fix?.type !== ALERT_FIX_TYPE.cve || exclude.upgrade && registry.getManifestData(NPM$2, name)) {
         continue;
       }
       if (!infoByPkg) {
@@ -1626,7 +1643,10 @@ function getDetailsFromDiff(diff_, options) {
 }
 function getUrlOrigin(input) {
   try {
-    return URL.parse(input)?.origin ?? '';
+    // TODO: URL.parse is available in Node 22.1.0. We can use it when we drop Node 18.
+    // https://nodejs.org/docs/latest-v22.x/api/url.html#urlparseinput-base
+    // return URL.parse(input)?.origin ?? ''
+    return new URL(input).origin ?? '';
   } catch {}
   return '';
 }
@@ -1707,12 +1727,12 @@ async function getAlertsMapFromArborist(arb, options) {
       return [key, overrideSet.value];
     }));
   }
-  const socketSdk = await setupSdk(getPublicToken());
+  const sockSdk = await setupSdk(getPublicToken());
   const toAlertsMapOptions = {
     overrides,
     ...options
   };
-  for await (const batchPackageFetchResult of socketSdk.batchPackageStream({
+  for await (const batchPackageFetchResult of sockSdk.batchPackageStream({
     alerts: 'true',
     compact: 'true',
     fixable: include.unfixable ? 'false' : 'true'
@@ -1910,12 +1930,12 @@ function installSafeArborist() {
 
 installSafeArborist();
 
+exports.ALERT_SEVERITY = ALERT_SEVERITY;
 exports.Arborist = Arborist;
 exports.AuthError = AuthError;
 exports.ColorOrMarkdown = ColorOrMarkdown;
 exports.InputError = InputError;
 exports.SAFE_ARBORIST_REIFY_OPTIONS_OVERRIDES = SAFE_ARBORIST_REIFY_OPTIONS_OVERRIDES;
-exports.SEVERITY = SEVERITY;
 exports.SafeArborist = SafeArborist;
 exports.addArtifactToAlertsMap = addArtifactToAlertsMap;
 exports.captureException = captureException;
@@ -1924,18 +1944,20 @@ exports.findPackageNodes = findPackageNodes;
 exports.findUp = findUp;
 exports.formatSeverityCount = formatSeverityCount;
 exports.getAlertsMapFromArborist = getAlertsMapFromArborist;
+exports.getConfigValue = getConfigValue;
 exports.getCveInfoByAlertsMap = getCveInfoByAlertsMap;
 exports.getDefaultToken = getDefaultToken;
 exports.getPublicToken = getPublicToken;
-exports.getSetting = getSetting;
 exports.getSeverityCount = getSeverityCount;
 exports.getSocketDevAlertUrl = getSocketDevAlertUrl;
 exports.getSocketDevPackageOverviewUrl = getSocketDevPackageOverviewUrl;
 exports.readFileBinary = readFileBinary;
 exports.readFileUtf8 = readFileUtf8;
 exports.safeReadFile = safeReadFile;
+exports.sensitiveConfigKeys = sensitiveConfigKeys;
 exports.setupSdk = setupSdk;
+exports.supportedConfigKeys = supportedConfigKeys;
+exports.updateConfigValue = updateConfigValue;
 exports.updateNode = updateNode;
-exports.updateSetting = updateSetting;
-//# debugId=10ac7b59-9e2e-4a6a-88ed-ed401e2c65fd
+//# debugId=be8eae0e-badd-401f-9719-bf4c7157004d
 //# sourceMappingURL=shadow-npm-inject.js.map