@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/grammar-source.js

@@ -1,224 +0,0 @@
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { writeFileAtomic } from "./atomic-write.js";
-import { recordDegradationOnce } from "./degradation-ledger.js";
-import { getPackageRoot } from "./package-root.js";
-export const TREE_SITTER_WASMS_VERSION = "0.1.13";
-const GRAMMAR_CDN_BASE = `https://unpkg.com/tree-sitter-wasms@${TREE_SITTER_WASMS_VERSION}/out`;
-export const GRAMMAR_SOURCE_OVERRIDES = {
-  "tree-sitter-lua.wasm": {
-    package: "@tree-sitter-grammars/tree-sitter-lua",
-    version: "0.4.1",
-    url: "https://unpkg.com/@tree-sitter-grammars/tree-sitter-lua@0.4.1/tree-sitter-lua.wasm"
-  },
-  "tree-sitter-yaml.wasm": {
-    package: "@tree-sitter-grammars/tree-sitter-yaml",
-    version: "0.7.1",
-    url: "https://unpkg.com/@tree-sitter-grammars/tree-sitter-yaml@0.7.1/tree-sitter-yaml.wasm"
-  }
-};
-export function grammarSourceUrl(filename) {
-  return GRAMMAR_SOURCE_OVERRIDES[filename]?.url ?? `${GRAMMAR_CDN_BASE}/${filename}`;
-}
-export const VENDORED_GRAMMARS = {
-  "tree-sitter-cue.wasm": {
-    repo: "https://github.com/eonpatapon/tree-sitter-cue",
-    commit: "dd7b90e0770ff18070c515937ba3c3d6d93db00e",
-    license: "MIT",
-    buildCommand: "npx tree-sitter-cli build --wasm"
-  }
-};
-export function isVendoredGrammar(filename) {
-  return Object.hasOwn(VENDORED_GRAMMARS, filename);
-}
-export function vendoredGrammarRefusal(filename) {
-  return {
-    ok: false,
-    retryable: false,
-    reason: `${filename} is built in-house and ships in vendor/grammars/; it has no ` + `download source, so a missing copy means the install is incomplete.`
-  };
-}
-export function vendoredGrammarsDir() {
-  return path.join(getPackageRoot(import.meta.url), "vendor", "grammars");
-}
-export const LANGUAGE_TO_GRAMMAR = {
-  typescript: "tree-sitter-typescript.wasm",
-  tsx: "tree-sitter-tsx.wasm",
-  javascript: "tree-sitter-javascript.wasm",
-  python: "tree-sitter-python.wasm",
-  rust: "tree-sitter-rust.wasm",
-  go: "tree-sitter-go.wasm",
-  java: "tree-sitter-java.wasm",
-  kotlin: "tree-sitter-kotlin.wasm",
-  dart: "tree-sitter-dart.wasm",
-  c: "tree-sitter-c.wasm",
-  cpp: "tree-sitter-cpp.wasm",
-  elixir: "tree-sitter-elixir.wasm",
-  ruby: "tree-sitter-ruby.wasm",
-  bash: "tree-sitter-bash.wasm",
-  csharp: "tree-sitter-c_sharp.wasm",
-  css: "tree-sitter-css.wasm",
-  html: "tree-sitter-html.wasm",
-  json: "tree-sitter-json.wasm",
-  lua: "tree-sitter-lua.wasm",
-  ocaml: "tree-sitter-ocaml.wasm",
-  php: "tree-sitter-php.wasm",
-  swift: "tree-sitter-swift.wasm",
-  toml: "tree-sitter-toml.wasm",
-  vue: "tree-sitter-vue.wasm",
-  yaml: "tree-sitter-yaml.wasm",
-  zig: "tree-sitter-zig.wasm",
-  cue: "tree-sitter-cue.wasm"
-};
-export const GRAMMAR_FILES = [
-  ...new Set(Object.values(LANGUAGE_TO_GRAMMAR))
-];
-export const BLOCKED_GRAMMARS = {
-  "tree-sitter-swift.wasm": {
-    blocked: ({ isV8, nodeMajor }) => isV8 && nodeMajor >= 24,
-    reason: "tree-sitter-swift crashes the runtime on Node >= 24 (V8 Turboshaft WASM OOM, #423/#432); skipped so the process degrades gracefully instead of aborting."
-  }
-};
-function currentGrammarRuntime() {
-  const m = /^v?(\d+)/.exec(process.versions?.node ?? "");
-  return {
-    nodeMajor: m ? Number(m[1]) : 0,
-    isV8: !process.versions.bun && Boolean(process.versions.v8),
-    platform: process.platform
-  };
-}
-export function grammarBlockReason(filename, rt = currentGrammarRuntime()) {
-  if (process.env.PILENS_UNSAFE_FORCE_GRAMMAR_LOAD === "1")
-    return null;
-  const block = BLOCKED_GRAMMARS[filename];
-  return block?.blocked(rt) ? block.reason : null;
-}
-const WASM_MAGIC = [0, 97, 115, 109];
-export function hasWasmMagic(bytes) {
-  if (bytes.length < WASM_MAGIC.length)
-    return false;
-  return WASM_MAGIC.every((byte, i) => bytes[i] === byte);
-}
-export function fileHasWasmMagic(filePath) {
-  let fd;
-  try {
-    fd = fs.openSync(filePath, "r");
-    const head = Buffer.alloc(WASM_MAGIC.length);
-    const read = fs.readSync(fd, head, 0, head.length, 0);
-    return read === head.length && hasWasmMagic(head);
-  } catch {
-    return false;
-  } finally {
-    if (fd !== undefined) {
-      try {
-        fs.closeSync(fd);
-      } catch {}
-    }
-  }
-}
-const HTML_PREFIXES = ["<!doctype html", "<html", "<head", "<?xml"];
-export function describeNonWasmBody(bytes) {
-  if (bytes.length === 0) {
-    return "The download returned an empty body (0 bytes) instead of a wasm module.";
-  }
-  const head = Buffer.from(bytes.subarray(0, Math.min(16, bytes.length))).toString("latin1");
-  const lead = head.trimStart().toLowerCase();
-  const shape = HTML_PREFIXES.some((prefix) => lead.startsWith(prefix)) ? "an HTML page (a captive portal or proxy intercepted the request)" : "non-wasm data";
-  const magic = Buffer.from(bytes.subarray(0, WASM_MAGIC.length)).toString("hex").replace(/../g, "$& ").trim();
-  return `The download returned ${shape} — ` + `${bytes.length} bytes starting ${magic}, not a wasm module.`;
-}
-let manifestOverride;
-let cachedManifest;
-function grammarManifestPath() {
-  return path.join(getPackageRoot(import.meta.url), "scripts", "grammars.lock.json");
-}
-function resolveGrammarManifest() {
-  if (manifestOverride !== undefined)
-    return manifestOverride;
-  if (cachedManifest !== undefined)
-    return cachedManifest;
-  try {
-    const raw = fs.readFileSync(grammarManifestPath(), "utf-8");
-    cachedManifest = JSON.parse(raw);
-  } catch {
-    cachedManifest = null;
-  }
-  return cachedManifest;
-}
-function loadGrammarManifest() {
-  const manifest = resolveGrammarManifest();
-  if (manifest === null) {
-    recordDegradationOnce({
-      kind: "grammar-blocked",
-      subject: "grammars.lock.json",
-      reason: "the pinned sha256 manifest is unavailable — runtime grammar downloads " + "fall back to the weaker Content-Length check (or no integrity check at " + "all for a source with neither)."
-    });
-  }
-  return manifest;
-}
-export function _setGrammarManifestForTests(manifest) {
-  manifestOverride = manifest;
-}
-function sha256Hex(data) {
-  return `sha256:${createHash("sha256").update(data).digest("hex")}`;
-}
-export function pinnedGrammarHash(filename) {
-  return loadGrammarManifest()?.grammars[filename];
-}
-export function grammarFileSha256(filePath) {
-  try {
-    return sha256Hex(fs.readFileSync(filePath));
-  } catch {
-    return;
-  }
-}
-function shortHash(hash) {
-  const hex = hash.startsWith("sha256:") ? hash.slice("sha256:".length) : hash;
-  return `sha256:${hex.slice(0, 12)}…`;
-}
-export async function downloadGrammarDetailed(destDir, filename) {
-  if (isVendoredGrammar(filename))
-    return vendoredGrammarRefusal(filename);
-  try {
-    fs.mkdirSync(destDir, { recursive: true });
-    const res = await fetch(grammarSourceUrl(filename));
-    if (!res.ok) {
-      const retryable = res.status !== 404 && res.status !== 410;
-      return { ok: false, retryable };
-    }
-    const data = Buffer.from(await res.arrayBuffer());
-    if (!hasWasmMagic(data)) {
-      return { ok: false, retryable: true, reason: describeNonWasmBody(data) };
-    }
-    const declaredLength = res.headers.get("content-length");
-    if (declaredLength !== null) {
-      const expectedBytes = Number.parseInt(declaredLength, 10);
-      if (Number.isFinite(expectedBytes) && expectedBytes !== data.length) {
-        return {
-          ok: false,
-          retryable: true,
-          reason: `The download reported Content-Length: ${expectedBytes} but only ` + `${data.length} bytes arrived — a truncated transfer.`
-        };
-      }
-    }
-    const expectedHash = loadGrammarManifest()?.grammars[filename];
-    if (expectedHash) {
-      const actualHash = sha256Hex(data);
-      if (actualHash !== expectedHash) {
-        return {
-          ok: false,
-          retryable: true,
-          reason: `The download's sha256 (${shortHash(actualHash)}) does not match the ` + `pinned manifest (${shortHash(expectedHash)}) — a corrupt or truncated transfer.`
-        };
-      }
-    }
-    writeFileAtomic(path.join(destDir, filename), data, { bestEffort: false });
-    return { ok: true, retryable: true };
-  } catch {
-    return { ok: false, retryable: true };
-  }
-}
-export async function downloadGrammar(destDir, filename) {
-  return (await downloadGrammarDetailed(destDir, filename)).ok;
-}

