@poe-platform/safe-bash 0.1.800 → 0.1.802

package/dist/image-ast/index.browser.js

@@ -47901,6 +47901,7 @@ function formatExtractedPageText(page, options = {}) {
       if (Math.abs(dy) > 4) return dy;
       return a.bbox[0] - b.bbox[0];
     });
+    const leftMargin = allLines.reduce((left, line) => Math.min(left, line.bbox[0]), Infinity);
     const rows = [];
     for (const l of allLines) {
       const lastRow = rows[rows.length - 1];
@@ -47914,17 +47915,17 @@ function formatExtractedPageText(page, options = {}) {
       row.sort((a, b) => a.bbox[0] - b.bbox[0]);
       const pitch = options.fixedPitch !== void 0 && options.fixedPitch > 0 ? options.fixedPitch : 6;
       let lineStr = "";
-      let curX = 0;
+      let curX = leftMargin;
       if (options.fixedPitch !== void 0 && options.fixedPitch > 0) {
         const words = row.flatMap((seg) => seg.words).sort((a, b) => a.bbox[0] - b.bbox[0]);
         for (const w of words) {
-          const spaces = Math.max(curX > 0 ? 1 : 0, Math.round((w.bbox[0] - curX) / pitch));
+          const spaces = Math.max(lineStr.length > 0 ? 1 : 0, Math.round((w.bbox[0] - curX) / pitch));
           lineStr += " ".repeat(Math.min(spaces, 80)) + w.text;
           curX = w.bbox[2];
         }
       } else {
         for (const seg of row) {
-          const spaces = Math.max(curX > 0 ? 2 : 0, Math.round((seg.bbox[0] - curX) / pitch));
+          const spaces = Math.max(lineStr.length > 0 ? 2 : 0, Math.round((seg.bbox[0] - curX) / pitch));
           lineStr += " ".repeat(Math.min(spaces, 40)) + seg.text;
           curX = seg.bbox[2];
         }
@@ -57693,16 +57694,31 @@ async function openFileDescriptor(path, options, capabilities, acquire) {
 }
 
 // ../safe-fs/dist/contracts/virtual-path.js
-var MAX_PATH_BYTES = 65536;
-var MAX_PATH_COMPONENTS = 2048;
-function validatePath(path, maxComponents = MAX_PATH_COMPONENTS) {
+function pathByteLength(path) {
+  let bytes = 0;
+  for (const point of path) {
+    const code = point.codePointAt(0);
+    bytes += code <= 127 ? 1 : code <= 2047 ? 2 : code <= 65535 ? 3 : 4;
+  }
+  return bytes;
+}
+function validatePath(path, limits = {}) {
+  const maxBytes = typeof limits === "number" ? Infinity : limits.maxPathBytes ?? Infinity;
+  const maxComponents = typeof limits === "number" ? limits : limits.maxPathComponents ?? Infinity;
+  for (const value of [maxBytes, maxComponents]) {
+    if (value !== Infinity && (!Number.isSafeInteger(value) || value < 0)) {
+      throw new RangeError("Path limits must be nonnegative safe integers or Infinity");
+    }
+  }
   if (typeof path !== "string" || path.includes("\0")) {
     throw new FsError("EINVAL", { syscall: "resolve", message: "paths must be strings without NUL bytes" });
   }
-  if (path.length > MAX_PATH_BYTES) {
+  if (maxBytes !== Infinity && pathByteLength(path) > maxBytes) {
     throw new FsError("ENAMETOOLONG", { syscall: "resolve", path });
   }
-  const limit = Math.min(maxComponents, MAX_PATH_COMPONENTS);
+  if (maxComponents === Infinity)
+    return;
+  const limit = maxComponents;
   let components2 = 0;
   let inComponent = false;
   for (let i = 0; i < path.length; i++) {
@@ -58351,11 +58367,14 @@ function components(path, signal) {
   }
   return result;
 }
-function resolveMissingTarget(root, path, signal) {
+function resolveMissingTarget(root, path, signal, limits = {}) {
+  validatePath(path, limits);
   const fail3 = (code, failedPath = path) => {
     throw new FsError(code, { syscall: "realpath", path: failedPath });
   };
   const origin = components(path, signal);
+  let remainingBytes = (limits.maxPathBytes ?? Infinity) - pathByteLength(path);
+  let remainingComponents = (limits.maxPathComponents ?? Infinity) - origin.length;
   const initial = { node: root, name: "" };
   let position = initial;
   let links = 0;
@@ -58408,7 +58427,10 @@ function resolveMissingTarget(root, path, signal) {
       if (node.type === "symlink") {
         if (++links > 40)
           return fail3("ELOOP");
+        validatePath(node.target, { maxPathBytes: remainingBytes, maxPathComponents: remainingComponents });
         const names2 = components(node.target, signal);
+        remainingBytes -= pathByteLength(node.target);
+        remainingComponents -= names2.length;
         if (node.target.endsWith("/"))
           names2.push({ name: ".", start: node.target.length });
         if (node.target.startsWith("/"))
@@ -58612,26 +58634,22 @@ function readConfigRecord(value, label, keys) {
 
 // ../safe-fs/dist/fs/memory/limits.js
 var defaultMemoryFileSystemLimits = Object.freeze({
+  maxPathBytes: Infinity,
+  maxPathComponents: Infinity,
   maxFileBytes: Infinity,
   maxRetainedBytes: Infinity,
   maxMetadataUnits: Infinity
 });
 function normalizeMemoryFileSystemLimits(options) {
-  const keys = ["maxFileBytes", "maxRetainedBytes", "maxMetadataUnits"];
+  const keys = ["maxPathBytes", "maxPathComponents", "maxFileBytes", "maxRetainedBytes", "maxMetadataUnits"];
   const record2 = readConfigRecord(options, "memory option", [...keys, "maxBytes"]);
   const limits = { ...defaultMemoryFileSystemLimits };
-  if (Object.hasOwn(record2, "maxBytes") && record2.maxBytes !== void 0) {
-    if (typeof record2.maxBytes !== "number" || !Number.isSafeInteger(record2.maxBytes) || record2.maxBytes < 0) {
-      throw new RangeError("maxBytes must be a nonnegative safe integer");
-    }
-    limits.maxBytes = record2.maxBytes;
-  }
-  for (const key of keys) {
-    if (!Object.hasOwn(record2, key))
-      continue;
+  for (const key of [...keys, "maxBytes"]) {
     const value = record2[key];
+    if (value === void 0 || value === Infinity)
+      continue;
     if (typeof value !== "number" || !Number.isSafeInteger(value) || value < (key === "maxMetadataUnits" ? 1 : 0)) {
-      throw new RangeError(`${key} must be a ${key === "maxMetadataUnits" ? "positive" : "nonnegative"} safe integer`);
+      throw new RangeError(`${key} must be a ${key === "maxMetadataUnits" ? "positive" : "nonnegative"} safe integer or Infinity`);
     }
     limits[key] = value;
   }
@@ -58680,12 +58698,10 @@ var DUMMY_POOL_FILE_NODE = new MemoryFileNode(0, 0, null, 0, DUMMY_POOL_ALLOCATI
 DUMMY_POOL_FILE_NODE.atimeMs = DUMMY_POOL_FILE_NODE.mtimeMs = DUMMY_POOL_FILE_NODE.ctimeMs = DUMMY_POOL_FILE_NODE.birthtimeMs = 17e11;
 var defaultDateNow = Date.now;
 var fastWriteCachedNow = Date.now();
-var lastFastMapMiss = {
-  map: void 0,
-  key: "",
-  slot: -1
-};
 var FastDirectoryEntriesMap = class {
+  // Keep speculative slots local so a failed write cannot pin a tenant globally.
+  _missKey = "";
+  _missSlot = -1;
   _table = new Int16Array(128).fill(-1);
   _mask = 127;
   _keys = new Array(64).fill("");
@@ -58722,9 +58738,8 @@ var FastDirectoryEntriesMap = class {
   getForWriteWithHash(k, h) {
     let slot = h & this._mask;
     if (this.size === 0) {
-      lastFastMapMiss.map = this;
-      lastFastMapMiss.key = k;
-      lastFastMapMiss.slot = slot;
+      this._missKey = k;
+      this._missSlot = slot;
       return void 0;
     }
     const mask = this._mask;
@@ -58734,9 +58749,8 @@ var FastDirectoryEntriesMap = class {
     while (true) {
       const idx = table[slot];
       if (idx === -1) {
-        lastFastMapMiss.map = this;
-        lastFastMapMiss.key = k;
-        lastFastMapMiss.slot = firstDeleted !== -1 ? firstDeleted : slot;
+        this._missKey = k;
+        this._missSlot = firstDeleted !== -1 ? firstDeleted : slot;
         return void 0;
       }
       if (idx === -2) {
@@ -58785,6 +58799,7 @@ var FastDirectoryEntriesMap = class {
     return this.get(k) !== void 0;
   }
   _rebuild(newCap) {
+    this._missKey = "";
     const newTableLen = newCap * 2;
     const newMask = newTableLen - 1;
     const newTable = newCap <= 16384 ? new Int16Array(newTableLen).fill(-1) : new Int32Array(newTableLen).fill(-1);
@@ -58824,15 +58839,16 @@ var FastDirectoryEntriesMap = class {
     this._next = writeIdx;
   }
   set(k, v) {
-    if (this === lastFastMapMiss.map && k === lastFastMapMiss.key && this._next < this._keys.length) {
+    if (k === this._missKey && this._next < this._keys.length) {
       const entryIdx = this._next++;
-      this._table[lastFastMapMiss.slot] = entryIdx;
+      this._table[this._missSlot] = entryIdx;
       this._keys[entryIdx] = k;
       this._vals[entryIdx] = v;
       this.size++;
-      lastFastMapMiss.map = void 0;
+      this._missKey = "";
       return this;
     }
+    this._missKey = "";
     if (this._next >= this._keys.length) {
       this._rebuild(this.size * 2 <= this._keys.length ? this._keys.length : this._keys.length * 2);
     }
@@ -58863,6 +58879,7 @@ var FastDirectoryEntriesMap = class {
     }
   }
   delete(k) {
+    this._missKey = "";
     if (this.size === 0)
       return false;
     let slot = this._hash(k);
@@ -58888,6 +58905,7 @@ var FastDirectoryEntriesMap = class {
     }
   }
   clear() {
+    this._missKey = "";
     if (this._next > 0) {
       this._table.fill(-1);
       for (let i = 0; i < this._next; i++) {
@@ -59340,7 +59358,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     const owner = ownedStores.get(this);
     if (path !== "")
       this.validatePath(path, "realpath");
-    return resolveMissingTarget(owner.root, path || ".", options.signal);
+    return resolveMissingTarget(owner.root, path || ".", options.signal, this.ledger.limits);
   }
   async confineExtraction(roots, options = {}) {
     options.signal?.throwIfAborted();
@@ -59561,6 +59579,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
   }
   replaceData(node, allocation, length = allocation.data.byteLength) {
     const previous = node.allocation;
+    node.sourceRef = void 0;
     this.totalBytes += length - node.byteLength;
     node.byteLength = length;
     node.view = length === allocation.data.byteLength ? allocation.data : void 0;
@@ -59593,6 +59612,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
       this.fail("EINVAL", syscall, path);
     if (path.length === 0)
       this.fail("ENOENT", syscall, path);
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path, this.ledger.limits);
   }
   permission(node, mask, syscall, path) {
     if ((node.mode >> 6 & mask) !== mask)
@@ -59614,6 +59635,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
     node.mtimeMs = node.ctimeMs = now;
   }
   resolveNode(path, syscall, followFinal = true) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path, this.ledger.limits);
     const cache = memoryCaches.get(this.ledger);
     if (this.symlinkCount === 0 && isCleanAbsolutePath(path)) {
       const fastDir = cache.lastFastDirNode;
@@ -59698,7 +59721,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
         start = slash + 1;
       }
     }
-    let remainingPathUnits = 65536 - path.length;
+    let remainingPathUnits = this.ledger.limits.maxPathBytes - pathByteLength(path);
     if (remainingPathUnits < 0)
       this.fail("ENAMETOOLONG", syscall, path);
     let initialComponents = 0;
@@ -59708,12 +59731,12 @@ var MemoryFileSystem = class _MemoryFileSystem {
         inComp = false;
       else if (!inComp) {
         inComp = true;
-        if (++initialComponents > 256)
+        if (++initialComponents > this.ledger.limits.maxPathComponents)
           this.fail("ENAMETOOLONG", syscall, path);
       }
     }
-    const pending = path.split("/").filter(Boolean);
-    let remainingComponents = 256 - pending.length;
+    let pending = path.split("/").filter(Boolean);
+    let remainingComponents = this.ledger.limits.maxPathComponents - pending.length;
     if (path.endsWith("/"))
       pending.push("");
     const stack = [{ node: this.root, name: "" }];
@@ -59763,9 +59786,9 @@ var MemoryFileSystem = class _MemoryFileSystem {
       if (node.type === "symlink" && (options.followFinal !== false || pending.length > 0)) {
         if (++links > 40)
           this.fail("ELOOP", syscall, path);
-        if (node.target.length > remainingPathUnits)
+        if (pathByteLength(node.target) > remainingPathUnits)
           this.fail("ENAMETOOLONG", syscall, path);
-        remainingPathUnits -= node.target.length;
+        remainingPathUnits -= pathByteLength(node.target);
         const target = node.target.split("/").filter(Boolean);
         if (target.length > remainingComponents)
           this.fail("ENAMETOOLONG", syscall, path);
@@ -59774,7 +59797,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
           target.push("");
         if (options.resizeCreate !== void 0 && target.at(-1) === "" && pending[0] === "")
           target.pop();
-        pending.unshift(...target);
+        pending = target.concat(pending);
         if (node.target.startsWith("/"))
           stack.splice(1);
         continue;
@@ -59790,6 +59813,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
     };
   }
   file(path, syscall) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path, this.ledger.limits);
     if (this.symlinkCount === 0 && path.charCodeAt(0) === 47 && path.length > 1 && path.indexOf("/", 1) === -1 && !path.includes("\0")) {
       const name = path === _lastFileSlice1Path ? _lastFileSlice1Name : (_lastFileSlice1Path = path, _lastFileSlice1Name = path.slice(1));
       if (name !== "." && name !== "..") {
@@ -60064,6 +60089,8 @@ var MemoryFileSystem = class _MemoryFileSystem {
     }, syscall, path);
   }
   writeData(path, data, options, syscall) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path, this.ledger.limits);
     if (!(data instanceof Uint8Array))
       throw new TypeError("Memory files require Uint8Array data");
     const target = this.prepareWrite(path, options, syscall);
@@ -60177,12 +60204,15 @@ var MemoryFileSystem = class _MemoryFileSystem {
       node.byteLength = length;
       node.view = length === allocation.data.byteLength ? allocation.data : void 0;
     }
+    node.sourceRef = void 0;
     this.changed(node, now);
   }
   writeMemoryFileFast(path, data, append, mode) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(path, this.ledger.limits);
     const cache = memoryCaches.get(this.ledger);
     const syscall = append ? "appendFile" : "writeFile";
-    if (append && path === cache.lastFastFilePath && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 1) !== 0 && (cache.lastFastFileNode.mode & 2) !== 0) {
+    if (append && path === cache.lastFastFilePath && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 64) !== 0 && (cache.lastFastFileNode.mode & 128) !== 0) {
       const current2 = cache.lastFastFileNode;
       const length2 = current2.byteLength + data.byteLength;
       this.admitSize(current2, length2, syscall, path);
@@ -60196,7 +60226,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     let name = "";
     const cachedPrefix = cache.lastFastDirPrefix;
     const cachedDir = cache.lastFastDirNode;
-    if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 1) !== 0 && cachedPrefix.length > 1 && path.startsWith(cachedPrefix) && path.indexOf("/", cachedPrefix.length) === -1) {
+    if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 64) !== 0 && cachedPrefix.length > 1 && path.startsWith(cachedPrefix) && path.indexOf("/", cachedPrefix.length) === -1) {
       parent = cachedDir;
       name = path.slice(cachedPrefix.length);
       if (exceedsComponentByteLimit2(name))
@@ -60209,7 +60239,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
           name = path.slice(start);
           if (exceedsComponentByteLimit2(name))
             this.fail("ENAMETOOLONG", syscall, path);
-          if (start > 1 && (parent.mode & 1) !== 0) {
+          if (start > 1 && (parent.mode & 64) !== 0) {
             cache.lastFastDirPrefix = path.slice(0, start);
             cache.lastFastDirNode = parent;
           }
@@ -60329,6 +60359,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
         let ino = this.nextInode;
         this.nextInode = ino + batchCount;
         let nextIdx = 1;
+        entries2._missKey = "";
         entries2._next = 1 + batchCount;
         entries2.size = 1 + batchCount;
         const table = entries2._table;
@@ -60378,12 +60409,15 @@ var MemoryFileSystem = class _MemoryFileSystem {
     }
   }
   writeMemoryFileInDirFast(dirPrefix, name, data, append, mode, nameHash) {
+    if (this.ledger.limits.maxPathBytes !== Infinity || this.ledger.limits.maxPathComponents !== Infinity)
+      validatePath(dirPrefix + name, this.ledger.limits);
     const cache = this._cache;
     if (!append && dirPrefix === cache.lastFastDirPrefix && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 192) === 192 && name.length <= 85 && this.ledger.hasInfiniteRetained && this.ledger.hasInfiniteFileBytes && this.ledger.limits.maxBytes === void 0 && sharedFileNodePoolLen > 0) {
       const parent = cache.lastFastDirNode;
       const entries2 = parent.entries;
       const existing = nameHash !== void 0 ? entries2.getForWriteWithHash(name, nameHash) : entries2.getForWrite(name);
       if (existing === void 0 && entries2._next < entries2._keys.length) {
+        this.ledger.reserve(name.length * 2, 2, "writeFile", name);
         const now = fastWriteCachedNow;
         const length = data.byteLength;
         const node = sharedFileNodePool[--sharedFileNodePoolLen];
@@ -60405,13 +60439,11 @@ var MemoryFileSystem = class _MemoryFileSystem {
         node.allocation = DUMMY_POOL_ALLOCATION;
         node.sourceRef = node.data.subarray(0);
         const entryIdx = entries2._next++;
-        entries2._table[lastFastMapMiss.slot] = entryIdx;
+        entries2._table[entries2._missSlot] = entryIdx;
         entries2._keys[entryIdx] = name;
         entries2._vals[entryIdx] = node;
         entries2.size++;
-        lastFastMapMiss.map = void 0;
-        lastFastMapMiss.key = "";
-        this.ledger.reserve(name.length * 2, 2, "writeFile", name);
+        entries2._missKey = "";
         this.totalBytes += length;
         this.mutationTick = this.mutationTick + 1 | 0;
         parent.revision = parent.revision < 1073741823 ? parent.revision + 1 | 0 : Math.min(Number.MAX_SAFE_INTEGER + 1, parent.revision + 1);
@@ -60424,7 +60456,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
     }
     const syscall = append ? "appendFile" : "writeFile";
     try {
-      if (append && dirPrefix === cache.lastFastDirPrefix && name === cache.lastFastFileName && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 1) !== 0 && (cache.lastFastFileNode.mode & 2) !== 0) {
+      if (append && dirPrefix === cache.lastFastDirPrefix && name === cache.lastFastFileName && cache.lastFastFileNode !== void 0 && cache.lastFastFileNode.nlink !== 0 && cache.lastFastDirNode !== void 0 && cache.lastFastDirNode.nlink !== 0 && (cache.lastFastDirNode.mode & 64) !== 0 && (cache.lastFastFileNode.mode & 128) !== 0) {
         const current2 = cache.lastFastFileNode;
         const length2 = current2.byteLength + data.byteLength;
         this.admitSize(current2, length2, syscall, name);
@@ -60435,7 +60467,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
       }
       let parent = this.root;
       const cachedDir = cache.lastFastDirNode;
-      if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 1) !== 0 && dirPrefix === cache.lastFastDirPrefix) {
+      if (cachedDir !== void 0 && cachedDir.nlink !== 0 && (cachedDir.mode & 64) !== 0 && dirPrefix === cache.lastFastDirPrefix) {
         parent = cachedDir;
         if (exceedsComponentByteLimit2(name))
           this.fail("ENAMETOOLONG", syscall, name);
@@ -60460,7 +60492,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
         this.permission(parent, 1, syscall, name);
         if (exceedsComponentByteLimit2(name))
           this.fail("ENAMETOOLONG", syscall, name);
-        if (dirPrefix.length > 1 && (parent.mode & 1) !== 0) {
+        if (dirPrefix.length > 1 && (parent.mode & 64) !== 0) {
           cache.lastFastDirPrefix = dirPrefix;
           cache.lastFastDirNode = parent;
         }
@@ -60536,11 +60568,7 @@ var MemoryFileSystem = class _MemoryFileSystem {
             cache.lastFastFilePath = "";
             cache.lastFastFileName = name;
             cache.lastFastFileNode = node;
-            lastFastMapMiss.map = void 0;
-            lastFastMapMiss.key = "";
           } catch (error) {
-            lastFastMapMiss.map = void 0;
-            lastFastMapMiss.key = "";
             this.ledger.release(nameBytes, 2);
             throw error;
           }
@@ -62534,27 +62562,42 @@ function* parseXmlSteps(input, limits = {}) {
       throw new XmlLimitError("maxContentNodes", "XML content node limit exceeded");
   };
   let pendingWork = 0;
-  const skipWhitespace = () => {
+  const skipWhitespace = function* () {
     const start2 = offset;
     while (offset < source.length) {
       const c = source.charCodeAt(offset);
       if (c !== 32 && c !== 9 && c !== 10 && c !== 13)
         break;
       offset++;
+      pendingWork++;
+      if (pendingWork >= 512) {
+        yield 512;
+        pendingWork -= 512;
+      }
     }
     return offset - start2;
   };
-  const scanName = () => {
+  const scanName = function* () {
     const start2 = offset;
     while (offset < source.length) {
       const c = source.charCodeAt(offset);
       if (c === 32 || c === 9 || c === 13 || c === 10 || c === 47 || c === 61 || c === 62 || c === 63)
         break;
       offset++;
+      pendingWork++;
+      if (pendingWork >= 512) {
+        yield 512;
+        pendingWork -= 512;
+      }
     }
     const name = source.slice(start2, offset);
+    pendingWork += offset - start2;
+    while (pendingWork >= 512) {
+      yield 512;
+      pendingWork -= 512;
+    }
     const [prefix, localName] = qualifiedNameSync(name, qualifiedNames);
-    return [name, prefix, localName, (offset - start2) * 2];
+    return [name, prefix, localName];
   };
   while (offset < source.length) {
     pendingWork += 1;
@@ -62591,11 +62634,15 @@ function* parseXmlSteps(input, limits = {}) {
         }
       } else {
         for (let index = 0; index < resolved.length; index++) {
+          pendingWork++;
+          if (pendingWork >= 512) {
+            yield 512;
+            pendingWork -= 512;
+          }
           const c = resolved.charCodeAt(index);
           if (c !== 32 && c !== 9 && c !== 13 && c !== 10)
             invalid("text outside the root");
         }
-        pendingWork += resolved.length;
         while (pendingWork >= 512) {
           yield 512;
           pendingWork -= 512;
@@ -62637,8 +62684,7 @@ function* parseXmlSteps(input, limits = {}) {
     } else if (source.startsWith("<?", offset)) {
       const start2 = offset;
       offset += 2;
-      const [target, , , wName] = scanName();
-      pendingWork += wName;
+      const [target] = yield* scanName();
       while (pendingWork >= 512) {
         yield 512;
         pendingWork -= 512;
@@ -62677,8 +62723,8 @@ function* parseXmlSteps(input, limits = {}) {
       invalid("DTD and entity declarations are forbidden");
     } else if (source.charCodeAt(offset + 1) === 47) {
       offset += 2;
-      const [name, , , wName] = scanName();
-      pendingWork += wName + skipWhitespace();
+      const [name] = yield* scanName();
+      yield* skipWhitespace();
       while (pendingWork >= 512) {
         yield 512;
         pendingWork -= 512;
@@ -62691,10 +62737,11 @@ function* parseXmlSteps(input, limits = {}) {
     } else {
       offset++;
       const repeated = previousEmpty && source.startsWith(previousEmpty.suffix, offset) ? previousEmpty : void 0;
-      const [name, prefix, localName, wName] = repeated ? [repeated.name, repeated.prefix, repeated.localName, repeated.name.length * 2] : scanName();
+      const [name, prefix, localName] = repeated ? [repeated.name, repeated.prefix, repeated.localName] : yield* scanName();
       if (repeated)
         offset += name.length;
-      pendingWork += wName;
+      if (repeated)
+        pendingWork += name.length * 2;
       while (pendingWork >= 512) {
         yield 512;
         pendingWork -= 512;
@@ -62704,8 +62751,7 @@ function* parseXmlSteps(input, limits = {}) {
       let namespaces = stack.at(-1)?.namespaces ?? /* @__PURE__ */ new Map([["xml", xmlNamespace]]);
       let ownsNamespaces = stack.length === 0;
       while (!repeated) {
-        const ws = skipWhitespace();
-        pendingWork += ws;
+        const ws = yield* skipWhitespace();
         while (pendingWork >= 512) {
           yield 512;
           pendingWork -= 512;
@@ -62715,8 +62761,7 @@ function* parseXmlSteps(input, limits = {}) {
           break;
         if (ws === 0)
           invalid("attributes require whitespace");
-        const [attribute, attrPrefix, attrLocal, wAttr] = scanName();
-        pendingWork += wAttr;
+        const [attribute, attrPrefix, attrLocal] = yield* scanName();
         while (pendingWork >= 512) {
           yield 512;
           pendingWork -= 512;
@@ -62727,10 +62772,10 @@ function* parseXmlSteps(input, limits = {}) {
           throw new XmlLimitError("maxAttributes", "XML attribute limit exceeded");
         if ((attributes?.size ?? 0) >= maxAttributesPerElement)
           throw new XmlLimitError("maxAttributesPerElement", "XML attribute limit exceeded");
-        pendingWork += skipWhitespace();
+        yield* skipWhitespace();
         if (source[offset++] !== "=")
           invalid("missing attribute equals");
-        pendingWork += skipWhitespace();
+        yield* skipWhitespace();
         const quote = source[offset++];
         if (quote !== '"' && quote !== "'")
           invalid("unquoted attribute");
@@ -62917,14 +62962,13 @@ function scalar(element) {
 
 // ../safe-fs/dist/fs/webdav/webdav.js
 var timestampNamespace = "urn:virtual-bash:metadata";
-var maxTimestampPropertyBytes = 4096;
-function preflightTimestamps(property) {
+function preflightTimestamps(property, maxTimestampPropertyBytes) {
   let bytes = 0;
   for (const point of property.text) {
     const code = point.codePointAt(0);
     bytes += code <= 127 ? 1 : code <= 2047 ? 2 : code <= 65535 ? 3 : 4;
     if (bytes > maxTimestampPropertyBytes)
-      throw new Error("timestamp property exceeds 4KiB limit");
+      throw new Error("timestamp property exceeds byte limit");
   }
   const text = scalar(property);
   let offset = 0;
@@ -63165,6 +63209,7 @@ var WebDavFileSystem = class {
   headers;
   maxResponseBytes;
   maxXmlBytes;
+  maxTimestampPropertyBytes;
   maxEntries;
   xmlLimits;
   timeoutMs;
@@ -63234,6 +63279,7 @@ var WebDavFileSystem = class {
       streamingAppend: this.requestStreamSupport !== false
     });
     this.maxResponseBytes = options.maxResponseBytes === void 0 ? Infinity : positive(options.maxResponseBytes, "maxResponseBytes", false, true);
+    this.maxTimestampPropertyBytes = positive(options.maxTimestampPropertyBytes ?? Infinity, "maxTimestampPropertyBytes", true, true);
     this.maxXmlBytes = options.maxXmlBytes === void 0 ? Infinity : positive(options.maxXmlBytes, "maxXmlBytes", false, true);
     this.xmlLimits = Object.freeze({ ...options.xmlLimits });
     for (const [name, value] of Object.entries(this.xmlLimits))
@@ -63669,7 +63715,7 @@ var WebDavFileSystem = class {
     let mtimeMs = date("getlastmodified") ?? 0;
     let atimeMs = 0;
     if (timestampProperty) {
-      const timestamps = JSON.parse(preflightTimestamps(timestampProperty));
+      const timestamps = JSON.parse(preflightTimestamps(timestampProperty, this.maxTimestampPropertyBytes));
       if (typeof timestamps !== "object" || timestamps === null || !("version" in timestamps) || timestamps.version !== 1 || !("etag" in timestamps) || typeof timestamps.etag !== "string" || !/^"[\x21\x23-\x7e\x80-\xff]*"$/.test(timestamps.etag) || !("type" in timestamps) || timestamps.type !== "file" && timestamps.type !== "directory" || !("atimeMs" in timestamps) || typeof timestamps.atimeMs !== "number" || !Number.isFinite(timestamps.atimeMs) || Math.abs(timestamps.atimeMs) > 864e13 || !("mtimeMs" in timestamps) || typeof timestamps.mtimeMs !== "number" || !Number.isFinite(timestamps.mtimeMs) || Math.abs(timestamps.mtimeMs) > 864e13)
         throw new Error("invalid timestamp property");
       if (timestamps.etag === validator && timestamps.type === (directory ? "directory" : "file")) {