@bendyline/docblocks 2.0.0 → 2.1.1

package/dist/{chunk-GCPBEMMH.js → chunk-BVY7GGNV.js}

@@ -1,10 +1,16 @@
 import {
   ELECTRON_FILE_SYSTEM_V2_CAPABILITIES,
   maybeGetDocBlocksHost
-} from "./chunk-RVQHY3XU.js";
+} from "./chunk-6XHOOBYF.js";
 import {
+  isRecord
+} from "./chunk-73OOROXH.js";
+import {
+  compareSnapshotsByPath,
+  compareText,
+  copyBytes,
   parseFileSystemVersion
-} from "./chunk-AYZ4HN5M.js";
+} from "./chunk-M62ZGJ5I.js";
 import {
   FsError,
   WORKSPACE_ROOT,
@@ -14,7 +20,7 @@ import {
   parseWorkspacePath,
   workspacePathBasename,
   workspacePathDirname
-} from "./chunk-SI2LU2RP.js";
+} from "./chunk-AYWKIZLD.js";
 
 // src/filesystem/electron-provider-v2.ts
 var fallbackInstanceSequence = 0;
@@ -327,7 +333,7 @@ function normalizeDirectoryListing(value, parent) {
     if (seen.has(entry.path)) throw new TypeError("Filesystem listing contained a duplicate path.");
     seen.add(entry.path);
   }
-  const ordered = [...entries].sort(compareDirectoryEntries);
+  const ordered = [...entries].sort(compareSnapshotsByPath);
   if (ordered.some((entry, index) => entry.path !== entries[index]?.path)) {
     throw new TypeError("Filesystem listing was not in canonical deterministic order.");
   }
@@ -439,13 +445,6 @@ function assertCapabilities(value, operation) {
     }
   }
 }
-function compareDirectoryEntries(left, right) {
-  if (left.kind !== right.kind) return left.kind === "directory" ? -1 : 1;
-  return compareText(left.path, right.path);
-}
-function compareText(left, right) {
-  return left < right ? -1 : left > right ? 1 : 0;
-}
 function isWatchOrigin(value) {
   return value === "local" || value === "external" || value === "unknown";
 }
@@ -458,9 +457,6 @@ function isNonNegativeSafeInteger(value) {
 function isPositiveSafeInteger(value) {
   return isNonNegativeSafeInteger(value) && value > 0;
 }
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
 function invalidTransport(operation, message) {
   return new FsError("io", message, { operation, retryable: false });
 }
@@ -477,12 +473,6 @@ function withOperation(error, operation) {
     retryable: error.retryable
   });
 }
