@silverbulletmd/silverbullet 2.10.0 → 2.12.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@silverbulletmd/silverbullet",
-  "version": "2.10.0",
+  "version": "2.12.0",
   "type": "module",
   "description": "A self-hosted, web-based note taking app",
   "publishConfig": {
@@ -15,20 +15,26 @@
     "./lib/tree": "./plug-api/lib/tree.ts",
     "./lib/ref": "./plug-api/lib/ref.ts",
     "./lib/resolve": "./plug-api/lib/resolve.ts",
+    "./lib/resolve_path": "./plug-api/lib/resolve_path.ts",
+    "./lib/link_write": "./plug-api/lib/link_write.ts",
     "./lib/dates": "./plug-api/lib/dates.ts",
+    "./lib/fuzzy": "./plug-api/lib/fuzzy.ts",
     "./lib/async": "./plug-api/lib/async.ts",
     "./lib/crypto": "./plug-api/lib/crypto.ts",
     "./lib/limited_map": "./plug-api/lib/limited_map.ts",
     "./lib/tags": "./plug-api/lib/tags.ts",
+    "./lib/collation": "./plug-api/lib/collation.ts",
     "./lib/transclusion": "./plug-api/lib/transclusion.ts",
     "./lib/native_fetch": "./plug-api/lib/native_fetch.ts",
     "./lib/query_expression": "./plug-api/lib/query_expression.ts",
+    "./lib/panel_styles": "./plug-api/lib/panel_styles.ts",
     "./type/client": "./plug-api/types/client.ts",
     "./type/config": "./plug-api/types/config.ts",
     "./type/manifest": "./plug-api/types/manifest.ts",
     "./type/namespace": "./plug-api/types/namespace.ts",
     "./type/datastore": "./plug-api/types/datastore.ts",
     "./type/event": "./plug-api/types/event.ts",
+    "./type/revisions": "./plug-api/types/revisions.ts",
     "./type/index": "./plug-api/types/index.ts"
   },
   "bin": {
@@ -41,6 +47,7 @@
     "client/plugos/**/*.ts",
     "!client/plugos/**/*.test.ts",
     "client/asset_bundle/bundle.ts",
+    "client/config.ts",
     "client/data/kv_primitives.ts",
     "client/data/datastore.ts",
     "client/space_lua/**/*.ts",
@@ -48,6 +55,7 @@
     "!client/space_lua/**/*.bench.ts",
     "client/markdown_parser/constants.ts",
     "plugs/builtin_plugs.ts",
+    "plugs/index/types.ts",
     "dist/plug-compile.js"
   ],
   "scripts": {
@@ -55,9 +63,10 @@
     "build:plugs": "tsx build/build_plugs.ts",
     "build:client": "tsx build/build_client.ts",
     "build:plug-compile": "tsx build/build_plug_compile.ts",
+    "prebuild:client": "node build/patch_codemirror_view.mjs",
     "prepublishOnly": "npm run build:plug-compile",
     "test": "vitest run",
-    "check": "tsc --noEmit",
+    "check": "tsc --noEmit && tsc -p tsconfig.e2e.json",
     "lint": "biome lint .",
     "fmt": "biome format --write .",
     "fmt:check": "biome format .",
@@ -71,62 +80,64 @@
   },
   "dependencies": {
     "@cfworker/json-schema": "^4.1.1",
-    "@codemirror/autocomplete": "6.20.1",
-    "@codemirror/commands": "6.10.3",
+    "@codemirror/autocomplete": "6.20.3",
+    "@codemirror/commands": "6.11.1",
     "@codemirror/lang-css": "6.3.1",
-    "@codemirror/lang-html": "6.4.11",
+    "@codemirror/lang-html": "6.4.12",
     "@codemirror/lang-javascript": "6.2.5",
-    "@codemirror/lang-markdown": "6.5.0",
-    "@codemirror/language": "6.12.3",
-    "@codemirror/legacy-modes": "6.5.2",
-    "@codemirror/lint": "6.9.5",
-    "@codemirror/search": "6.6.0",
-    "@codemirror/state": "6.6.0",
-    "@codemirror/view": "6.41.0",
-    "@joplin/turndown-plugin-gfm": "1.0.64",
-    "@lezer/common": "1.5.1",
-    "@lezer/css": "1.3.3",
-    "@lezer/highlight": "1.2.3",
+    "@codemirror/lang-markdown": "6.5.2",
+    "@codemirror/language": "6.12.4",
+    "@codemirror/legacy-modes": "6.5.4",
+    "@codemirror/lint": "6.9.7",
+    "@codemirror/search": "6.7.2",
+    "@codemirror/state": "6.7.6",
+    "@codemirror/view": "6.43.13",
+    "@joplin/turndown-plugin-gfm": "1.0.68",
+    "@lezer/common": "1.5.2",
+    "@lezer/css": "1.3.8",
+    "@lezer/highlight": "1.2.4",
     "@lezer/html": "1.3.13",
-    "@lezer/javascript": "1.5.4",
-    "@lezer/lr": "1.4.8",
-    "@lezer/markdown": "1.6.3",
+    "@lezer/javascript": "1.5.5",
+    "@lezer/lr": "1.4.10",
+    "@lezer/markdown": "1.7.2",
     "@msgpack/msgpack": "3.1.3",
+    "@noble/hashes": "2.4.0",
     "@replit/codemirror-lang-nix": "6.0.1",
-    "@replit/codemirror-vim": "6.3.0",
-    "commander": "^14.0.3",
-    "crelt": "1.0.6",
+    "@replit/codemirror-vim": "6.4.0",
+    "@types/js-yaml": "^4.0.9",
+    "commander": "^15.0.0",
+    "crelt": "1.0.7",
     "d3-force": "^3.0.0",
-    "esbuild": "^0.27.3",
+    "esbuild": "^0.28.2",
     "fast-diff": "1.3.0",
-    "force-graph": "^1.49.0",
     "fast-glob": "^3.3.3",
+    "force-graph": "^1.51.4",
     "gitignore-parser": "0.0.2",
     "idb": "8.0.3",
-    "js-yaml": "^4.1.1",
+    "js-yaml": "^4.3.2",
     "mime": "4.1.0",
-    "preact": "10.28.2",
-    "preact-feather": "4.2.1",
-    "react-icons": "5.5.0",
-    "sass": "^1.97.3",
-    "style-mod": "4.1.3",
-    "turndown": "7.2.2"
+    "preact": "10.29.8",
+    "preact-feather": "4.3.0",
+    "react-icons": "5.7.0",
+    "sass": "^1.105.0",
+    "style-mod": "4.1.4",
+    "turndown": "7.2.4"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.4.6",
-    "@playwright/test": "^1.58.2",
-    "@preact/preset-vite": "^2.10.3",
+    "@biomejs/biome": "2.5.14",
+    "@playwright/test": "1.58.2",
+    "@preact/preset-vite": "^2.10.6",
     "@types/d3-force": "^3.0.10",
     "@types/gitignore-parser": "^0.0.3",
-    "@types/js-yaml": "^4.0.9",
-    "@types/node": "^22.0.0",
+    "@types/node": "^26.6.2",
     "@types/turndown": "^5.0.6",
-    "fake-indexeddb": "6.0.1",
+    "@typescript/native": "npm:typescript@^7.0.2",
+    "fake-indexeddb": "6.2.5",
     "preact-render-to-string": "^6.7.0",
-    "tsx": "^4.19.0",
-    "typescript": "^5.9.3",
-    "vite": "^7.3.1",
-    "vitest": "^4.0.18"
+    "tsx": "^4.23.15",
+    "typescript": "npm:@typescript/typescript6@^6.0.2",
+    "vite": "^8.3.1",
+    "vitest": "^4.1.11"
   },
   "engines": {
     "node": ">=24.13.0",

package/plug-api/lib/async.ts

@@ -11,7 +11,6 @@ export function throttle(
       }, limit);
     }
   };