package/extensions/dm-lens/dist/clients/gzip-stage-write.js

@@ -1,85 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { Readable } from "node:stream";
-import { pipeline } from "node:stream/promises";
-import { parentPort } from "node:worker_threads";
-import { createGzip } from "node:zlib";
-import { stagePathFor } from "./atomic-write-staging.js";
-export async function writeGzipStageFile(data, stagePath, testDelayMs, options) {
-  const startedAt = performance.now();
-  const tmpPath = stagePathFor(stagePath);
-  try {
-    if (testDelayMs) {
-      await new Promise((resolve) => setTimeout(resolve, testDelayMs));
-    }
-    const serializeStarted = performance.now();
-    const json = JSON.stringify(data);
-    const serializeMs = performance.now() - serializeStarted;
-    const rawBytes = Buffer.byteLength(json);
-    const semanticFingerprint = options?.semanticFingerprint?.(json);
-    if (semanticFingerprint !== undefined && options?.skipIfFingerprints?.includes(semanticFingerprint)) {
-      return {
-        rawBytes,
-        gzBytes: 0,
-        serializeMs,
-        writeMs: 0,
-        durationMs: performance.now() - startedAt,
-        semanticFingerprint,
-        skippedUnchanged: true
-      };
-    }
-    const writeStarted = performance.now();
-    await fs.promises.mkdir(path.dirname(stagePath), { recursive: true });
-    const chunks = function* () {
-      const chunkChars = 256 * 1024;
-      for (let offset = 0;offset < json.length; offset += chunkChars) {
-        yield json.slice(offset, offset + chunkChars);
-      }
-    };
-    await pipeline(Readable.from(chunks()), createGzip(), fs.createWriteStream(tmpPath));
-    await fs.promises.rename(tmpPath, stagePath);
-    const writeMs = performance.now() - writeStarted;
-    const gzBytes = (await fs.promises.stat(stagePath)).size;
-    return {
-      rawBytes,
-      gzBytes,
-      serializeMs,
-      writeMs,
-      durationMs: performance.now() - startedAt,
-      semanticFingerprint
-    };
-  } catch (err) {
-    await fs.promises.rm(tmpPath, { force: true }).catch(() => {});
-    throw err;
-  }
-}
-export function serveGzipStageWorker(buildBaseResult, options) {
-  const port = parentPort;
-  if (!port) {
-    throw new Error("gzip stage persist worker requires a parent port");
-  }
-  port.on("message", (request) => {
-    (async () => {
-      const result = {
-        ...buildBaseResult(request)
-      };
-      try {
-        const fingerprint = options?.semanticFingerprint;
-        const metrics = await writeGzipStageFile(request.data, request.stagePath, request.testDelayMs, {
-          semanticFingerprint: fingerprint ? (json) => fingerprint(request, json) : undefined,
-          skipIfFingerprints: options?.skipIfFingerprints?.(request)
-        });
-        result.rawBytes = metrics.rawBytes;
-        result.gzBytes = metrics.gzBytes;
-        result.serializeMs = metrics.serializeMs;
-        result.writeMs = metrics.writeMs;
-        result.durationMs = metrics.durationMs;
-        result.semanticFingerprint = metrics.semanticFingerprint;
-        result.skippedUnchanged = metrics.skippedUnchanged;
-      } catch (err) {
-        result.error = err instanceof Error ? err.message : String(err);
-      }
-      port.postMessage(result);
-    })();
-  });
-}

