pi-lens 4.4.3 → 4.4.4

package/dist/{chunk-FCSOVF55.js → chunk-CUHSHSB6.js}

@@ -3,20 +3,20 @@ import {
   extractTomlTableSection,
   hasTomlTable,
   parseTomlStringArray
-} from "./chunk-P7266HLM.js";
+} from "./chunk-MPNJLASA.js";
 import {
   getProjectTrustState
-} from "./chunk-ZANLILYD.js";
+} from "./chunk-M2IFVFWU.js";
 import {
   incrementDegradationCount,
   recordDegradationOnce
-} from "./chunk-JAU72XNY.js";
+} from "./chunk-J64T55EI.js";
 import {
   logExtension
-} from "./chunk-XTMJ7XDT.js";
+} from "./chunk-POMLXPMY.js";
 import {
   logLatency
-} from "./chunk-QQNQ7SJW.js";
+} from "./chunk-QBFBRV2B.js";
 import {
   UV_WORKSPACE_EXCLUDE_DIALECT,
   UV_WORKSPACE_MEMBERS_DIALECT,
@@ -24,7 +24,7 @@ import {
   matchesWorkspaceMemberPattern,
   toPosix,
   walkUpDirs
-} from "./chunk-N2H3ZPZY.js";
+} from "./chunk-3RKP3FMS.js";
 
 // dist/clients/bounded-telemetry.js
 var MAX_TRACKED_TURN_CAPS = 64;

package/dist/{chunk-CHOW74WE.js → chunk-CYRKQRPM.js}

@@ -1,10 +1,11 @@
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
 import {
-  BoundedLruCache
+  BoundedLruCache,
+  BoundedSet
 } from "./chunk-ABBOA7UD.js";
 import {
   normalizeMapKey
-} from "./chunk-N2H3ZPZY.js";
+} from "./chunk-3RKP3FMS.js";
 
 // dist/clients/dispatch/fact-store.js
 var capacityEvictionReporter;
@@ -28,8 +29,10 @@ var FactStore = class {
   // oldest-inserted.
   boundedSessionFacts = new BoundedLruCache(MAX_SESSION_FACT_RECORDS);
   // Keys evicted from `boundedSessionFacts` and not written since, so a reader
-  // can tell "evicted" from "never seen" (#2282). Same cap, same FIFO order.
-  evictedSessionFactKeys = /* @__PURE__ */ new Set();
+  // can tell "evicted" from "never seen" (#2282). Same cap, same FIFO order —
+  // the cap lives in `BoundedSet.add`'s own overflow rather than in a
+  // hand-rolled tombstone trim here (#4580 review F1).
+  evictedSessionFactKeys = new BoundedSet(MAX_SESSION_FACT_RECORDS);
   // Pin refcount per file. A file is exempt from capacity eviction while its
   // count is > 0. Refcounted, not a Set, so two overlapping dispatches of the
   // same file both hold the pin until BOTH settle (#2243 item 2).
@@ -282,12 +285,6 @@ var FactStore = class {
     const evicted = this.boundedSessionFacts.set(factId, value);
     for (const [oldestKey] of evicted) {
       this.evictedSessionFactKeys.add(oldestKey);
-      while (this.evictedSessionFactKeys.size > MAX_SESSION_FACT_RECORDS) {
-        const oldestTombstone = this.evictedSessionFactKeys.values().next().value;
-        if (oldestTombstone === void 0)
-          break;
-        this.evictedSessionFactKeys.delete(oldestTombstone);
-      }
       capacityEvictionReporter?.(this.subject, "session-count", `session-fact store axis=count exceeded ${MAX_SESSION_FACT_RECORDS} records; evicted least-recently-used fact for ${oldestKey}`);
     }
   }

package/dist/{chunk-Q7DUK4LX.js → chunk-DEL2U6CM.js}

@@ -1,18 +1,18 @@
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
 import {
   rootMarkersForFile
-} from "./chunk-QOBUHWHX.js";
+} from "./chunk-HRNHZA3N.js";
 import {
   createGenerationMap,
   createGenerationSource
-} from "./chunk-C34ZXZ7O.js";
+} from "./chunk-KUA4OJ5Y.js";
 import {
   getDegradationLedgerGeneration,
   recordDegradationOnce
-} from "./chunk-JAU72XNY.js";
+} from "./chunk-J64T55EI.js";
 import {
   logExtension
-} from "./chunk-XTMJ7XDT.js";
+} from "./chunk-POMLXPMY.js";
 import {
   isAtOrAboveHomeDir,
   isRealGitMarker,
@@ -20,7 +20,7 @@ import {
   isWindowsPath,
   nameMatchesMarkerGlob,
   normalizeEphemeralMapKey
-} from "./chunk-N2H3ZPZY.js";
+} from "./chunk-3RKP3FMS.js";
 
 // dist/clients/tool-cwd.js
 import * as os from "node:os";

