token-goat 2.9.29 → 2.9.31

package/dist/token-goat-chunk-7R2ZVVAX.mjs

@@ -0,0 +1,218 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  buildLineIndex,
+  lineTextAt,
+  offsetToLine,
+  stripJsComments,
+  stripXmlComments
+} from "./token-goat-chunk-OUKDTVNU.mjs";
+import {
+  countContentLines
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import "./token-goat-chunk-GGGG7RWB.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/languages/salesforce_frontend.ts
+init_define_import_meta_env();
+import * as path from "node:path";
+function bundleName(filePath) {
+  const normalized = filePath.replaceAll("\\", "/");
+  const parent = path.posix.basename(path.posix.dirname(normalized));
+  const base = path.posix.basename(normalized).replace(/\.[^.]+$/, "");
+  return parent === "lwc" || parent === "aura" ? base : parent;
+}
+function lwcTagAlias(name) {
+  const kebab = name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1-$2").replace(/([a-z\d])([A-Z])/g, "$1-$2").toLowerCase();
+  return `c-${kebab}`;
+}
+function symbol(filePath, name, kind, lineStart, lineEnd = lineStart) {
+  return { filePath, name, kind, lineStart, lineEnd, body: "", docstring: "", parent: "" };
+}
+function ref(filePath, name, line, col, context) {
+  return { filePath, name, line, col, context };
+}
+function dedupe(values, key) {
+  const seen = /* @__PURE__ */ new Set();
+  return values.filter((value) => {
+    const id = key(value);
+    if (seen.has(id)) return false;
+    seen.add(id);
+    return true;
+  });
+}
+function extractLwcJavaScript(content, filePath) {
+  const lineIndex = buildLineIndex(content);
+  const bundle = bundleName(filePath);
+  const symbols = [
+    symbol(filePath, bundle, "lwc_bundle", 1, countContentLines(content)),
+    symbol(filePath, lwcTagAlias(bundle), "lwc_component_alias", 1, countContentLines(content))
+  ];
+  const refs = [];
+  const commentFree = stripJsComments(content);
+  const apiRe = /@api\s*(?:\r?\n\s*)?(?:(get|set)\s+)?(?:async\s+)?([A-Za-z_$][\w$]*)\s*(\()?/g;
+  for (const match of commentFree.matchAll(apiRe)) {
+    const line = offsetToLine(lineIndex, match.index ?? 0);
+    const kind = match[3] && !match[1] ? "lwc_api_method" : "lwc_api_property";
+    symbols.push(symbol(filePath, match[2] ?? "", kind, line));
+  }
+  const importRe = /from\s+['"]@salesforce\/(apex|schema|label|resourceUrl|messageChannel|customPermission|userPermission)\/([^'"]+)['"]/g;
+  for (const match of commentFree.matchAll(importRe)) {
+    const offset = match.index ?? 0;
+    const line = offsetToLine(lineIndex, offset);
+    const context = lineTextAt(content, lineIndex, line);
+    const target = match[2] ?? "";
+    const targetOffset = offset + (match[0]?.indexOf(target) ?? 0);
+    const col = targetOffset - (commentFree.lastIndexOf("\n", targetOffset) + 1);
+    if (match[1] === "apex") {
+      const className = target.split(".")[0] ?? target;
+      refs.push(ref(filePath, className, line, col, context));
+    }
+    refs.push(ref(filePath, target, line, col, context));
+  }
+  return {
+    symbols: dedupe(symbols, (entry) => `${entry.name}\0${entry.kind}\0${entry.lineStart}`),
+    refs: dedupe(refs, (entry) => `${entry.filePath}\0${entry.name}\0${entry.line}\0${entry.col}`)
+  };
+}
+function extractLwcTemplate(content, filePath) {
+  const symbols = [];
+  const refs = [];
+  const markupNoComments = stripXmlComments(content);
+  const lineIndex = buildLineIndex(content);
+  for (const match of markupNoComments.matchAll(/\blwc:ref\s*=\s*["']([^"']+)["']/gi)) {
+    const line = offsetToLine(lineIndex, match.index ?? 0);
+    symbols.push(symbol(filePath, match[1] ?? "", "lwc_ref", line));
+  }
+  for (const match of markupNoComments.matchAll(/\bid\s*=\s*["']([^"'{}:]+)["']/gi)) {
+    const line = offsetToLine(lineIndex, match.index ?? 0);
+    symbols.push(symbol(filePath, match[1] ?? "", "lwc_id", line));
+  }
+  for (const match of markupNoComments.matchAll(/\bon[a-z][\w-]*\s*=\s*\{\s*([A-Za-z_$][\w$]*)\s*\}/gi)) {
+    const offset = match.index ?? 0;
+    const line = offsetToLine(lineIndex, offset);
+    refs.push(ref(filePath, match[1] ?? "", line, 0, lineTextAt(content, lineIndex, line)));
+  }
+  for (const match of markupNoComments.matchAll(/<\s*(c-[a-z][\w-]*)\b/gi)) {
+    const offset = match.index ?? 0;
+    const line = offsetToLine(lineIndex, offset);
+    refs.push(ref(filePath, (match[1] ?? "").toLowerCase(), line, 0, lineTextAt(content, lineIndex, line)));
+  }
+  return {
+    symbols: dedupe(symbols, (entry) => `${entry.name}\0${entry.kind}\0${entry.lineStart}`),
+    refs: dedupe(refs, (entry) => `${entry.filePath}\0${entry.name}\0${entry.line}\0${entry.col}`)
+  };
+}
+var MARKUP_KIND = {
+  ".cmp": "aura_bundle",
+  ".app": "aura_application",
+  ".evt": "aura_event_bundle",
+  ".intf": "aura_interface",
+  ".design": "aura_design",
+  ".auradoc": "aura_documentation",
+  ".tokens": "aura_tokens",
+  ".page": "visualforce_page",
+  ".component": "visualforce_component",
+  ".email": "visualforce_email_template"
+};
+function markupArtifactName(filePath, extension) {
+  if (extension === ".page" || extension === ".component" || extension === ".email") {
+    return path.posix.basename(filePath.replaceAll("\\", "/")).replace(new RegExp(`${extension.replace(".", "\\.")}$`, "i"), "");
+  }
+  return bundleName(filePath);
+}
+function addAttributeSymbols(symbols, content, lineIndex, filePath, tag, kind) {
+  scanAttributeTags(content, tag, (name, index) => symbols.push(symbol(filePath, name, kind, offsetToLine(lineIndex, index))));
+}
+function scanAttributeTags(content, tag, onName) {
+  const tagStart = new RegExp(`<\\s*${tag}\\b`, "gi");
+  let work = 0;
+  for (let found = tagStart.exec(content); found !== null; found = tagStart.exec(content)) {
+    const scanned = scanTagForName(content, tagStart.lastIndex);
+    work += scanned.scanned;
+    if (scanned.end < 0) break;
+    if (scanned.name !== void 0) onName(scanned.name, found.index);
+    tagStart.lastIndex = scanned.end + 1;
+  }
+  return work;
+}
+var AURA_NAME_TAGS = [
+  ["aura:attribute", "aura_attribute"],
+  ["aura:handler", "aura_handler"],
+  ["aura:registerEvent", "aura_event"],
+  ["design:attribute", "aura_design_attribute"]
+];
+function attributeScanWork(content) {
+  const text = stripXmlComments(content);
+  return AURA_NAME_TAGS.reduce((sum, [tag]) => sum + scanAttributeTags(text, tag, () => void 0), 0);
+}
+var NAME_ATTRIBUTE = /name\s*=\s*["']([^"']+)["']/iy;
+function scanTagForName(content, from) {
+  let name;
+  let searched = 0;
+  const unpaired = {};
+  for (let i = from; i < content.length; i++) {
+    const ch = content[i] ?? "";
+    if (ch === ">") return { name, end: i, scanned: i - from + searched };
+    if (ch === '"' || ch === "'") {
+      const close = unpaired[ch] ? -1 : content.indexOf(ch, i + 1);
+      if (close < 0) {
+        if (!unpaired[ch]) searched += content.length - i - 1;
+        unpaired[ch] = true;
+      } else i = close;
+    } else if ((ch === "n" || ch === "N") && !/\w/.test(content[i - 1] ?? "")) {
+      NAME_ATTRIBUTE.lastIndex = i;
+      name = NAME_ATTRIBUTE.exec(content)?.[1] ?? name;
+    }
+  }
+  return { name, end: -1, scanned: content.length - from + searched };
+}
+function attributeRefs(refs, content, lineIndex, filePath, attribute, split = false) {
+  const attributeRe = new RegExp(`\\b${attribute}\\s*=\\s*["']([^"']+)["']`, "gi");
+  for (const match of content.matchAll(attributeRe)) {
+    const line = offsetToLine(lineIndex, match.index ?? 0);
+    const values = split ? (match[1] ?? "").split(",").map((value) => value.trim()).filter(Boolean) : [match[1] ?? ""];
+    for (const value of values) refs.push(ref(filePath, value, line, 0, lineTextAt(content, lineIndex, line)));
+  }
+}
+function extractSalesforceMarkup(content, filePath) {
+  const normalized = filePath.replaceAll("\\", "/");
+  const extension = path.posix.extname(normalized).toLowerCase();
+  const kind = MARKUP_KIND[extension] ?? "salesforce_markup";
+  const symbols = [
+    symbol(filePath, markupArtifactName(normalized, extension), kind, 1, countContentLines(content))
+  ];
+  const refs = [];
+  const isAura = [".cmp", ".app", ".evt", ".intf", ".design", ".auradoc", ".tokens"].includes(extension);
+  const markupNoComments = stripXmlComments(content);
+  const lineIndex = buildLineIndex(content);
+  if (isAura) {
+    for (const [tag, tagKind] of AURA_NAME_TAGS) addAttributeSymbols(symbols, markupNoComments, lineIndex, filePath, tag, tagKind);
+  }
+  attributeRefs(refs, markupNoComments, lineIndex, filePath, "controller");
+  attributeRefs(refs, markupNoComments, lineIndex, filePath, "extensions", true);
+  const actionRe = isAura ? /\{!\s*c\.([A-Za-z_$][\w$]*)(?:[^}\w$][^}]*)?\}/gi : /\baction\s*=\s*["']\{!\s*(?:c\.)?([A-Za-z_$][\w$]*)(?:[^}\w$][^}]*)?\}["']/gi;
+  for (const match of markupNoComments.matchAll(actionRe)) {
+    const line = offsetToLine(lineIndex, match.index ?? 0);
+    refs.push(ref(filePath, match[1] ?? "", line, 0, lineTextAt(content, lineIndex, line)));
+  }
+  for (const match of markupNoComments.matchAll(/\bc:[A-Za-z_$][\w$]*/g)) {
+    const line = offsetToLine(lineIndex, match.index ?? 0);
+    refs.push(ref(filePath, match[0], line, 0, lineTextAt(content, lineIndex, line)));
+  }
+  return {
+    symbols: dedupe(symbols, (entry) => `${entry.name}\0${entry.kind}\0${entry.lineStart}`),
+    refs: dedupe(refs, (entry) => `${entry.filePath}\0${entry.name}\0${entry.line}\0${entry.col}`)
+  };
+}
+export {
+  attributeScanWork,
+  extractLwcJavaScript,
+  extractLwcTemplate,
+  extractSalesforceMarkup
+};

package/dist/{token-goat-chunk-TCQANXYC.mjs → token-goat-chunk-AM5V6GSX.mjs}

@@ -7,7 +7,7 @@ import {
   isUncOrDevicePath,
   lowercaseDriveLetter,
   normalizeDarwinSystemAlias
-} from "./token-goat-chunk-NMTKNYGF.mjs";
+} from "./token-goat-chunk-FNFBKLRD.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -209,6 +209,7 @@ function sameDirectory(a, b, platform = process.platform) {
 
 // src/process_util.ts
 init_define_import_meta_env();