package/extensions/dm-lens/dist/clients/hashline-anchor.js

@@ -1,222 +0,0 @@
-import * as nodeFs from "node:fs";
-import { BoundedFifoMap } from "./bounded-cache.js";
-const HASHLINE_ANCHOR_LENGTH = 3;
-const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-const HASH_SPACE = ALPHABET.length ** HASHLINE_ANCHOR_LENGTH;
-const HASH_PROBE_STRIDE = ALPHABET.length ** 2 + ALPHABET.length + 1;
-const MAX_HASH_SOURCE_BYTES = 500;
-const BITSET_WORDS = Math.ceil(HASH_SPACE / 32);
-const ANCHOR_TOKEN_RE = /^[A-Za-z0-9]{3}$/;
-const XXH_PRIME1 = 2654435761;
-const XXH_PRIME2 = 2246822519;
-const XXH_PRIME3 = 3266489917;
-const XXH_PRIME4 = 668265263;
-const XXH_PRIME5 = 374761393;
-function rotl32(value, bits) {
-  return value << bits | value >>> 32 - bits;
-}
-function xxhRound(acc, input) {
-  return Math.imul(rotl32(acc + Math.imul(input, XXH_PRIME2) | 0, 13), XXH_PRIME1) | 0;
-}
-export function xxh32Bytes(bytes) {
-  const length = bytes.length;
-  let index = 0;
-  let hash;
-  if (length >= 16) {
-    const limit = length - 16;
-    let v1 = XXH_PRIME1 + XXH_PRIME2 | 0;
-    let v2 = XXH_PRIME2 | 0;
-    let v3 = 0;
-    let v4 = -XXH_PRIME1 | 0;
-    do {
-      v1 = xxhRound(v1, readU32(bytes, index));
-      v2 = xxhRound(v2, readU32(bytes, index + 4));
-      v3 = xxhRound(v3, readU32(bytes, index + 8));
-      v4 = xxhRound(v4, readU32(bytes, index + 12));
-      index += 16;
-    } while (index <= limit);
-    hash = rotl32(v1, 1) + rotl32(v2, 7) + rotl32(v3, 12) + rotl32(v4, 18) | 0;
-  } else {
-    hash = XXH_PRIME5 | 0;
-  }
-  hash = hash + length | 0;
-  while (index + 4 <= length) {
-    hash = Math.imul(rotl32(hash + Math.imul(readU32(bytes, index), XXH_PRIME3) | 0, 17), XXH_PRIME4) | 0;
-    index += 4;
-  }
-  while (index < length) {
-    hash = Math.imul(rotl32(hash + Math.imul(bytes[index], XXH_PRIME5) | 0, 11), XXH_PRIME1) | 0;
-    index += 1;
-  }
-  hash = hash ^ hash >>> 15 | 0;
-  hash = Math.imul(hash, XXH_PRIME2) | 0;
-  hash = hash ^ hash >>> 13 | 0;
-  hash = Math.imul(hash, XXH_PRIME3) | 0;
-  hash = hash ^ hash >>> 16 | 0;
-  return hash >>> 0;
-}
-function readU32(bytes, offset) {
-  return bytes[offset] | bytes[offset + 1] << 8 | bytes[offset + 2] << 16 | bytes[offset + 3] << 24 | 0;
-}
-function canon(line) {
-  return line.replace(/\r/g, "").trimEnd();
-}
-function splitLines(text) {
-  if (text.length === 0)
-    return [""];
-  const lines = text.split(`
-`);
-  return text.endsWith(`
-`) ? lines.slice(0, -1) : lines;
-}
-function hashSourceBytes(line) {
-  const bytes = Buffer.from(canon(line), "utf8");
-  if (bytes.length <= MAX_HASH_SOURCE_BYTES)
-    return bytes;
-  let cut = MAX_HASH_SOURCE_BYTES;
-  while (cut > 0 && (bytes[cut] & 192) === 128)
-    cut -= 1;
-  return bytes.subarray(0, cut);
-}
-function hashSourceKey(line) {
-  return Buffer.from(hashSourceBytes(line)).toString("utf8");
-}
-function indexToAnchor(index) {
-  let out = "";
-  let remaining = index;
-  for (let digit = 0;digit < HASHLINE_ANCHOR_LENGTH; digit += 1) {
-    out = ALPHABET[remaining % ALPHABET.length] + out;
-    remaining = Math.floor(remaining / ALPHABET.length);
-  }
-  return out;
-}
-function getBit(bits, index) {
-  return (bits[index >>> 5] >>> (index & 31) & 1) !== 0;
-}
-function setBit(bits, index) {
-  bits[index >>> 5] |= 1 << (index & 31);
-}
-function nextZeroBit(bits, start) {
-  let index = start % HASH_SPACE;
-  for (let step = 0;step < HASH_SPACE; step += 1) {
-    if (!getBit(bits, index))
-      return index;
-    index += HASH_PROBE_STRIDE;
-    if (index >= HASH_SPACE)
-      index -= HASH_SPACE;
-  }
-  return -1;
-}
-export function computeHashlineAnchors(content) {
-  const lines = splitLines(content);
-  if (lines.length > HASH_SPACE)
-    return;
-  const anchors = [];
-  anchors.length = lines.length;
-  const used = new Uint32Array(BITSET_WORDS);
-  let hint = 0;
-  const sourceCache = new Map;
-  for (let i = 0;i < lines.length; i += 1) {
-    const line = lines[i];
-    let baseIndex = sourceCache.get(line);
-    if (baseIndex === undefined) {
-      baseIndex = (xxh32Bytes(hashSourceBytes(line)) >>> 14) % HASH_SPACE;
-      sourceCache.set(line, baseIndex);
-    }
-    if (!getBit(used, baseIndex)) {
-      setBit(used, baseIndex);
-      hint = baseIndex + HASH_PROBE_STRIDE;
-      anchors[i] = indexToAnchor(baseIndex);
-      continue;
-    }
-    const probed = nextZeroBit(used, hint);
-    if (probed < 0)
-      return;
-    setBit(used, probed);
-    hint = probed + HASH_PROBE_STRIDE;
-    anchors[i] = indexToAnchor(probed);
-  }
-  return anchors;
-}
-export function normalizeHashlineAnchorToken(value) {
-  if (typeof value !== "string")
-    return;
-  const trimmed = value.trim();
-  return ANCHOR_TOKEN_RE.test(trimmed) ? trimmed : undefined;
-}
-const MAX_ANCHOR_FILE_BYTES = 4 * 1024 * 1024;
-const ANCHOR_INDEX_CACHE_LIMIT = 8;
-const ANCHOR_INDEX_CACHE = new BoundedFifoMap(ANCHOR_INDEX_CACHE_LIMIT);
-export function dropHashlineAnchorMemo() {
-  ANCHOR_INDEX_CACHE.clear();
-}
-function buildAnchorIndex(filePath) {
-  let stats;
-  try {
-    stats = nodeFs.statSync(filePath);
-  } catch {
-    return { failure: "file_unreadable" };
-  }
-  if (!stats.isFile())
-    return { failure: "file_unreadable" };
-  if (stats.size > MAX_ANCHOR_FILE_BYTES)
-    return { failure: "file_too_large" };
-  const cached = ANCHOR_INDEX_CACHE.get(filePath);
-  if (cached && cached.mtimeMs === stats.mtimeMs && cached.size === stats.size) {
-    return { index: cached.index, contentUnique: cached.contentUnique };
-  }
-  let raw;
-  try {
-    raw = nodeFs.readFileSync(filePath, "utf8");
-  } catch {
-    return { failure: "file_unreadable" };
-  }
-  const normalized = (raw.startsWith("\uFEFF") ? raw.slice(1) : raw).replace(/\r\n/g, `
-`).replace(/\r/g, `
-`);
-  const anchors = computeHashlineAnchors(normalized);
-  if (anchors === undefined)
-    return { failure: "file_too_large" };
-  const index = new Map;
-  for (let i = 0;i < anchors.length; i += 1) {
-    index.set(anchors[i], i + 1);
-  }
-  const lines = splitLines(normalized);
-  const keys = [];
-  keys.length = lines.length;
-  const keyCounts = new Map;
-  const keyCache = new Map;
-  for (let i = 0;i < lines.length; i += 1) {
-    const line = lines[i];
-    let key = keyCache.get(line);
-    if (key === undefined) {
-      key = hashSourceKey(line);
-      keyCache.set(line, key);
-    }
-    keys[i] = key;
-    keyCounts.set(key, (keyCounts.get(key) ?? 0) + 1);
-  }
-  const contentUnique = keys.map((key) => keyCounts.get(key) === 1);
-  ANCHOR_INDEX_CACHE.set(filePath, {
-    mtimeMs: stats.mtimeMs,
-    size: stats.size,
-    index,
-    contentUnique
-  });
-  return { index, contentUnique };
-}
-export function resolveHashlineAnchor(filePath, anchor) {
-  const token = normalizeHashlineAnchorToken(anchor);
-  if (token === undefined)
-    return { failure: "not_an_anchor" };
-  const built = buildAnchorIndex(filePath);
-  if ("failure" in built)
-    return { failure: built.failure };
-  const line = built.index.get(token);
-  if (line === undefined)
-    return { failure: "anchor_not_found" };
-  if (built.contentUnique[line - 1] !== true) {
-    return { failure: "content_not_unique" };
-  }
-  return { line };
-}