package/dist/{chunk-6C7JWPCP.js → chunk-DGUKIYSI.js}

@@ -3,31 +3,31 @@ import {
   shouldRecurseIntoDir,
   walkTreeRecursiveSync,
   walkTreeStackAsync
-} from "./chunk-5NGR67U5.js";
+} from "./chunk-XBJVAEEO.js";
 import {
   getProjectIgnoreMatcher
-} from "./chunk-C34ZXZ7O.js";
+} from "./chunk-KUA4OJ5Y.js";
 import {
   KIND_EXTENSIONS,
   isCodeKindFile
-} from "./chunk-PHDMFAKM.js";
+} from "./chunk-DUO2TU77.js";
 import {
   classifyGeneratedOrArtifactDetailed,
   isDeclarationFile
-} from "./chunk-2BBLFX75.js";
+} from "./chunk-J6MPGQTS.js";
 import {
   logLatency
-} from "./chunk-QQNQ7SJW.js";
+} from "./chunk-QBFBRV2B.js";
 import {
   toPositiveFinite
-} from "./chunk-AOHZU2BM.js";
+} from "./chunk-YNE3RP52.js";
 import {
   BoundedLruCache
 } from "./chunk-ABBOA7UD.js";
 import {
   normalizeEphemeralMapKey,
   normalizeFilePath
-} from "./chunk-N2H3ZPZY.js";
+} from "./chunk-3RKP3FMS.js";
 
 // dist/clients/source-filter.js
 import * as fs2 from "node:fs";
