@duckmind/dm-linux-x64 0.66.0 → 0.66.2

package/extensions/dm-lens/dist/clients/path-keyed-map.js

@@ -1,57 +0,0 @@
-import { BoundedFifoMap } from "./bounded-cache.js";
-
-export class PathKeyedMap {
-  normalize;
-  store;
-  constructor(normalize, maxEntries) {
-    this.normalize = normalize;
-    this.store = maxEntries === undefined ? new Map : new BoundedFifoMap(maxEntries);
-  }
-  get size() {
-    return this.store.size;
-  }
-  get(path) {
-    return this.store.get(this.normalize(path))?.value;
-  }
-  has(path) {
-    return this.store.has(this.normalize(path));
-  }
-  set(path, value) {
-    this.store.set(this.normalize(path), { displayPath: path, value });
-    return this;
-  }
-  delete(path) {
-    if (this.store.delete(this.normalize(path)))
-      return true;
-    for (const [key, entry] of this.store) {
-      if (entry.displayPath !== path)
-        continue;
-      this.store.delete(key);
-      return true;
-    }
-    return false;
-  }
-  clear() {
-    this.store.clear();
-  }
-  *keys() {
-    for (const entry of this.store.values())
-      yield entry.displayPath;
-  }
-  *values() {
-    for (const entry of this.store.values())
-      yield entry.value;
-  }
-  *entries() {
-    for (const entry of this.store.values())
-      yield [entry.displayPath, entry.value];
-  }
-  forEach(callback) {
-    for (const entry of this.store.values()) {
-      callback(entry.value, entry.displayPath, this);
-    }
-  }
-  [Symbol.iterator]() {
-    return this.entries();
-  }
-}

package/extensions/dm-lens/dist/clients/path-utils.js