-  // Immediately execute any pending call and cancel the timer
   throttled.flush = () => {
     if (timer) {
       clearTimeout(timer);
@@ -91,7 +90,7 @@ export class PromiseQueue {
       reject(error);
     }
 
-    void this.process(); // Continue processing the next promise in the queue
+    void this.process();
   }
 }
 
@@ -108,17 +107,13 @@ export async function batchRequests<I, O>(
   batchSize: number,
 ): Promise<O[]> {
   const results: O[] = [];
-  // Split values into batches of batchSize
   const batches: I[][] = [];
   for (let i = 0; i < values.length; i += batchSize) {
     batches.push(values.slice(i, i + batchSize));
   }
-  // Run fn on them in parallel
   const batchResults = await Promise.all(batches.map(fn));
-  // Flatten the results
   for (const batchResult of batchResults) {
     if (Array.isArray(batchResult)) {
-      // If fn returns an array, collect them
       results.push(...batchResult);
     }
   }

package/plug-api/lib/collation.ts

@@ -0,0 +1,22 @@
+import type { QueryCollationConfig } from "../types/config.ts";
+
+/**
+ * Compares two values the same way the query engine's `order by` does:
+ * codepoint order by default, or `Intl.Collator` order when the space's
+ * `queryCollation` config turns it on and both sides are strings.
+ */
+export function compareCollated(
+  // deno-lint-ignore no-explicit-any
+  a: any,
+  // deno-lint-ignore no-explicit-any
+  b: any,
+  collation: QueryCollationConfig | undefined,
+  collator: Intl.Collator,
+): number {
+  if (collation?.enabled && typeof a === "string" && typeof b === "string") {
+    return collator.compare(a, b);
+  }
+  if (a < b) return -1;
+  if (a > b) return 1;
+  return 0;
+}

package/plug-api/lib/crypto.ts

@@ -1,3 +1,5 @@
+import { sha256 } from "@noble/hashes/sha2.js";
+
 export function base64Decode(s: string): Uint8Array {
   const binString = atob(s);
   const len = binString.length;
@@ -32,31 +34,33 @@ export function base64DecodeDataUrl(dataUrl: string): Uint8Array {
   return base64Decode(b64Encoded);
 }
 
-/**
- * Perform sha256 hash using the browser's crypto APIs
- * Note: this will only work over HTTPS
- * @param message
- */
 export async function hashSHA256(
   message: string | Uint8Array,
 ): Promise<string> {
-  // Transform the string into an ArrayBuffer
   const encoder = new TextEncoder();
   const data: Uint8Array =
     typeof message === "string" ? encoder.encode(message) : message;
 
-  // Generate the hash
-  const hashBuffer = await globalThis.crypto.subtle.digest(
-    "SHA-256",
-    data as BufferSource,
-  );
+  const hashBuffer = globalThis.crypto.subtle
+    ? await globalThis.crypto.subtle.digest("SHA-256", data as BufferSource)
+    : sha256(data);
 
-  // Transform the hash into a hex string
   return Array.from(new Uint8Array(hashBuffer))
     .map((b) => b.toString(16).padStart(2, "0"))
     .join("");
 }
 
+export function randomUUID(): string {
+  if (globalThis.crypto.randomUUID) return globalThis.crypto.randomUUID();
+  const bytes = globalThis.crypto.getRandomValues(new Uint8Array(16));
+  bytes[6] = (bytes[6] & 0x0f) | 0x40;
+  bytes[8] = (bytes[8] & 0x3f) | 0x80;
+  const hex = Array.from(bytes, (byte) =>
+    byte.toString(16).padStart(2, "0"),
+  ).join("");
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+
 /**
  * To avoid database clashes based on space folder path name, base URLs and encryption keys we derive
  * a database name from a hash of all these combined together
@@ -117,7 +121,6 @@ export async function encryptAesGcm(
   );
   const encrypted = new Uint8Array(encryptedBuffer);
 
-  // Prepend IV to ciphertext
   const result = new Uint8Array(iv.length + encrypted.length);
   result.set(iv, 0);
   result.set(encrypted, iv.length);
@@ -143,10 +146,8 @@ export async function deriveCTRKeyFromPassword(
   password: string,
   salt: Uint8Array,
 ): Promise<CryptoKey> {
-  // Encode password to ArrayBuffer
   const passwordBytes = new TextEncoder().encode(password);
 
-  // Import password as a CryptoKey
   const baseKey = await globalThis.crypto.subtle.importKey(
     "raw",
     passwordBytes,

package/plug-api/lib/dates.ts

@@ -2,6 +2,39 @@ export function niceDate(d: Date): string {
   return localDateString(d).split("T")[0];
 }
 
+/** Largest-unit-first, so the cascade below divides down to the right one. */
+const RELATIVE_DIVISIONS: {
+  amount: number;
+  unit: Intl.RelativeTimeFormatUnit;
+}[] = [
+  { amount: 60, unit: "second" },
+  { amount: 60, unit: "minute" },
+  { amount: 24, unit: "hour" },
+  { amount: 7, unit: "day" },
+  { amount: 4.34524, unit: "week" },
+  { amount: 12, unit: "month" },
+];
+
+/**
+ * "10 minutes ago", "yesterday", "3 months ago". `numeric: "auto"` is what
+ * turns the -1 cases into words rather than "1 day ago".
+ */
+export function relativeTime(
+  timestamp: number,
+  locale?: string,
+  now: number = Date.now(),
+): string {
+  const formatter = new Intl.RelativeTimeFormat(locale, { numeric: "auto" });
+  let duration = (timestamp - now) / 1000;
+  for (const { amount, unit } of RELATIVE_DIVISIONS) {
+    if (Math.abs(duration) < amount) {
+      return formatter.format(Math.round(duration), unit);
+    }
+    duration /= amount;
+  }
+  return formatter.format(Math.round(duration), "year");
+}
+
 export function localDateString(d: Date): string {
   return (
     d.getFullYear() +

package/plug-api/lib/fuzzy.ts

@@ -0,0 +1,282 @@
+function normalize(s: string): string {
+  return s
+    .normalize("NFD")
+    .replace(/\p{Diacritic}/gu, "")
+    .toLowerCase();
+}
+
+const WORD_BOUNDARY_CHARS = new Set(["/", "-", "_", " ", ".", ":"]);
+
+function isWordBoundaryAt(
+  original: string,
+  lowered: string,
+  i: number,
+): boolean {
+  if (i === 0) return true;
+  const prev = lowered[i - 1];
+  if (WORD_BOUNDARY_CHARS.has(prev)) return true;
+  // CamelCase boundary: previous original char is lowercase, current is uppercase
+  const origPrev = original[i - 1];
+  const origCur = original[i];
+  if (
+    origPrev &&
+    origCur &&
+    origPrev === origPrev.toLowerCase() &&
+    origPrev !== origPrev.toUpperCase() &&
+    origCur === origCur.toUpperCase() &&
+    origCur !== origCur.toLowerCase()
+  ) {
+    return true;
+  }
+  return false;
+}
+
+function bestSubstringEditDistance(token: string, candidate: string): number {
+  const tl = token.length;
+  const cl = candidate.length;
+  let prevPrev = new Array(cl + 1).fill(0);
+  let prev = new Array(cl + 1).fill(0);
+  let curr = new Array(cl + 1);
+
+  for (let i = 1; i <= tl; i++) {
+    curr[0] = i;
+    for (let j = 1; j <= cl; j++) {
+      const cost = token[i - 1] === candidate[j - 1] ? 0 : 1;
+      let v = Math.min(prev[j] + 1, curr[j - 1] + 1, prev[j - 1] + cost);
+      if (
+        i > 1 &&
+        j > 1 &&
+        token[i - 1] === candidate[j - 2] &&
+        token[i - 2] === candidate[j - 1]
+      ) {
+        v = Math.min(v, prevPrev[j - 2] + 1);
+      }
+      curr[j] = v;
+    }
+    const tmp = prevPrev;
+    prevPrev = prev;
+    prev = curr;
+    curr = tmp;
+  }
+
+  let best = prev[0];
+  for (let j = 1; j <= cl; j++) {
+    if (prev[j] < best) best = prev[j];
+  }
+  return best;
+}
+
+export function typoScore(token: string, candidate: string): number {
+  if (token.length < 4) return 0;
+  const max = Math.min(2, Math.floor(token.length / 4));
+  if (max < 1) return 0;
+
+  const bestDist = bestSubstringEditDistance(token, candidate);
+  if (bestDist > max) return 0;
+  return 0.25 - 0.05 * bestDist; // 0.25 / 0.20 / 0.15
+}
+
+function subsequenceScore(
+  token: string,
+  candidate: string,
+  candidateOriginal: string,
+): number {
+  // Greedy left-to-right match; track contiguous runs and word-boundary hits.
+  let ti = 0;
+  let firstMatch = -1;
+  let lastMatch = -1;
+  let contiguousRunSum = 0;
+  let currentRun = 0;
+  let boundaryHits = 0;
+  let prevMatchCi = -2;
+
+  for (let ci = 0; ci < candidate.length && ti < token.length; ci++) {
+    if (candidate[ci] === token[ti]) {
+      if (firstMatch < 0) firstMatch = ci;
+      lastMatch = ci;
+      if (isWordBoundaryAt(candidateOriginal, candidate, ci)) boundaryHits++;
+      if (ci === prevMatchCi + 1) {
+        currentRun++;
+      } else {
+        contiguousRunSum += currentRun * currentRun;
+        currentRun = 1;
+      }
+      prevMatchCi = ci;
+      ti++;
+    }
+  }
+  contiguousRunSum += currentRun * currentRun;
+
+  if (ti < token.length) return 0; // not a subsequence at all
+
+  // Normalize: token length over span (penalizes wide spans)
+  const span = lastMatch - firstMatch + 1;
+  const density = token.length / span; // in (0, 1]
+  const boundaryBonus = boundaryHits / token.length; // in [0, 1]
+  const contiguityBonus = contiguousRunSum / (token.length * token.length); // in (0, 1]
+
+  // Weighted combination scaled into [0.30, 0.65]
+  const raw = 0.5 * density + 0.3 * contiguityBonus + 0.2 * boundaryBonus;
+  return 0.3 + raw * 0.35;
+}
+
+export function scoreToken(token: string, candidate: string): number {
+  if (!token) return 0;
+  const t = normalize(token);
+  const cOrig = candidate;
+  const c = normalize(candidate);
+
+  // Tier 1: exact equality
+  if (c === t) return 1.0;
+
+  // Tier 2: prefix
+  if (c.startsWith(t)) {
+    return isWordBoundaryAt(cOrig, c, 0) ? 0.95 : 0.9;
+  }
+
+  // Tier 3: substring. Search for the best occurrence — a word-boundary
+  // match wins even if it appears later than a non-boundary match.
+  {
+    let bestIdx = -1;
+    let bestBoundary = false;
+    let idx = c.indexOf(t);
+    while (idx >= 0) {
+      const boundary = isWordBoundaryAt(cOrig, c, idx);
+      if (bestIdx < 0 || (boundary && !bestBoundary)) {
+        bestIdx = idx;
+        bestBoundary = boundary;
+        if (boundary) break; // can't get better
+      }
+      idx = c.indexOf(t, idx + 1);
+    }
+    if (bestIdx >= 0) {
+      // For very short tokens (<=2 chars), only count substring matches at
+      // word boundaries — otherwise short tokens generate too much noise.
+      if (t.length > 2 || bestBoundary) {
+        return bestBoundary ? 0.8 : 0.75;
+      }
+      // fall through for short non-boundary substring matches
+    }
+  }
+
+  // Tier 4: subsequence (short tokens skip this tier; substring at boundary
+  // is the only way for them to match)
+  if (t.length > 2) {
+    const subseq = subsequenceScore(t, c, cOrig);
+    if (subseq > 0) return subseq;
+  }
+
+  // Tier 5: bounded typo
+  const typo = typoScore(t, c);
+  if (typo > 0) return typo;
+
+  return 0;
+}
+
+export type RankField = { weight: number; segments?: boolean };
+export type RankOptions<T> = {
+  fields?: Record<string, number | RankField>;
+  orderId?: (obj: T) => number;
+};
+
+const DEFAULT_FIELDS: Record<string, number | RankField> = {
+  name: { weight: 1.0, segments: true },
+  displayName: 0.9,
+  aliases: 0.85,
+};
+
+/**
+ * Whether `phrase` equals one of `obj`'s ranked fields verbatim (normalized).
+ * Per-token scoring (below) never penalizes a candidate for carrying *extra*
+ * words the phrase didn't ask for -- "Foo" and "Foo Bar" score identically
+ * against the phrase "Foo", since each of the phrase's tokens matches
+ * somewhere in either candidate just as well. That leaves same-score ties
+ * exactly where a user's full, exact phrase should still win outright, which
+ * is what this tie-break (see `rank`'s sort) is for.
+ */
+function hasExactFieldMatch<T extends Record<string, any>>(
+  obj: T,
+  normalizedPhrase: string,
+  fields: Record<string, number | RankField>,
+): boolean {
+  for (const fieldName of Object.keys(fields)) {
+    const raw = obj[fieldName];
+    const values: unknown[] = Array.isArray(raw)
+      ? raw
+      : raw != null
+        ? [raw]
+        : [];
+    for (const value of values) {
+      if (normalize(String(value)) === normalizedPhrase) return true;
+    }
+  }
+  return false;
+}
+
+export function rank<T extends Record<string, any>>(
+  objects: T[],
+  phrase: string,
+  options: RankOptions<T> = {},
+): (T & { score: number })[] {
+  const fields = options.fields ?? DEFAULT_FIELDS;
+  const orderId = options.orderId ?? (() => 0);
+  const normalizedPhrase = normalize(phrase);
+  const tokens = normalizedPhrase.split(/\s+/).filter((t) => t.length > 0);
+  if (tokens.length === 0) {
+    return [...objects]
+      .sort(
+        (a, b) =>
+          orderId(a) - orderId(b) ||
+          String(a.name ?? "").localeCompare(String(b.name ?? "")),
+      )
+      .map((o) => ({ ...o, score: 1 }));
+  }
+  const results: (T & { score: number })[] = [];
+  for (const obj of objects) {
+    let product = 1;
+    let excluded = false;
+    for (const token of tokens) {
+      let best = 0;
+      for (const [fieldName, fieldSpec] of Object.entries(fields)) {
+        const spec: RankField =
+          typeof fieldSpec === "number" ? { weight: fieldSpec } : fieldSpec;
+        const raw = obj[fieldName];
+        const values: string[] = Array.isArray(raw)
+          ? raw.map(String)
+          : raw != null
+            ? [String(raw)]
+            : [];
+        for (const value of values) {
+          if (spec.segments && value.includes("/")) {
+            const last = value.slice(value.lastIndexOf("/") + 1);
+            best = Math.max(
+              best,
+              scoreToken(token, last) * spec.weight,
+              scoreToken(token, value) * spec.weight * 0.85,
+            );
+          } else {
+            best = Math.max(best, scoreToken(token, value) * spec.weight);
+          }
+        }
+      }
+      if (best === 0) {
+        excluded = true;
+        break;
+      }
+      product *= best;
+    }
+    if (!excluded) {
+      results.push({ ...obj, score: product ** (1 / tokens.length) });
+    }
+  }
+  return results.sort((a, b) => {
+    if (b.score !== a.score) return b.score - a.score;
+    const aExact = hasExactFieldMatch(a, normalizedPhrase, fields);
+    const bExact = hasExactFieldMatch(b, normalizedPhrase, fields);
+    if (aExact !== bExact) return aExact ? -1 : 1;
+    return (
+      orderId(a) - orderId(b) ||
+      String(a.name ?? "").localeCompare(String(b.name ?? ""))
+    );
+  });
+}

package/plug-api/lib/json.ts

@@ -50,7 +50,6 @@ export function deepEqual(a: any, b: any): boolean {
  * @param d the date to convert
  */
 export function cleanStringDate(d: Date): string {
-  // If no significant time, return a date string only
   if (
     d.getUTCHours() === 0 &&
     d.getUTCMinutes() === 0 &&
@@ -85,7 +84,6 @@ export function cleanupJSON(a: any): any {
   if (Array.isArray(a)) {
     return a.map(cleanupJSON);
   }
-  // If a is a date, convert to a string
   if (a instanceof Date) {
     return cleanStringDate(a);
   }
@@ -106,17 +104,14 @@ export function cleanupJSON(a: any): any {
 }
 
 export function deepClone<T>(obj: T, ignoreKeys: string[] = []): T {
-  // Handle null, undefined, or primitive types (string, number, boolean, symbol, bigint)
   if (obj === null || typeof obj !== "object") {
     return obj;
   }
 
-  // Handle Date
   if (obj instanceof Date) {
     return new Date(obj.getTime()) as any;
   }
 
-  // Handle Array
   if (Array.isArray(obj)) {
     const arrClone: any[] = [];
     for (let i = 0; i < obj.length; i++) {
@@ -125,7 +120,6 @@ export function deepClone<T>(obj: T, ignoreKeys: string[] = []): T {
     return arrClone as any;
   }
 
-  // Handle Object
   if (obj instanceof Object) {
     const objClone: { [key: string]: any } = {};
     for (const key in obj) {

package/plug-api/lib/limited_map.ts

@@ -31,7 +31,6 @@ export class LimitedMap<V> {
       }, ttl);
     }
     if (this.map.size >= this.maxSize) {
-      // Remove the oldest key before adding a new one
       const oldestKey = this.getOldestKey();
       this.map.delete(oldestKey!);
     }
@@ -41,7 +40,6 @@ export class LimitedMap<V> {
   get(key: string): V | undefined {
     const entry = this.map.get(key);
     if (entry) {
-      // Update the last accessed timestamp
       entry.la = Date.now();
       return entry.value;
     }