@@ -110,14 +110,15 @@ function slowFsDegradationNotice() {
 function createArtifactProbeCache() {
   return /* @__PURE__ */ new Map();
 }
-function probeExists(filePath, cache) {
+function probeExists(filePath, cache, siblings) {
+  const exists = () => (!siblings || siblings.mayContain(filePath)) && fs2.existsSync(filePath);
   if (!cache)
-    return fs2.existsSync(filePath);
+    return exists();
   const key = normalizeEphemeralMapKey(filePath);
   const cached = cache.get(key);
   if (cached !== void 0)
     return cached;
-  const result = fs2.existsSync(filePath);
+  const result = exists();
   cache.set(key, result);
   return result;
 }
@@ -225,9 +226,9 @@ function getBasename(filePath) {
 function getDir(filePath) {
   return path2.dirname(filePath);
 }
-function findSourceSibling(filePath, probeCache) {
+function findSourceSibling(filePath, probeCache, siblings) {
   for (const candidate of sourceTwinCandidates(filePath)) {
-    if (probeExists(candidate, probeCache))
+    if (probeExists(candidate, probeCache, siblings))
       return candidate;
   }
   const ext = path2.extname(filePath).toLowerCase();
@@ -236,7 +237,7 @@ function findSourceSibling(filePath, probeCache) {
   for (const [sourceExt, shadowedExts] of Object.entries(SOURCE_PRECEDENCE)) {
     if (!sourceExtsForCompiledExt(sourceExt).length && shadowedExts.includes(ext)) {
       const siblingPath = path2.join(dir, base + sourceExt);
-      if (probeExists(siblingPath, probeCache))
+      if (probeExists(siblingPath, probeCache, siblings))
         return siblingPath;
     }
   }
@@ -245,8 +246,8 @@ function findSourceSibling(filePath, probeCache) {
 function sourceExtsForCompiledExt(sourceExt) {
   return sourceExt === ".ts" || sourceExt === ".tsx" || sourceExt === ".mts" || sourceExt === ".cts" ? [sourceExt] : [];
 }
-function isBuildArtifact(filePath, probeCache) {
-  return findSourceSibling(filePath, probeCache) !== null;
+function isBuildArtifact(filePath, probeCache, siblings) {
+  return findSourceSibling(filePath, probeCache, siblings) !== null;
 }
 function filterSourceFiles(filePaths, options) {
   const keep = [];
@@ -279,7 +280,7 @@ function resolveCollectionConfig(rootDir, options, config) {
     options
   };
 }
-function classifyEntry(entry, fullPath, cfg, probeCache, skipCounters) {
+function classifyEntry(entry, fullPath, cfg, probeCache, skipCounters, siblings) {
   const { ignoreMatcher, extraExcludePatterns, extensions, options } = cfg;
   if (entry.isDirectory()) {
     const canRecurse = shouldRecurseIntoDir(
@@ -307,7 +308,7 @@ function classifyEntry(entry, fullPath, cfg, probeCache, skipCounters) {
       return {};
     if (ignoreMatcher.isIgnored(fullPath, false))
       return {};
-    if (isBuildArtifact(fullPath, probeCache)) {
+    if (isBuildArtifact(fullPath, probeCache, siblings)) {
       if (skipCounters)
         skipCounters.buildArtifactSkips += 1;
       return {};
@@ -349,12 +350,12 @@ function collectSourceFilesWithBudget(dir, options) {
   const probeCache = createArtifactProbeCache();
   const budget = createEntryBudget(cfg.maxScanEntries);
   const skipCounters = createSourceWalkSkipCounters();
-  walkTreeRecursiveSync(rootDir, (entry, fullPath) => {
+  walkTreeRecursiveSync(rootDir, (entry, fullPath, siblings) => {
     if (kept.isFull())
       return "stop";
     if (!chargeEntryBudget(budget))
       return "stop";
-    const { recurseInto, keepFile } = classifyEntry(entry, fullPath, cfg, probeCache, skipCounters);
+    const { recurseInto, keepFile } = classifyEntry(entry, fullPath, cfg, probeCache, skipCounters, siblings);
     if (recurseInto)
       return "recurse";
     if (keepFile)
@@ -369,7 +370,8 @@ function collectSourceFilesWithBudget(dir, options) {
     buildArtifactSkips: skipCounters.buildArtifactSkips,
     generatedDirSkips: skipCounters.generatedDirSkips,
     generatedNameOverrides: skipCounters.generatedNameOverrides,
-    generatedNameOnlySkips: skipCounters.generatedNameOnlySkips
+    generatedNameOnlySkips: skipCounters.generatedNameOnlySkips,
+    entriesVisited: budget.visited
   };
 }
 function collectSourceFiles(dir, options) {
@@ -385,11 +387,11 @@ async function collectSourceFilesWithBudgetAsync(dir, options) {
   const probeCache = createArtifactProbeCache();
   const budget = createEntryBudget(cfg.maxScanEntries);
   const skipCounters = createSourceWalkSkipCounters();
-  await walkTreeStackAsync(rootDir, (entry, fullPath) => {
+  await walkTreeStackAsync(rootDir, (entry, fullPath, siblings) => {
     options?.onEntryVisited?.();
     if (!chargeEntryBudget(budget))
       return "stop";
-    const { recurseInto, keepFile } = classifyEntry(entry, fullPath, cfg, probeCache, skipCounters);
+    const { recurseInto, keepFile } = classifyEntry(entry, fullPath, cfg, probeCache, skipCounters, siblings);
     if (recurseInto)
       return "recurse";
     if (keepFile) {
@@ -417,7 +419,8 @@ async function collectSourceFilesWithBudgetAsync(dir, options) {
     buildArtifactSkips: skipCounters.buildArtifactSkips,
     generatedDirSkips: skipCounters.generatedDirSkips,
     generatedNameOverrides: skipCounters.generatedNameOverrides,
-    generatedNameOnlySkips: skipCounters.generatedNameOnlySkips
+    generatedNameOnlySkips: skipCounters.generatedNameOnlySkips,
+    entriesVisited: budget.visited
   };
 }
 function getFilterStats(allFiles, filteredFiles) {

package/dist/{chunk-PHDMFAKM.js → chunk-DUO2TU77.js}

@@ -1,10 +1,10 @@
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
 import {
   findNearestDirWithMarker
-} from "./chunk-XVF2VVXP.js";
+} from "./chunk-5HSRT26B.js";
 import {
   isWindowsPath
-} from "./chunk-N2H3ZPZY.js";
+} from "./chunk-3RKP3FMS.js";
 
 // dist/clients/file-kinds.js
 import { basename, extname, win32 } from "node:path";

package/dist/{chunk-MRXKYPCS.js → chunk-EBC36LNN.js}

@@ -1,10 +1,10 @@
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
 import {
   createToolchainAvailability
-} from "./chunk-7DYBLXYA.js";
+} from "./chunk-HYGZEMX6.js";
 import {
   createSubsystemLogger
-} from "./chunk-XTMJ7XDT.js";
+} from "./chunk-POMLXPMY.js";
 
 // dist/clients/rust-client.js
 import * as path from "node:path";

package/dist/{chunk-CSHFH5IN.js → chunk-ED36RF6Y.js}

@@ -1,7 +1,7 @@
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
 import {
   isTestMode
-} from "./chunk-AOHZU2BM.js";
+} from "./chunk-YNE3RP52.js";
 
 // dist/clients/scanner-temp-root.js
 import * as os from "node:os";

package/dist/{chunk-76MWC2K6.js → chunk-EUXZEFTV.js}

@@ -1,17 +1,17 @@
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
 import {
   extractFactsFromTree
-} from "./chunk-GXW6K4YJ.js";
+} from "./chunk-T57LYLZT.js";
 import {
   findOwnerName
 } from "./chunk-5W3R6LFT.js";
 import {
   firstChildOfType,
   walk
-} from "./chunk-QHJ6DQ2R.js";
+} from "./chunk-US7ECLD7.js";
 import {
   isJstsFactFile
-} from "./chunk-PHDMFAKM.js";
+} from "./chunk-DUO2TU77.js";
 
 // dist/clients/dispatch/facts/function-facts.js
 var BOUNDARY_PREFIXES = [
@@ -123,64 +123,29 @@ function isCallPassThrough(stmt, paramNames) {
   }
   return { pass: true, target: (expr.children ?? [])[0]?.text };
 }
+function isDecisionPoint(type, children) {
+  if (COMPLEXITY_TYPES.has(type))
+    return true;
+  return type === "binary_expression" && children.some((c) => LOGICAL_OPERATORS.has(c?.type));
+}
 function calcCyclomaticComplexity(body) {
   let cc = 1;
   walk(body, (node) => {
-    if (COMPLEXITY_TYPES.has(node.type)) {
+    if (isDecisionPoint(node.type, node.children ?? []))
       cc++;
-    } else if (node.type === "binary_expression") {
-      if ((node.children ?? []).some((c) => LOGICAL_OPERATORS.has(c?.type))) {
-        cc++;
-      }
-    }
   });
   return cc;
 }
-function calcMaxNestingDepth(body) {
-  let maxDepth = 0;
-  const walkDepth = (node, depth) => {
-    if (depth > maxDepth)
-      maxDepth = depth;
-    const next = NESTING_TYPES.has(node.type) ? depth + 1 : depth;
-    for (const child of node.children ?? []) {
-      if (child)
-        walkDepth(child, next);
-    }
-  };
-  for (const child of body.children ?? []) {
-    if (child)
-      walkDepth(child, 0);
-  }
-  return maxDepth;
-}
-function collectOutgoingCalls(body) {
-  const calls = /* @__PURE__ */ new Set();
-  walk(body, (node) => {
-    if (node.type === "call_expression") {
-      const callee = (node.children ?? [])[0]?.text ?? "";
-      if (callee.length < 80)
-        calls.add(callee);
-    }
-  });
-  return [...calls];
+function memberCallSite(callee) {
+  if (callee?.type !== "member_expression")
+    return void 0;
+  const object = (callee.children ?? [])[0];
+  const property = (callee.children ?? []).find((c) => c?.type === "property_identifier");
+  if (object?.type !== "identifier" || !property)
+    return void 0;
+  return { receiver: object.text, method: property.text };
 }
-function collectMemberCallSites(body) {
-  const sites = [];
-  walk(body, (node) => {
-    if (node.type !== "call_expression")
-      return;
-    const callee = (node.children ?? [])[0];
-    if (!callee || callee.type !== "member_expression")
-      return;
-    const object = (callee.children ?? [])[0];
-    const property = (callee.children ?? []).find((c) => c?.type === "property_identifier");
-    if (!object || object.type !== "identifier" || !property)
-      return;
-    sites.push({ receiver: object.text, method: property.text });
-  });
-  return sites;
-}
-function collectReceiverTypes(body, params) {
+function parameterReceiverTypes(params) {
   const types = {};
   for (const param of params) {
     const id = firstNamedChild(param);
@@ -191,49 +156,75 @@ function collectReceiverTypes(body, params) {
     if (typeId)
       types[id.text] = typeId.text;
   }
-  walk(body, (node) => {
-    if (node.type !== "variable_declarator")
-      return;
-    const id = firstChildOfType(node, "identifier");
-    if (!id)
-      return;
-    const value = (node.children ?? []).find((c) => c?.type === "new_expression");
-    if (!value)
-      return;
-    const ctor = firstNamedChild(value);
-    if (ctor?.type === "identifier")
-      types[id.text] = ctor.text;
-  });
   return types;
 }
+function returnsAwaitedCall(stmt) {
+  const ret = firstNamedChild(stmt);
+  return ret?.type === "await_expression" && firstNamedChild(ret)?.type === "call_expression";
+}
+function addCallFacts(callee, calls, memberCallSites) {
+  const calleeText = callee?.text ?? "";
+  if (calleeText.length < 80)
+    calls.add(calleeText);
+  const site = memberCallSite(callee);
+  if (site)
+    memberCallSites.push(site);
+}
+function addNewReceiverType(children, receiverTypes) {
+  const id = children.find((c) => c?.type === "identifier");
+  const value = children.find((c) => c?.type === "new_expression");
+  const ctor = value ? firstNamedChild(value) : void 0;
+  if (id && ctor?.type === "identifier")
+    receiverTypes[id.text] = ctor.text;
+}
+function summarizeBody(body, params) {
+  let hasAwait = false;
+  let hasReturnAwaitCall = false;
+  let cyclomaticComplexity = 1;
+  let maxNestingDepth = 0;
+  const calls = /* @__PURE__ */ new Set();
+  const memberCallSites = [];
+  const receiverTypes = parameterReceiverTypes(params);
+  const visit = (node, depth) => {
+    const type = node.type;
+    const children = node.children ?? [];
+    if (depth > maxNestingDepth)
+      maxNestingDepth = depth;
+    if (isDecisionPoint(type, children))
+      cyclomaticComplexity++;
+    if (type === "await_expression") {
+      hasAwait = true;
+    } else if (type === "return_statement") {
+      if (returnsAwaitedCall(node))
+        hasReturnAwaitCall = true;
+    } else if (type === "call_expression") {
+      addCallFacts(children[0], calls, memberCallSites);
+    } else if (type === "variable_declarator") {
+      addNewReceiverType(children, receiverTypes);
+    }
+    const next = NESTING_TYPES.has(type) ? depth + 1 : depth;
+    for (const child of children) {
+      if (child)
+        visit(child, next);
+    }
+  };
+  visit(body, 0);
+  return {
+    hasAwait,
+    hasReturnAwaitCall,
+    cyclomaticComplexity,
+    maxNestingDepth,
+    outgoingCalls: [...calls],
+    memberCallSites,
+    receiverTypes
+  };
+}
 function hasExplicitPromiseReturnType(node) {
   const returnType = firstChildOfType(node, "type_annotation");
   if (!returnType)
     return false;
   return /:\s*Promise\b/.test(returnType.text);
 }
-function hasAwaitInNode(node) {
-  let found = false;
-  walk(node, (n) => {
-    if (n.type === "await_expression")
-      found = true;
-  });
-  return found;
-}
-function hasReturnAwaitCall(node) {
-  let found = false;
-  walk(node, (n) => {
-    if (n.type !== "return_statement")
-      return;
-    const ret = firstNamedChild(n);
-    if (ret?.type !== "await_expression")
-      return;
-    const awaited = firstNamedChild(ret);
-    if (awaited?.type === "call_expression")
-      found = true;
-  });
-  return found;
-}
 var functionFactProvider = {
   id: "fact.file.functions",
   provides: ["file.functionSummaries", "file.functionFactsCoverage"],
@@ -257,31 +248,33 @@ var functionFactProvider = {
         const target = passThrough.target ?? "";
         const lowerTarget = target.toLowerCase();
         const isBoundaryWrapper = BOUNDARY_PREFIXES.some((prefix) => lowerTarget.startsWith(prefix));
+        const bodySummary = summarizeBody(body, params);
         summaries.push({
           name: getFunctionName(node),
           line: node.startPosition.row + 1,
           column: node.startPosition.column + 1,
           endLine: body.endPosition.row + 1,
           isAsync: Boolean(firstChildOfType(node, "async")),
-          hasAwait: hasAwaitInNode(body),
-          hasReturnAwaitCall: hasReturnAwaitCall(body),
+          hasAwait: bodySummary.hasAwait,
+          hasReturnAwaitCall: bodySummary.hasReturnAwaitCall,
           statementCount,
           parameterCount: params.length,
           isPassThroughWrapper: passThrough.pass,
           passThroughTarget: passThrough.target,
           isBoundaryWrapper,
           hasExplicitPromiseReturnType: hasExplicitPromiseReturnType(node),
-          cyclomaticComplexity: calcCyclomaticComplexity(body),
-          maxNestingDepth: calcMaxNestingDepth(body),
-          outgoingCalls: collectOutgoingCalls(body),
-          memberCallSites: collectMemberCallSites(body),
-          receiverTypes: collectReceiverTypes(body, params)
+          cyclomaticComplexity: bodySummary.cyclomaticComplexity,
+          maxNestingDepth: bodySummary.maxNestingDepth,
+          outgoingCalls: bodySummary.outgoingCalls,
+          memberCallSites: bodySummary.memberCallSites,
+          receiverTypes: bodySummary.receiverTypes
         });
       };
       walk(root, (node) => {
-        if (FUNCTION_TYPES.has(node.type))
+        const type = node.type;
+        if (FUNCTION_TYPES.has(type))
           addSummary(node);
-        if (node.type === "class_declaration" || node.type === "interface_declaration") {
+        if (type === "class_declaration" || type === "interface_declaration") {
           const nameNode = firstChildOfType(node, "type_identifier") ?? firstChildOfType(node, "identifier");
           if (nameNode) {
             containers.push({

package/dist/{chunk-QOZXJ4NA.js → chunk-FM4RDMKT.js}

@@ -1973,7 +1973,7 @@ function readBlockScalar(state, parentIndent, props) {
         state.position = linePosition + column;
         throwError(state, "tab characters must not be used in indentation");
       }
-      if (column < maxLeadingIndent) {
+      if (column >= parentIndent && column < maxLeadingIndent) {
         state.position = linePosition + column;
         throwError(state, "bad indentation of a mapping entry");
       }
@@ -2183,13 +2183,16 @@ function readBlockMapping(state, nodeIndent, flowIndent, props) {
           ch = state.input.charCodeAt(++state.position);
           if (!isWsOrEolOrEnd(ch)) throwError(state, "a whitespace character is expected after the key-value separator within a block mapping");
           if (!mappingOpened) {
-            restoreState(state, beforeKey);
-            addMappingEvent(state, beforeKey.position, props.anchorStart, props.anchorEnd, props.tagStart, props.tagEnd, COLLECTION_STYLE.BLOCK);
+            state.events.splice(beforeKey.eventsLength, 0, {
+              type: EVENT_ID.MAPPING,
+              start: beforeKey.position,
+              anchorStart: props.anchorStart,
+              anchorEnd: props.anchorEnd,
+              tagStart: props.tagStart,
+              tagEnd: props.tagEnd,
+              style: COLLECTION_STYLE.BLOCK
+            });
             mappingOpened = true;
-            parseNode(state, flowIndent, CONTEXT_FLOW_OUT, false, true);
-            ch = state.input.charCodeAt(state.position);
-            while (isWhiteSpace(ch)) ch = state.input.charCodeAt(++state.position);
-            state.position++;
           }
           detected = true;
           atExplicitKey = false;
@@ -3360,5 +3363,5 @@ export {
 /*! Bundled license information:
 
 js-yaml/dist/js-yaml.mjs:
-  (*! js-yaml 5.4.2 https://github.com/nodeca/js-yaml @license MIT *)
+  (*! js-yaml 5.4.3 https://github.com/nodeca/js-yaml @license MIT *)
 */