+import { spawnSync } from "node:child_process";
 import { existsSync, realpathSync as realpathSync2, statSync } from "node:fs";
 import * as path2 from "node:path";
 function sleepSync(ms) {
@@ -283,9 +284,16 @@ function quoteShellPath(value) {
   if (process.platform === "win32") return `"${value}"`;
   return `"${value.replace(/[\\$`"]/g, "\\$&")}"`;
 }
+function quotePosixShellWord(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
 function quotePowershellPath(value) {
   return `'${value.replace(/'/g, "''")}'`;
 }
+var POWERSHELL_EXIT_SUFFIX = "; if (Get-Variable LASTEXITCODE -ErrorAction Ignore) { exit (Get-Variable LASTEXITCODE -ValueOnly) }; exit 1";
+function powershellHookLine(call) {
+  return `& ${call}${POWERSHELL_EXIT_SUFFIX}`;
+}
 function resolveOnPath(label) {
   if (path2.isAbsolute(label)) return existsSync(label) ? label : null;
   if (label.includes("/") || label.includes("\\")) return null;
@@ -317,6 +325,12 @@ function resolveOnPath(label) {
   }
   return null;
 }
+function spawnResolvedSync(resolved, args, options) {
+  if (!isWindows() || !/\.(?:cmd|bat)$/i.test(resolved)) return spawnSync(resolved, args, options);
+  const comspec = path2.join(process.env["SystemRoot"] ?? process.env["windir"] ?? "C:\\Windows", "System32", "cmd.exe");
+  const line = [resolved, ...args].map(windowsCmdQuoteArg).join(" ");
+  return spawnSync(existsSync(comspec) ? comspec : "cmd.exe", ["/d", "/s", "/c", `"${line}"`], { ...options, windowsVerbatimArguments: true });
+}
 function installEpipeGuard(streams) {
   const targets = (streams ?? [process.stdout, process.stderr]).filter((s) => s !== void 0);
   for (const stream of targets) {
@@ -343,9 +357,11 @@ export {
   isInsideRoot,
   sleepSync,
   isWindows,
-  windowsCmdQuoteArg,
   quoteShellPath,
+  quotePosixShellWord,
   quotePowershellPath,
+  powershellHookLine,
   resolveOnPath,
+  spawnResolvedSync,
   installEpipeGuard
 };

package/dist/token-goat-chunk-AUNGYYQX.mjs

@@ -0,0 +1,184 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  DownloadCooldownError,
+  DownloadFailedError,
+  activeDownloadCooldown,
+  clearDownloadFailure,
+  describeCause,
+  isExplicitDownload,
+  recordDownloadFailure
+} from "./token-goat-chunk-2UPZGKKY.mjs";
+import {
+  loadConfig
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/pinned_fetch.ts
+init_define_import_meta_env();
+import { createHash } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pipeline } from "node:stream/promises";
+var ATTEMPTS = 3;
+var retryDelayMs = 250;
+function setPinnedRetryDelayForTesting(ms) {
+  retryDelayMs = ms ?? 250;
+}
+var DETERMINISTIC_CODE = /^(?:ENOTFOUND|EAI_NONAME|ERR_INVALID_URL|ERR_TLS_|ERR_SSL_|CERT_|DEPTH_ZERO_SELF_SIGNED_CERT$|SELF_SIGNED_CERT_IN_CHAIN$|UNABLE_TO_)/;
+function causeCodes(e) {
+  const codes = [];
+  let cursor = e;
+  for (let depth = 0; cursor !== null && typeof cursor === "object" && depth < 5; depth++) {
+    const code = cursor.code;
+    if (typeof code === "string") codes.push(code);
+    cursor = cursor.cause;
+  }
+  return codes;
+}
+function transient(e) {
+  if (e instanceof TypeError) return !causeCodes(e).some((code) => DETERMINISTIC_CODE.test(code)) && !/ENOTFOUND/.test(describeCause(e));
+  return e instanceof Error && (e.name === "TimeoutError" || e.name === "AbortError");
+}
+var HostFailure = class extends Error {
+  retry;
+  constructor(message, retry, cause) {
+    super(message, cause === void 0 ? void 0 : { cause });
+    this.retry = retry;
+  }
+};
+function failure(url, message, cause, startedAt) {
+  let at = Date.now();
+  try {
+    at = recordDownloadFailure(url, message, at, startedAt).at;
+  } catch {
+  }
+  return new DownloadFailedError(message, url, at, cause);
+}
+function forgetFailure(url) {
+  try {
+    clearDownloadFailure(url);
+  } catch {
+  }
+}
+async function fetchOk(url) {
+  let response;
+  try {
+    response = await fetch(url, { redirect: "follow" });
+  } catch (e) {
+    throw new HostFailure(`GET ${url} failed: ${describeCause(e)}`, transient(e), e);
+  }
+  if (response.ok) return response;
+  await response.body?.cancel().catch(() => void 0);
+  throw new HostFailure(`GET ${url} returned ${response.status} ${response.statusText}`, response.status >= 500 || response.status === 429);
+}
+async function* bodyChunks(url, body, expected) {
+  let received = 0;
+  try {
+    for await (const chunk of body) {
+      received += chunk.byteLength;
+      yield chunk;
+    }
+  } catch (e) {
+    throw new HostFailure(`GET ${url} broke off after ${received} of ${expected} bytes: ${describeCause(e)}`, transient(e), e);
+  }
+}
+function sha256Of(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = fs.createReadStream(filePath);
+    stream.on("error", reject);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+async function copyFromSharedCache(shared, file, target) {
+  const source = path.join(shared, file.name);
+  const temp = `${target}.${process.pid}.shared`;
+  try {
+    const info = fs.lstatSync(source, { throwIfNoEntry: false });
+    if (!info?.isFile() || info.size !== file.bytes) return false;
+    fs.copyFileSync(source, temp);
+    if (await sha256Of(temp) !== file.sha256) {
+      fs.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+      fs.rmSync(source, { force: true, maxRetries: 20, retryDelay: 25 });
+      return false;
+    }
+    fs.renameSync(temp, target);
+    return true;
+  } catch {
+    try {
+      fs.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+    } catch {
+    }
+    return false;
+  }
+}
+async function downloadPinned(url, file, target) {
+  if (loadConfig().network.offline) throw new Error(`Offline mode is on (network.offline): refusing to download ${url}`);
+  if (!isExplicitDownload()) {
+    const cooldown = activeDownloadCooldown(url);
+    if (cooldown) throw new DownloadCooldownError(url, cooldown);
+  }
+  const startedAt = Date.now();
+  for (let attempt = 1; ; attempt++) {
+    try {
+      await fetchAndPlace(url, file, target);
+      forgetFailure(url);
+      return;
+    } catch (e) {
+      if (!(e instanceof HostFailure)) throw e;
+      if (attempt < ATTEMPTS && e.retry) {
+        await new Promise((resolve) => setTimeout(resolve, retryDelayMs * attempt));
+        continue;
+      }
+      throw failure(url, e.message, e.cause, startedAt);
+    }
+  }
+}
+async function fetchAndPlace(url, file, target) {
+  const response = await fetchOk(url);
+  const body = response.body;
+  if (!body) throw new Error(`GET ${url} returned no body`);
+  const temp = `${target}.${process.pid}.partial`;
+  const hash = createHash("sha256");
+  let written = 0;
+  const out = fs.createWriteStream(temp);
+  try {
+    await pipeline(async function* () {
+      for await (const chunk of bodyChunks(url, body, file.bytes)) {
+        written += chunk.byteLength;
+        if (written > file.bytes) throw new Error(`${file.name} is longer than the pinned ${file.bytes} bytes`);
+        hash.update(chunk);
+        yield chunk;
+      }
+    }, out);
+    if (written !== file.bytes) {
+      throw new Error(`${file.name} is ${written} bytes, expected the pinned ${file.bytes}`);
+    }
+    const digest = hash.digest("hex");
+    if (digest !== file.sha256) {
+      throw new Error(`${file.name} has sha256 ${digest}, expected the pinned ${file.sha256}`);
+    }
+    fs.renameSync(temp, target);
+  } catch (e) {
+    await new Promise((resolve) => {
+      if (out.closed) resolve();
+      else out.once("close", () => resolve());
+    });
+    try {
+      fs.rmSync(temp, { force: true, maxRetries: 20, retryDelay: 25 });
+    } catch {
+    }
+    throw e;
+  }
+}
+
+export {
+  setPinnedRetryDelayForTesting,
+  sha256Of,
+  copyFromSharedCache,
+  downloadPinned
+};