-function copyBytes(data) {
-  const source = ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : new Uint8Array(data);
-  const copy = new Uint8Array(source.byteLength);
-  copy.set(source);
-  return copy.buffer;
-}
 function copyWireBuffer(data) {
   if (Object.prototype.toString.call(data) !== "[object ArrayBuffer]") {
     throw new TypeError("Expected an ArrayBuffer from the filesystem transport.");
@@ -560,4 +550,3 @@ export {
   ElectronFileSystemProviderV2,
   ElectronFileSystemProvider
 };
-//# sourceMappingURL=chunk-GCPBEMMH.js.map

package/dist/{chunk-AEHCVWU5.js → chunk-DZB666V7.js}

@@ -22,4 +22,3 @@ async function withFileCommitLock(key, operation) {
 export {
   withFileCommitLock
 };
-//# sourceMappingURL=chunk-AEHCVWU5.js.map

package/dist/{chunk-75UUF6C4.js → chunk-HI7QEWL6.js}

@@ -1,6 +1,6 @@
 import {
   tryParseWorkspacePath
-} from "./chunk-SI2LU2RP.js";
+} from "./chunk-AYWKIZLD.js";
 
 // src/mcp/types.ts
 var DOCBLOCKS_MCP_WIRE_VERSION = 1;
@@ -105,16 +105,22 @@ function parseDocumentSource(value) {
   if (!isRecord(value) || typeof value.kind !== "string") return null;
   switch (value.kind) {
     case "markdown": {
-      if (!hasExactKeys(value, ["kind", "markdown", "name"])) return null;
-      const { markdown, name } = value;
+      if (!hasExactKeys(value, ["kind", "markdown"]) && !hasExactKeys(value, ["kind", "markdown", "name"])) {
+        return null;
+      }
+      const { markdown } = value;
+      const name = Object.prototype.hasOwnProperty.call(value, "name") ? value.name : null;
       if (!isBoundedString(markdown, MCP_WIRE_LIMITS.documentCharacters) || !isNullableBoundedString(name, MCP_WIRE_LIMITS.labelCharacters)) {
         return null;
       }
       return { kind: "markdown", markdown, name };
     }
     case "file": {
-      if (!hasExactKeys(value, ["kind", "rootId", "path", "format"])) return null;
-      const { rootId, path, format } = value;
+      if (!hasExactKeys(value, ["kind", "rootId", "path"]) && !hasExactKeys(value, ["kind", "rootId", "path", "format"])) {
+        return null;
+      }
+      const { rootId, path } = value;
+      const format = Object.prototype.hasOwnProperty.call(value, "format") ? value.format : null;
       const parsedPath = parseNonRootWorkspacePath(path);
       if (!isIdentifier(rootId) || parsedPath === null || !(format === null || isFormat(format))) {
         return null;
@@ -126,8 +132,11 @@ function parseDocumentSource(value) {
       return { kind: "artifact", uri: value.uri };
     }
     case "bundle": {
-      if (!hasExactKeys(value, ["kind", "markdown", "assets", "name"])) return null;
-      const { markdown, name } = value;
+      if (!hasExactKeys(value, ["kind", "markdown", "assets"]) && !hasExactKeys(value, ["kind", "markdown", "assets", "name"])) {
+        return null;
+      }
+      const { markdown } = value;
+      const name = Object.prototype.hasOwnProperty.call(value, "name") ? value.name : null;
       if (!isBoundedString(markdown, MCP_WIRE_LIMITS.documentCharacters) || !isNullableBoundedString(name, MCP_WIRE_LIMITS.labelCharacters)) {
         return null;
       }
@@ -390,12 +399,12 @@ function parseComparisonResult(value) {
   };
 }
 function parseMaterializationOptions(value) {
-  if (!isRecord(value) || !hasExactKeys(value, ["rootId", "path", "ifExists", "expectedSha256"]) || !isIdentifier(value.rootId)) {
+  if (!isRecord(value) || !hasExactKeys(value, ["rootId", "path", "ifExists"]) && !hasExactKeys(value, ["rootId", "path", "ifExists", "expectedSha256"]) || !isIdentifier(value.rootId)) {
     return null;
   }
   const path = parseNonRootWorkspacePath(value.path);
   if (path === null) return null;
-  if (value.ifExists === "error" && value.expectedSha256 === null) {
+  if (value.ifExists === "error" && (value.expectedSha256 === null || !Object.prototype.hasOwnProperty.call(value, "expectedSha256"))) {
     return { rootId: value.rootId, path, ifExists: "error", expectedSha256: null };
   }
   if (value.ifExists === "replace" && isSha256(value.expectedSha256)) {
@@ -799,4 +808,3 @@ export {
   parseComparisonResult,
   parseMaterializationOptions
 };
-//# sourceMappingURL=chunk-75UUF6C4.js.map

package/dist/chunk-KQ6756AJ.js

@@ -0,0 +1,28 @@
+import {
+  workspacePathDirname
+} from "./chunk-AYWKIZLD.js";
+
+// src/filesystem/internal/parent-chain.ts
+function parentChain(path) {
+  const parents = [];
+  let current = workspacePathDirname(path);
+  while (current) {
+    parents.unshift(current);
+    current = workspacePathDirname(current);
+  }
+  return parents;
+}
+function parentChainWithRoot(path) {
+  const parents = [];
+  let current = workspacePathDirname(path);
+  while (true) {
+    parents.unshift(current);
+    if (!current) return parents;
+    current = workspacePathDirname(current);
+  }
+}
+
+export {
+  parentChain,
+  parentChainWithRoot
+};

package/dist/chunk-LMMOFRGQ.js

@@ -0,0 +1,148 @@
+// src/share/index.ts
+var SHARED_DOCUMENT_LIMITS = Object.freeze({
+  /** A conservative interoperability threshold, not a universal browser limit. */
+  portableUrlCharacters: 4096,
+  /** Hard cap applied before a hash is copied or decoded. */
+  urlCharacters: 32768,
+  /** Maximum UTF-8 Markdown accepted by the first-party link generator. */
+  markdownBytes: 20 * 1024,
+  /** Maximum compressed DBK bytes carried by the versioned envelope. */
+  archiveBytes: 23 * 1024
+});
+var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var HASH_PREFIX = "#shared(";
+var MAGIC = new Uint8Array([68, 66, 83, 72, 65, 82, 69]);
+var VERSION = 1;
+var HEADER_BYTES = MAGIC.byteLength + 2;
+var MODE_TO_CODE = Object.freeze({
+  slideshow: 1,
+  video: 2,
+  page: 3,
+  document: 4,
+  narrate: 5
+});
+var CODE_TO_MODE = Object.freeze({
+  1: "slideshow",
+  2: "video",
+  3: "page",
+  4: "document",
+  5: "narrate"
+});
+function createSharedDocumentHash(archive, mode = null) {
+  assertArchive(archive);
+  const bytes = new Uint8Array(HEADER_BYTES + archive.byteLength);
+  bytes.set(MAGIC, 0);
+  bytes[MAGIC.byteLength] = VERSION;
+  bytes[MAGIC.byteLength + 1] = mode === null ? 0 : MODE_TO_CODE[mode];
+  bytes.set(archive, HEADER_BYTES);
+  const hash = `${HASH_PREFIX}${encodeBase64(bytes)})`;
+  if (hash.length > SHARED_DOCUMENT_LIMITS.urlCharacters) {
+    throw new Error("The shared document payload exceeds the URL length limit.");
+  }
+  return hash;
+}
+function createSharedDocumentUrl(baseUrl, archive, mode = null) {
+  const url = new URL(baseUrl);
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("Shared document links require an HTTP(S) DocBlocks URL.");
+  }
+  url.hash = createSharedDocumentHash(archive, mode);
+  const result = url.toString();
+  if (result.length > SHARED_DOCUMENT_LIMITS.urlCharacters) {
+    throw new Error("The shared document link exceeds the URL length limit.");
+  }
+  return result;
+}
+function parseSharedDocumentHash(hash) {
+  if (!hash.startsWith("#shared")) return { kind: "none" };
+  if (hash.length > SHARED_DOCUMENT_LIMITS.urlCharacters || !hash.startsWith(HASH_PREFIX) || !hash.endsWith(")")) {
+    return invalid("This shared document link is malformed or too long.");
+  }
+  const encoded = hash.slice(HASH_PREFIX.length, -1);
+  const maximumPayloadBytes = HEADER_BYTES + SHARED_DOCUMENT_LIMITS.archiveBytes;
+  const maximumBase64Characters = Math.ceil(maximumPayloadBytes / 3) * 4;
+  if (encoded.length === 0 || encoded.length > maximumBase64Characters) {
+    return invalid("This shared document payload is empty or too large.");
+  }
+  const bytes = decodeBase64(encoded, maximumPayloadBytes);
+  if (!bytes || bytes.byteLength <= HEADER_BYTES) {
+    return invalid("This shared document payload is not valid base64 data.");
+  }
+  for (let index = 0; index < MAGIC.byteLength; index += 1) {
+    if (bytes[index] !== MAGIC[index]) {
+      return invalid("This shared document payload has an unknown format.");
+    }
+  }
+  if (bytes[MAGIC.byteLength] !== VERSION) {
+    return invalid("This shared document link uses an unsupported version.");
+  }
+  const modeCode = bytes[MAGIC.byteLength + 1] ?? 0;
+  const mode = modeCode === 0 ? null : CODE_TO_MODE[modeCode];
+  if (modeCode !== 0 && !mode) {
+    return invalid("This shared document link has an unsupported launch mode.");
+  }
+  const archive = bytes.slice(HEADER_BYTES);
+  if (!hasZipSignature(archive)) {
+    return invalid("This shared document payload does not contain a DBK archive.");
+  }
+  return { kind: "valid", payload: { archive, mode } };
+}
+function assertArchive(archive) {
+  if (archive.byteLength === 0 || archive.byteLength > SHARED_DOCUMENT_LIMITS.archiveBytes) {
+    throw new Error("The shared document archive exceeds the URL payload limit.");
+  }
+  if (!hasZipSignature(archive)) {
+    throw new Error("A shared document payload must contain a DBK ZIP archive.");
+  }
+}
+function hasZipSignature(bytes) {
+  return bytes.byteLength >= 4 && bytes[0] === 80 && bytes[1] === 75 && bytes[2] === 3 && bytes[3] === 4;
+}
+function invalid(message) {
+  return { kind: "invalid", message };
+}
+function encodeBase64(bytes) {
+  let result = "";
+  for (let index = 0; index < bytes.byteLength; index += 3) {
+    const first = bytes[index] ?? 0;
+    const hasSecond = index + 1 < bytes.byteLength;
+    const hasThird = index + 2 < bytes.byteLength;
+    const second = bytes[index + 1] ?? 0;
+    const third = bytes[index + 2] ?? 0;
+    const value = first << 16 | second << 8 | third;
+    result += BASE64_ALPHABET[value >>> 18 & 63];
+    result += BASE64_ALPHABET[value >>> 12 & 63];
+    result += hasSecond ? BASE64_ALPHABET[value >>> 6 & 63] : "=";
+    result += hasThird ? BASE64_ALPHABET[value & 63] : "=";
+  }
+  return result;
+}
+function decodeBase64(value, maximumBytes) {
+  if (value.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/u.test(value) || value.slice(0, -2).includes("=")) {
+    return null;
+  }
+  const padding = value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0;
+  const byteLength = value.length / 4 * 3 - padding;
+  if (byteLength <= 0 || byteLength > maximumBytes) return null;
+  const result = new Uint8Array(byteLength);
+  let outputIndex = 0;
+  for (let index = 0; index < value.length; index += 4) {
+    const a = BASE64_ALPHABET.indexOf(value[index] ?? "");
+    const b = BASE64_ALPHABET.indexOf(value[index + 1] ?? "");
+    const c = value[index + 2] === "=" ? 0 : BASE64_ALPHABET.indexOf(value[index + 2] ?? "");
+    const d = value[index + 3] === "=" ? 0 : BASE64_ALPHABET.indexOf(value[index + 3] ?? "");
+    if (a < 0 || b < 0 || c < 0 || d < 0) return null;
+    const combined = a << 18 | b << 12 | c << 6 | d;
+    if (outputIndex < byteLength) result[outputIndex++] = combined >>> 16 & 255;
+    if (outputIndex < byteLength) result[outputIndex++] = combined >>> 8 & 255;
+    if (outputIndex < byteLength) result[outputIndex++] = combined & 255;
+  }
+  return encodeBase64(result) === value ? result : null;
+}
+
+export {
+  SHARED_DOCUMENT_LIMITS,
+  createSharedDocumentHash,
+  createSharedDocumentUrl,
+  parseSharedDocumentHash
+};

package/dist/{chunk-FNW556FN.js → chunk-M2PUNKHS.js}

@@ -72,4 +72,3 @@ export {
   parseExternalHttpUrl,
   isTrustedRendererUrl
 };
-//# sourceMappingURL=chunk-FNW556FN.js.map

package/dist/chunk-M5ZNQGR5.js

@@ -0,0 +1,19 @@
+import {
+  FsError
+} from "./chunk-AYWKIZLD.js";
+
+// src/filesystem/utf8.ts
+function decodeUtf8Text(data, options = {}) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(data);
+  } catch {
+    throw new FsError("corrupt", `${options.label ?? "Text content"} is not valid UTF-8.`, {
+      operation: options.operation ?? "read",
+      path: options.path
+    });
+  }
+}
+
+export {
+  decodeUtf8Text
+};

package/dist/chunk-M62ZGJ5I.js

@@ -0,0 +1,51 @@
+// src/filesystem/v2.ts
+function parseFileSystemVersion(value) {
+  if (typeof value !== "string" || !value || value.length > 1024 || value.includes("\0")) {
+    throw new TypeError("Filesystem version tokens must be non-empty bounded strings.");
+  }
+  return value;
+}
+function tryParseFileSystemVersion(value) {
+  try {
+    return parseFileSystemVersion(value);
+  } catch {
+    return null;
+  }
+}
+
+// src/filesystem/internal/bytes.ts
+function copyBytes(data) {
+  const source = ArrayBuffer.isView(data) ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : new Uint8Array(data);
+  const copy = new Uint8Array(source.byteLength);
+  copy.set(source);
+  return copy.buffer;
+}
+function bytesEqual(left, right) {
+  const leftBytes = ArrayBuffer.isView(left) ? new Uint8Array(left.buffer, left.byteOffset, left.byteLength) : new Uint8Array(left);
+  const rightBytes = ArrayBuffer.isView(right) ? new Uint8Array(right.buffer, right.byteOffset, right.byteLength) : new Uint8Array(right);
+  if (leftBytes.byteLength !== rightBytes.byteLength) return false;
+  return leftBytes.every((byte, index) => byte === rightBytes[index]);
+}
+
+// src/filesystem/internal/entry-order.ts
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function compareSnapshotsByName(left, right) {
+  if (left.kind !== right.kind) return left.kind === "directory" ? -1 : 1;
+  return compareText(left.name, right.name);
+}
+function compareSnapshotsByPath(left, right) {
+  if (left.kind !== right.kind) return left.kind === "directory" ? -1 : 1;
+  return compareText(left.path, right.path);
+}
+
+export {
+  parseFileSystemVersion,
+  tryParseFileSystemVersion,
+  copyBytes,
+  bytesEqual,
+  compareText,
+  compareSnapshotsByName,
+  compareSnapshotsByPath
+};

package/dist/chunk-OQCPBOQA.js

@@ -0,0 +1,168 @@
+// src/filesystem/indexeddb-store.ts
+function indexedDBWorkspaceDatabaseName(workspaceId) {
+  return `docblocks-fs-${workspaceId}`;
+}
+function deleteIndexedDBDatabase(databaseName) {
+  if (typeof indexedDB === "undefined") {
+    return Promise.reject(new Error("IndexedDB is not available in this environment."));
+  }
+  return new Promise((resolve, reject) => {
+    const request = indexedDB.deleteDatabase(databaseName);
+    request.onsuccess = () => resolve();
+    request.onerror = () => reject(request.error ?? new Error(`Failed to delete the "${databaseName}" database.`));
+  });
+}
+function deleteIndexedDBWorkspaceData(workspaceId) {
+  return deleteIndexedDBDatabase(indexedDBWorkspaceDatabaseName(workspaceId));
+}
+var RawIndexedDBFileSystemStore = class {
+  constructor(databaseName, storeName) {
+    this.databaseName = databaseName;
+    this.storeName = storeName;
+    this.database = null;
+    this.opening = null;
+    this.closed = false;
+  }
+  async transaction(mode, operation) {
+    const database = await this.getDatabase();
+    const nativeTransaction = database.transaction(this.storeName, mode);
+    const completion = waitForTransaction(nativeTransaction);
+    const transaction = new RawIndexedDBFileSystemTransaction(
+      nativeTransaction.objectStore(this.storeName)
+    );
+    let result;
+    try {
+      result = await operation(transaction);
+    } catch (error) {
+      try {
+        nativeTransaction.abort();
+      } catch {
+      }
+      await completion.catch(() => void 0);
+      throw error;
+    }
+    await completion;
+    return result;
+  }
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.database?.close();
+    this.database = null;
+    this.opening = null;
+  }
+  getDatabase() {
+    if (this.closed) {
+      return Promise.reject(new Error("The IndexedDB filesystem store is closed."));
+    }
+    if (this.database) return Promise.resolve(this.database);
+    if (this.opening) return this.opening;
+    if (typeof indexedDB === "undefined") {
+      return Promise.reject(new Error("IndexedDB is not available in this environment."));
+    }
+    this.opening = openDatabaseWithStore(this.databaseName, this.storeName).then((database) => {
+      if (this.closed) {
+        database.close();
+        throw new Error("The IndexedDB filesystem store is closed.");
+      }
+      this.database = database;
+      this.opening = null;
+      database.onversionchange = () => {
+        database.close();
+        if (this.database === database) this.database = null;
+      };
+      return database;
+    }).catch((error) => {
+      this.opening = null;
+      throw error;
+    });
+    return this.opening;
+  }
+};
+var RawIndexedDBFileSystemTransaction = class {
+  constructor(store) {
+    this.store = store;
+  }
+  async get(key) {
+    const value = await requestResult(this.store.get(key));
+    return value === void 0 ? null : value;
+  }
+  async put(key, value) {
+    await requestResult(this.store.put(value, key));
+  }
+  async delete(key) {
+    await requestResult(this.store.delete(key));
+  }
+  async keys() {
+    const keys = await requestResult(this.store.getAllKeys());
+    return keys.map((key) => {
+      if (typeof key !== "string") {
+        throw new Error("The DocBlocks filesystem store contains a non-string key.");
+      }
+      return key;
+    });
+  }
+  async hasKeyWithPrefix(prefix) {
+    const cursor = await requestResult(this.store.openKeyCursor(IDBKeyRange.lowerBound(prefix)));
+    return cursor !== null && typeof cursor.key === "string" && cursor.key.startsWith(prefix);
+  }
+};
+async function openDatabaseWithStore(databaseName, storeName) {
+  const database = await openDatabase(databaseName, void 0, (upgradeDatabase) => {
+    if (!upgradeDatabase.objectStoreNames.contains(storeName)) {
+      upgradeDatabase.createObjectStore(storeName);
+    }
+  });
+  if (database.objectStoreNames.contains(storeName)) return database;
+  const nextVersion = database.version + 1;
+  database.close();
+  return openDatabase(databaseName, nextVersion, (upgradeDatabase) => {
+    if (!upgradeDatabase.objectStoreNames.contains(storeName)) {
+      upgradeDatabase.createObjectStore(storeName);
+    }
+  });
+}
+function openDatabase(databaseName, version, upgrade) {
+  return new Promise((resolve, reject) => {
+    const request = version === void 0 ? indexedDB.open(databaseName) : indexedDB.open(databaseName, version);
+    let settled = false;
+    request.onupgradeneeded = () => upgrade(request.result);
+    request.onsuccess = () => {
+      if (settled) {
+        request.result.close();
+        return;
+      }
+      settled = true;
+      resolve(request.result);
+    };
+    request.onerror = () => {
+      if (settled) return;
+      settled = true;
+      reject(request.error ?? new Error(`Could not open IndexedDB database ${databaseName}.`));
+    };
+    request.onblocked = () => {
+      if (settled) return;
+      settled = true;
+      reject(new Error(`IndexedDB database ${databaseName} is blocked by another open page.`));
+    };
+  });
+}
+function requestResult(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => resolve(request.result);
+    request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed."));
+  });
+}
+function waitForTransaction(transaction) {
+  return new Promise((resolve, reject) => {
+    transaction.oncomplete = () => resolve();
+    transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction was aborted."));
+    transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB transaction failed."));
+  });
+}
+
+export {
+  indexedDBWorkspaceDatabaseName,
+  deleteIndexedDBWorkspaceData,
+  RawIndexedDBFileSystemStore
+};

package/dist/{chunk-EGNDADXB.js → chunk-QI6YKTQV.js}

@@ -1,9 +1,9 @@
 import {
   parseWorkspacePath
-} from "./chunk-SI2LU2RP.js";
+} from "./chunk-AYWKIZLD.js";
 import {
   getFileSystemProviderV2
-} from "./chunk-EZKJZUNJ.js";
+} from "./chunk-XAMILHQP.js";
 
 // src/filesystem/move-error.ts
 function locationFromPresence(source, destination) {
@@ -108,4 +108,3 @@ export {
   describePartialMove,
   describeEntryMove
 };
-//# sourceMappingURL=chunk-EGNDADXB.js.map