@@ -1,476 +0,0 @@
-import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { win32 } from "node:path";
-import { fileURLToPath, pathToFileURL } from "node:url";
-import { minimatch } from "./deps/minimatch.js";
-export function isWindowsPath(filePath) {
-  return /^[A-Za-z]:/.test(filePath) || filePath.startsWith("\\");
-}
-export function toPosix(filePath) {
-  return filePath.replace(/\\/g, "/");
-}
-export function isFullyQualifiedWin32(filePath) {
-  return win32.isAbsolute(filePath) && win32.parse(filePath).root.length > 1;
-}
-export function isFullyQualifiedPosix(filePath) {
-  return path.posix.isAbsolute(filePath) && !isWindowsPath(filePath);
-}
-export function isFullyQualified(filePath) {
-  return process.platform === "win32" ? isFullyQualifiedWin32(filePath) : isFullyQualifiedPosix(filePath);
-}
-export function isAbsoluteFilePath(filePath) {
-  const p = isWindowsPath(filePath) ? win32 : path;
-  return p.isAbsolute(filePath);
-}
-export function splitPathSegments(filePath) {
-  return filePath.split(/[\\/]+/).filter(Boolean);
-}
-function adoptCanonicalCasing(held, canonical) {
-  const heldParts = held.split("/");
-  const realParts = canonical.split("/");
-  let i = heldParts.length - 1;
-  let j = realParts.length - 1;
-  let changed = false;
-  while (i >= 0 && j >= 0) {
-    const a = heldParts[i];
-    const b = realParts[j];
-    if (a !== b) {
-      if (a.toLowerCase() !== b.toLowerCase())
-        break;
-      heldParts[i] = b;
-      changed = true;
-    }
-    i--;
-    j--;
-  }
-  return changed ? heldParts.join("/") : held;
-}
-export function normalizeFilePath(filePath) {
-  const normalized = filePath.replace(/\\/g, "/");
-  if (process.platform !== "win32" && !isWindowsPath(normalized)) {
-    const folded = normalized === "" || normalized.startsWith("//") ? normalized : path.posix.normalize(normalized);
-    try {
-      const canonical = realpathSync.native(folded);
-      if (canonical === folded)
-        return folded;
-      const adopted = adoptCanonicalCasing(folded, canonical);
-      if (adopted === folded)
-        return folded;
-      return realpathSync.native(adopted) === canonical ? adopted : folded;
-    } catch {
-      return folded;
-    }
-  }
-  try {
-    const canonical = realpathSync.native(filePath);
-    return canonical.replace(/\\/g, "/");
-  } catch {
-    try {
-      return resolveNonExisting(filePath);
-    } catch {
-      const resolved = win32.normalize(win32.resolve(filePath));
-      return resolved.replace(/\\/g, "/").toLowerCase();
-    }
-  }
-}
-export function realpathOrResolve(filePath) {
-  const resolved = path.resolve(filePath);
-  try {
-    return realpathSync(resolved);
-  } catch {
-    return resolved;
-  }
-}
-export function normalizeLoggedPath(value) {
-  return isFullyQualifiedWin32(value) || isFullyQualifiedPosix(value) ? normalizeFilePath(value) : value;
-}
-function resolveNonExisting(filePath) {
-  const resolved = win32.resolve(filePath);
-  let current = resolved;
-  const nonExistentParts = [];
-  while (true) {
-    if (existsSync(current)) {
-      const canonical = realpathSync.native(current);
-      if (nonExistentParts.length === 0) {
-        return canonical.replace(/\\/g, "/");
-      }
-      const tail = nonExistentParts.reverse().join("/").toLowerCase();
-      const base = canonical.replace(/\\/g, "/");
-      return base.endsWith("/") ? base + tail : `${base}/${tail}`;
-    }
-    const parent = win32.dirname(current);
-    if (parent === current) {
-      throw new Error("No existing parent found");
-    }
-    nonExistentParts.push(win32.basename(current));
-    current = parent;
-  }
-}
-export function uriToPath(uri) {
-  try {
-    const filePath = fileURLToPath(uri);
-    return normalizeFilePath(filePath);
-  } catch {
-    return normalizeFilePath(uri);
-  }
-}
-export function uriToDiskPath(uri) {
-  try {
-    return fileURLToPath(uri);
-  } catch {
-    return uri;
-  }
-}
-export function pathToUri(filePath) {
-  return pathToFileURL(filePath).href;
-}
-export function normalizeMapKey(filePath) {
-  return normalizeFilePath(filePath);
-}
-export function toProjectRelativePath(filePath, projectRoot) {
-  const p = isWindowsPath(filePath) ? win32 : path;
-  if (!p.isAbsolute(filePath))
-    return filePath.replace(/\\/g, "/");
-  const relative = p.relative(p.resolve(projectRoot), filePath);
-  return relative && !relative.startsWith("..") && !p.isAbsolute(relative) ? relative.replace(/\\/g, "/") : filePath.replace(/\\/g, "/");
-}
-export function normalizeEphemeralMapKey(filePath) {
-  if (process.platform !== "win32" && !filePath.includes("\\"))
-    return filePath;
-  const slashed = filePath.replace(/\\/g, "/");
-  return process.platform === "win32" ? slashed.toLowerCase() : slashed;
-}
-export function pathsEqual(a, b) {
-  return normalizeFilePath(a) === normalizeFilePath(b);
-}
-export function* walkUpDirs(startDir) {
-  let current = path.resolve(startDir);
-  while (true) {
-    yield current;
-    const parent = path.dirname(current);
-    if (parent === current)
-      return;
-    current = parent;
-  }
-}
-export function findNearestContaining(startDir, candidates) {
-  for (const dir of walkUpDirs(startDir)) {
-    for (const name of candidates) {
-      if (existsSync(path.join(dir, name)))
-        return dir;
-    }
-  }
-  return;
-}
-export function findLocalToolConfig(startDir, names, options = {}) {
-  const homeDir = options.homeDir !== undefined ? path.resolve(options.homeDir) : undefined;
-  for (const dir of walkUpDirs(startDir || process.cwd())) {
-    if (homeDir !== undefined && isAtOrAboveHomeDir(dir, homeDir)) {
-      return;
-    }
-    for (const name of names) {
-      const candidate = path.join(dir, name);
-      if (existsSync(candidate))
-        return candidate;
-    }
-  }
-  return;
-}
-export function isRealGitMarker(markerPath) {
-  try {
-    const marker = statSync(markerPath);
-    if (marker.isDirectory())
-      return existsSync(path.join(markerPath, "HEAD"));
-    if (!marker.isFile())
-      return false;
-    return readFileSync(markerPath, "utf8").split(/\r?\n/, 1)[0].startsWith("gitdir:");
-  } catch {
-    return false;
-  }
-}
-export function findNearestMarkerRoot(startDir, markers, options = {}) {
-  const boundaries = options.boundaries ?? [];
-  const homeDir = path.resolve(options.homeDir ?? os.homedir());
-  const markerPredicate = options.markerPredicate ?? (() => true);
-  let current = path.resolve(startDir);
-  for (let depth = 0;depth < 64; depth++) {
-    if (isAtOrAboveHomeDir(current, homeDir))
-      return null;
-    if (markers.some((m) => existsSync(path.join(current, m)) && markerPredicate(path.join(current, m))))
-      return current;
-    if (boundaries.some((m) => existsSync(path.join(current, m))))
-      return null;
-    const parent = path.dirname(current);
-    if (parent === current)
-      return null;
-    current = parent;
-  }
-  return null;
-}
-export function isAtOrAboveHomeDir(dir, homeDir = os.homedir(), pathImpl = path) {
-  const rel = pathImpl.relative(pathImpl.resolve(dir), pathImpl.resolve(homeDir));
-  return !rel.startsWith("..") && !pathImpl.isAbsolute(rel);
-}
-export function homeRelativePath(filePath, homeDir = os.homedir()) {
-  if (filePath.length === 0)
-    return filePath;
-  const candidate = toPosix(filePath);
-  const home = toPosix(homeDir).replace(/\/+$/, "");
-  if (home.length === 0)
-    return filePath;
-  const fold = (text) => process.platform === "win32" ? text.toLowerCase() : text;
-  const foldedHome = fold(home);
-  const foldedCandidate = fold(candidate);
-  if (foldedCandidate === foldedHome)
-    return "~";
-  if (!foldedCandidate.startsWith(`${foldedHome}/`))
-    return filePath;
-  return `~${candidate.slice(home.length)}`;
-}
-export function isUnderDir(child, parent) {
-  const normChild = normalizeFilePath(child);
-  const normParent = normalizeFilePath(parent);
-  const parentPrefix = normParent.endsWith("/") ? normParent : `${normParent}/`;
-  return normChild === normParent || normChild.startsWith(parentPrefix);
-}
-const VENDOR_DIR_NAMES = new Set([
-  "node_modules",
-  "vendor",
-  "vendors",
-  "third_party",
-  "third-party"
-]);
-export function isExternalOrVendorFile(filePath, projectRoot) {
-  if (!isUnderDir(filePath, projectRoot))
-    return true;
-  const normalized = normalizeFilePath(filePath);
-  const rootNorm = normalizeFilePath(projectRoot);
-  const rel = normalized.startsWith(rootNorm + "/") ? normalized.slice(rootNorm.length + 1) : normalized;
-  return rel.split("/").some((seg) => VENDOR_DIR_NAMES.has(seg));
-}
-export function nameMatchesMarkerGlob(name, pattern) {
-  return minimatch(name, pattern, {
-    dot: true,
-    nocase: process.platform === "win32"
-  });
-}
-export function direntsHaveMarkerGlobMatch(entries, pattern) {
-  return entries.some((entry) => (entry.isFile() || entry.isSymbolicLink()) && nameMatchesMarkerGlob(entry.name, pattern));
-}
-export const CARGO_WORKSPACE_MEMBER_DIALECT = {
-  name: "cargo",
-  globstar: "pattern-never-matches",
-  wildcardCrossesSeparator: false,
-  characterClasses: false,
-  normalizePattern: (pattern) => pattern.replace(/\/+$/, "")
-};
-export const UV_WORKSPACE_MEMBERS_DIALECT = {
-  name: "uv-members",
-  globstar: "crosses-components",
-  wildcardCrossesSeparator: false,
-  characterClasses: true,
-  normalizePattern: (pattern) => path.posix.normalize(toPosix(pattern))
-};
-export const UV_WORKSPACE_EXCLUDE_DIALECT = {
-  name: "uv-exclude",
-  globstar: "crosses-components",
-  wildcardCrossesSeparator: true,
-  characterClasses: true,
-  normalizePattern: (pattern) => path.posix.normalize(toPosix(pattern))
-};
-function findCharacterClassEnd(segment, open) {
-  let i = open + 1;
-  if (segment[i] === "!" || segment[i] === "^")
-    i += 1;
-  if (segment[i] === "]")
-    i += 1;
-  for (;i < segment.length; i += 1)
-    if (segment[i] === "]")
-      return i;
-  return -1;
-}
-function stepAcceptsChar(crossesSeparator, ch) {
-  return crossesSeparator ? ch !== `
-` && ch !== "\r" && ch !== "\u2028" && ch !== "\u2029" : ch !== "/";
-}
-function compileWorkspaceMemberPattern(pattern, dialect) {
-  const isGlobstar = (component) => component === "**" && dialect.globstar === "crosses-components";
-  const components = pattern.split("/");
-  const steps = [];
-  let needSeparator = false;
-  for (let c = 0;c < components.length; c += 1) {
-    if (needSeparator)
-      steps.push({ kind: "literal", char: "/" });
-    needSeparator = false;
-    const component = components[c];
-    if (isGlobstar(component)) {
-      if (c === components.length - 1) {
-        steps.push({ kind: "one", crossesSeparator: true });
-        steps.push({ kind: "star", crossesSeparator: true });
-        continue;
-      }
-      const split = { kind: "split", alternative: -1 };
-      steps.push(split);
-      steps.push({ kind: "one", crossesSeparator: true });
-      steps.push({ kind: "star", crossesSeparator: true });
-      steps.push({ kind: "literal", char: "/" });
-      split.alternative = steps.length;
-      continue;
-    }
-    for (let i = 0;i < component.length; i += 1) {
-      const ch = component[i];
-      if (ch === "*") {
-        steps.push({
-          kind: "star",
-          crossesSeparator: dialect.wildcardCrossesSeparator
-        });
-        continue;
-      }
-      if (ch === "?") {
-        steps.push({
-          kind: "one",
-          crossesSeparator: dialect.wildcardCrossesSeparator
-        });
-        continue;
-      }
-      if (ch === "[" && dialect.characterClasses) {
-        const close = findCharacterClassEnd(component, i);
-        if (close !== -1) {
-          const body = component.slice(i + 1, close).replace(/[\\\]]/g, "\\$&");
-          const source = body.startsWith("!") ? `[^${body.slice(1)}]` : `[${body}]`;
-          let match;
-          try {
-            match = new RegExp(`^${source}$`);
-          } catch {
-            return;
-          }
-          steps.push({ kind: "class", match });
-          i = close;
-          continue;
-        }
-      }
-      steps.push({ kind: "literal", char: ch });
-    }
-    needSeparator = true;
-  }
-  return steps;
-}
-function matchesWorkspaceMemberSteps(steps, subject) {
-  const stepCount = steps.length;
-  const width = subject.length + 1;
-  const table = new Uint8Array((stepCount + 1) * width);
-  for (let p = subject.length;p >= 0; p -= 1) {
-    const atEnd = p === subject.length;
-    table[stepCount * width + p] = atEnd ? 1 : 0;
-    for (let s = stepCount - 1;s >= 0; s -= 1) {
-      const step = steps[s];
-      const next = (s + 1) * width;
-      let matched = 0;
-      switch (step.kind) {
-        case "literal":
-          matched = !atEnd && subject[p] === step.char ? table[next + p + 1] : 0;
-          break;
-        case "one":
-          matched = !atEnd && stepAcceptsChar(step.crossesSeparator, subject[p]) ? table[next + p + 1] : 0;
-          break;
-        case "class":
-          matched = !atEnd && step.match.test(subject[p]) ? table[next + p + 1] : 0;
-          break;
-        case "star":
-          matched = table[next + p] === 1 || !atEnd && stepAcceptsChar(step.crossesSeparator, subject[p]) && table[s * width + p + 1] === 1 ? 1 : 0;
-          break;
-        case "split":
-          matched = table[step.alternative * width + p] === 1 || table[next + p] === 1 ? 1 : 0;
-          break;
-      }
-      table[s * width + p] = matched;
-    }
-  }
-  return table[0] === 1;
-}
-export function matchesWorkspaceMemberPattern(pattern, relativePath, dialect) {
-  const normalized = dialect.normalizePattern(pattern);
-  if (dialect.globstar === "pattern-never-matches" && normalized.includes("**")) {
-    return false;
-  }
-  const steps = compileWorkspaceMemberPattern(normalized, dialect);
-  return steps !== undefined && matchesWorkspaceMemberSteps(steps, relativePath);
-}
-const NARROW_NO_BREAK_SPACE = " ";
-const RIGHT_SINGLE_QUOTE = "’";
-const HOST_UNICODE_SPACES = /[\u00A0\u2000-\u200A\u202F\u205F\u3000]/g;
-function hostNormalizeWindowsShellPath(filePath) {
-  if (!filePath.startsWith("/") || filePath.startsWith("//") || filePath.includes("\\")) {
-    return filePath;
-  }
-  const match = filePath.match(/^\/(?:mnt\/|cygdrive\/)?([a-z])(?:\/(.*))?$/i);
-  if (!match)
-    return filePath;
-  const suffix = match[2]?.replaceAll("/", "\\");
-  return `${match[1].toUpperCase()}:\\${suffix ?? ""}`;
-}
-export function normalizeHostToolPath(input, options = {}) {
-  let normalized = input;
-  if (options.normalizeUnicodeSpaces) {
-    normalized = normalized.replace(HOST_UNICODE_SPACES, " ");
-  }
-  if (options.stripAtPrefix && normalized.startsWith("@")) {
-    normalized = normalized.slice(1);
-  }
-  if (process.platform === "win32") {
-    normalized = hostNormalizeWindowsShellPath(normalized);
-  }
-  if (normalized === "~")
-    return os.homedir();
-  if (normalized.startsWith("~/") || process.platform === "win32" && normalized.startsWith("~\\")) {
-    return path.join(os.homedir(), normalized.slice(2));
-  }
-  if (normalized.startsWith("file://")) {
-    try {
-      return fileURLToPath(normalized);
-    } catch {
-      return normalized;
-    }
-  }
-  return normalized;
-}
-export function resolveHostToolPath(input, baseDir) {
-  const normalized = normalizeHostToolPath(input, {
-    normalizeUnicodeSpaces: true,
-    stripAtPrefix: true
-  });
-  const normalizedBaseDir = normalizeHostToolPath(baseDir);
-  return path.isAbsolute(normalized) ? path.resolve(normalized) : path.resolve(normalizedBaseDir, normalized);
-}
-export function resolveHostPathVariants(resolvedPath, fileExists = existsSync) {
-  if (fileExists(resolvedPath)) {
-    return { path: resolvedPath, unresolved: false, triedVariants: [] };
-  }
-  const nfd = resolvedPath.normalize("NFD");
-  const candidates = [
-    {
-      variant: "narrow-nbsp",
-      candidate: resolvedPath.replace(/ (AM|PM)\./gi, `${NARROW_NO_BREAK_SPACE}$1.`)
-    },
-    { variant: "nfd", candidate: nfd },
-    {
-      variant: "curly-quote",
-      candidate: resolvedPath.replaceAll("'", RIGHT_SINGLE_QUOTE)
-    },
-    {
-      variant: "nfd-curly-quote",
-      candidate: nfd.replaceAll("'", RIGHT_SINGLE_QUOTE)
-    }
-  ];
-  const triedVariants = [];
-  for (const { variant, candidate } of candidates) {
-    if (candidate === resolvedPath)
-      continue;
-    triedVariants.push(variant);
-    if (fileExists(candidate)) {
-      return { path: candidate, variant, unresolved: false, triedVariants };
-    }
-  }
-  return { path: resolvedPath, unresolved: true, triedVariants };
-}