package/extensions/dm-lens/dist/clients/hook-budgets.js

@@ -1,16 +0,0 @@
-export const HOOK_WALL_BUDGET_MS = Object.freeze({
-  session_start: 5000,
-  turn_start: 0,
-  turn_end: 3000,
-  agent_end: 1000,
-  agent_settled: 1e4,
-  tool_result_read_only: 500,
-  tool_result_edit: 1e4,
-  session_shutdown: 0,
-  context: 0,
-  session_before_fork: 0
-});
-export const HOOK_BUDGET_KEYS = Object.keys(HOOK_WALL_BUDGET_MS);
-export function isHookBudgetKey(value) {
-  return Object.hasOwn(HOOK_WALL_BUDGET_MS, value);
-}

package/extensions/dm-lens/dist/clients/host-edit-normalize.js

@@ -1,87 +0,0 @@
-export const HOST_EDIT_DIFF_SDK_FLOOR = "0.85.1";
-export const HOST_SMART_SINGLE_QUOTES = [8216, 8217, 8218, 8219];
-export const HOST_SMART_DOUBLE_QUOTES = [8220, 8221, 8222, 8223];
-export const HOST_UNICODE_DASHES = [
-  8208,
-  8209,
-  8210,
-  8211,
-  8212,
-  8213,
-  8722
-];
-export const HOST_SPECIAL_SPACES = [
-  160,
-  8194,
-  8195,
-  8196,
-  8197,
-  8198,
-  8199,
-  8200,
-  8201,
-  8202,
-  8239,
-  8287,
-  12288
-];
-export const HOST_BOM_CODE_POINT = 65279;
-const charClass = (codePoints) => new RegExp(`[${String.fromCharCode(...codePoints)}]`, "g");
-const SMART_SINGLE_QUOTES_RE = charClass(HOST_SMART_SINGLE_QUOTES);
-const SMART_DOUBLE_QUOTES_RE = charClass(HOST_SMART_DOUBLE_QUOTES);
-const UNICODE_DASHES_RE = charClass(HOST_UNICODE_DASHES);
-const SPECIAL_SPACES_RE = charClass(HOST_SPECIAL_SPACES);
-const BOM = String.fromCharCode(HOST_BOM_CODE_POINT);
-export function detectLineEnding(content) {
-  const crlfIdx = content.indexOf(`\r
-`);
-  const lfIdx = content.indexOf(`
-`);
-  if (lfIdx === -1)
-    return `
-`;
-  if (crlfIdx === -1)
-    return `
-`;
-  return crlfIdx < lfIdx ? `\r
-` : `
-`;
-}
-export function normalizeToLF(text) {
-  return text.replace(/\r\n/g, `
-`).replace(/\r/g, `
-`);
-}
-export function restoreLineEndings(text, ending) {
-  return ending === `\r
-` ? text.replace(/\n/g, `\r
-`) : text;
-}
-export function normalizeForFuzzyMatch(text) {
-  return text.normalize("NFKC").split(`
-`).map((line) => line.trimEnd()).join(`
-`).replace(SMART_SINGLE_QUOTES_RE, "'").replace(SMART_DOUBLE_QUOTES_RE, '"').replace(UNICODE_DASHES_RE, "-").replace(SPECIAL_SPACES_RE, " ");
-}
-export function stripBom(content) {
-  return content.startsWith(BOM) ? { bom: BOM, text: content.slice(1) } : { bom: "", text: content };
-}
-export function normalizeForGuardMatch(text) {
-  return normalizeForFuzzyMatch(normalizeToLF(stripBom(text).text));
-}
-export function hostWouldApplyOldText(content, oldText) {
-  const c = normalizeToLF(stripBom(content).text);
-  const o = normalizeToLF(stripBom(oldText).text);
-  if (o.length === 0) {
-    return { wouldApply: false, occurrences: 0, usedFuzzyMatch: false };
-  }
-  const exactFound = c.indexOf(o) !== -1;
-  const fuzzyContent = normalizeForFuzzyMatch(c);
-  const fuzzyOldText = normalizeForFuzzyMatch(o);
-  const fuzzyFound = fuzzyContent.indexOf(fuzzyOldText) !== -1;
-  const occurrences = fuzzyOldText.length === 0 ? 0 : fuzzyContent.split(fuzzyOldText).length - 1;
-  return {
-    wouldApply: (exactFound || fuzzyFound) && occurrences === 1,
-    occurrences,
-    usedFuzzyMatch: !exactFound && fuzzyFound
-  };
-}

package/extensions/dm-lens/dist/clients/host-ports.js

@@ -1,35 +0,0 @@
-export function createDefaultHostPorts(overrides = {}) {
-  const unknownMode = () => "unknown";
-  const defaults = {
-    notify: { user: () => {} },
-    trust: { isProjectTrusted: () => "unknown" },
-    mode: {
-      current: unknownMode,
-      supportsTuiWidget: () => true,
-      suppressesUserNotify: () => false
-    },
-    log: { extension: () => {}, debug: () => {}, sink: () => () => {} },
-    emit: { bus: () => {} },
-    status: { set: () => {} },
-    spawn: { abortSignal: () => {
-      return;
-    }, isAllowed: () => true },
-    render: { invalidate: () => {} },
-    session: { id: () => {
-      return;
-    } },
-    workspace: { cwd: () => {
-      return;
-    }, projectRoot: () => {
-      return;
-    } },
-    flags: { get: () => {
-      return;
-    } },
-    tools: { has: async () => false, getActive: () => [], setActive: () => {} }
-  };
-  return Object.fromEntries(Object.entries(defaults).map(([group, value]) => [
-    group,
-    { ...value, ...overrides[group] }
-  ]));
-}