@tnotesjs/core 0.6.0 → 0.7.0

package/dist/workspace/index.cjs

@@ -1,1207 +1,9 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkIHFUHB4Jcjs = require('../chunk-IHFUHB4J.cjs');
 
+var _chunkAGVER5MXcjs = require('../chunk-AGVER5MX.cjs');
+require('../chunk-7FEANCT6.cjs');
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-var _chunk3R7QSABBcjs = require('../chunk-3R7QSABB.cjs');
-require('../chunk-HXED7KVT.cjs');
-
-// workspace/workspace.ts
-var _crypto = require('crypto');
-var _promises = require('fs/promises'); var _promises2 = _interopRequireDefault(_promises);
-var _path = require('path'); var _path2 = _interopRequireDefault(_path);
-
-// workspace/atomic.ts
-
-var _fs = require('fs');
-
-
-
-// workspace/errors.ts
-var WorkspaceError = class extends Error {
-  constructor(code, message, details) {
-    super(message);
-    this.name = "WorkspaceError";
-    this.code = code;
-    this.details = details;
-  }
-};
-
-// workspace/atomic.ts
-async function pathExists(filePath) {
-  try {
-    await _promises2.default.access(filePath, _fs.constants.F_OK);
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-async function stageWrite(write) {
-  await _promises2.default.mkdir(_path2.default.dirname(write.path), { recursive: true });
-  const temporaryPath = _path2.default.join(
-    _path2.default.dirname(write.path),
-    `.${_path2.default.basename(write.path)}.${_crypto.randomUUID.call(void 0, )}.tmp`
-  );
-  const handle = await _promises2.default.open(temporaryPath, "wx");
-  try {
-    await handle.writeFile(write.data);
-    await handle.sync();
-  } finally {
-    await handle.close();
-  }
-  return temporaryPath;
-}
-async function restoreOriginals(originals) {
-  for (const original of originals) {
-    if (original.existed && original.data) {
-      const restorePath = await stageWrite({
-        path: original.path,
-        data: original.data
-      });
-      await _promises2.default.rename(restorePath, original.path);
-    } else {
-      await _promises2.default.rm(original.path, { force: true });
-    }
-  }
-}
-async function writeFilesAtomically(writes) {
-  const uniqueWrites = /* @__PURE__ */ new Map();
-  for (const write of writes) uniqueWrites.set(write.path, write);
-  const normalizedWrites = [...uniqueWrites.values()];
-  const originals = [];
-  const staged = [];
-  try {
-    for (const write of normalizedWrites) {
-      const existed = await pathExists(write.path);
-      originals.push({
-        path: write.path,
-        existed,
-        data: existed ? await _promises2.default.readFile(write.path) : void 0
-      });
-      staged.push({
-        target: write.path,
-        temporary: await stageWrite(write)
-      });
-    }
-    for (const item of staged) {
-      await _promises2.default.rename(item.temporary, item.target);
-    }
-  } catch (error) {
-    await Promise.allSettled(
-      staged.map((item) => _promises2.default.rm(item.temporary, { force: true }))
-    );
-    try {
-      await restoreOriginals(originals);
-    } catch (restoreError) {
-      throw new WorkspaceError(
-        "FILESYSTEM_ERROR",
-        "\u5199\u5165\u5931\u8D25\uFF0C\u5E76\u4E14\u65E0\u6CD5\u5B8C\u6574\u6062\u590D\u539F\u6587\u4EF6",
-        {
-          cause: error instanceof Error ? error.message : String(error),
-          restoreCause: restoreError instanceof Error ? restoreError.message : String(restoreError)
-        }
-      );
-    }
-    throw new WorkspaceError("FILESYSTEM_ERROR", "\u65E0\u6CD5\u539F\u5B50\u5199\u5165\u77E5\u8BC6\u5E93\u6587\u4EF6", {
-      cause: error instanceof Error ? error.message : String(error)
-    });
-  }
-}
-
-// workspace/mutationQueue.ts
-var MutationQueue = class {
-  constructor() {
-    this.tail = Promise.resolve();
-    this.disposed = false;
-  }
-  async run(operation) {
-    if (this.disposed) {
-      throw new Error("Mutation queue has been disposed");
-    }
-    const previous = this.tail;
-    let release;
-    this.tail = new Promise((resolve) => {
-      release = resolve;
-    });
-    await previous;
-    try {
-      return await operation();
-    } finally {
-      release();
-    }
-  }
-  async dispose() {
-    this.disposed = true;
-    await this.tail;
-  }
-};
-
-// workspace/paths.ts
-
-function createWorkspacePaths(rootPath) {
-  if (!rootPath || !_path2.default.isAbsolute(rootPath)) {
-    throw new WorkspaceError(
-      "INVALID_PATH",
-      "\u77E5\u8BC6\u5E93\u8DEF\u5F84\u5FC5\u987B\u662F\u975E\u7A7A\u7684\u7EDD\u5BF9\u8DEF\u5F84",
-      { rootPath }
-    );
-  }
-  const root = _path2.default.normalize(_path2.default.resolve(rootPath));
-  return {
-    root,
-    config: _path2.default.join(root, ".tnotes.json"),
-    toc: _path2.default.join(root, "TOC.md"),
-    notes: _path2.default.join(root, "notes"),
-    sidebar: _path2.default.join(root, "sidebar.json"),
-    packageJson: _path2.default.join(root, "package.json")
-  };
-}
-function assertPathInside(parent, target) {
-  const relative = _path2.default.relative(parent, target);
-  if (relative === "" || !relative.startsWith(`..${_path2.default.sep}`) && relative !== ".." && !_path2.default.isAbsolute(relative)) {
-    return;
-  }
-  throw new WorkspaceError("INVALID_PATH", "\u76EE\u6807\u8DEF\u5F84\u8D85\u51FA\u5141\u8BB8\u8303\u56F4", {
-    parent,
-    target
-  });
-}
-function sanitizeFileName(fileName) {
-  const value = fileName.trim();
-  if (!value || value === "." || value === ".." || value.includes("/") || value.includes("\\") || value.includes("\0")) {
-    throw new WorkspaceError("INVALID_PATH", "\u9644\u4EF6\u6587\u4EF6\u540D\u4E0D\u5408\u6CD5", {
-      fileName
-    });
-  }
-  return value;
-}
-
-// workspace/scanner.ts
-
-
-
-var NOTE_DIRECTORY_PATTERN = /^(\d{4})\.\s*(.+)$/;
-var CURRENT_SCHEMA_VERSION = 1;
-function digest(...values) {
-  const hash = _crypto.createHash.call(void 0, "sha256");
-  for (const value of values) {
-    hash.update(value);
-    hash.update("\0");
-  }
-  return hash.digest("hex");
-}
-async function readText(filePath) {
-  try {
-    return await _promises2.default.readFile(filePath, "utf8");
-  } catch (e2) {
-    return null;
-  }
-}
-function parseJsonObject(content) {
-  try {
-    const value = JSON.parse(content);
-    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
-  } catch (e3) {
-    return null;
-  }
-}
-function noteInfoFromSummary(note) {
-  return {
-    index: note.index,
-    path: note.directoryPath,
-    dirName: note.dirName,
-    readmePath: note.readmePath,
-    configPath: note.configPath,
-    config: note.config
-  };
-}
-async function scanWorkspace(paths) {
-  const diagnostics = [];
-  let rootIsDirectory = false;
-  try {
-    rootIsDirectory = (await _promises2.default.stat(paths.root)).isDirectory();
-  } catch (e4) {
-  }
-  if (!rootIsDirectory) {
-    diagnostics.push({
-      code: "ROOT_NOT_DIRECTORY",
-      message: "\u77E5\u8BC6\u5E93\u6839\u76EE\u5F55\u4E0D\u5B58\u5728\u6216\u4E0D\u662F\u76EE\u5F55",
-      severity: "error",
-      path: paths.root
-    });
-  }
-  const configText = await readText(paths.config);
-  let config = null;
-  if (configText === null) {
-    diagnostics.push({
-      code: "CONFIG_MISSING",
-      message: "\u7F3A\u5C11\u77E5\u8BC6\u5E93\u914D\u7F6E .tnotes.json",
-      severity: "error",
-      path: paths.config
-    });
-  } else {
-    config = parseJsonObject(configText);
-    if (!config) {
-      diagnostics.push({
-        code: "CONFIG_INVALID_JSON",
-        message: "\u77E5\u8BC6\u5E93\u914D\u7F6E\u4E0D\u662F\u6709\u6548\u7684 JSON \u5BF9\u8C61",
-        severity: "error",
-        path: paths.config
-      });
-    } else {
-      if (typeof config.id !== "string" || !config.id.trim()) {
-        diagnostics.push({
-          code: "CONFIG_ID_MISSING",
-          message: "\u77E5\u8BC6\u5E93\u914D\u7F6E\u7F3A\u5C11\u7A33\u5B9A\u7684 id",
-          severity: "error",
-          path: paths.config
-        });
-      }
-      if (typeof config.repoName !== "string" || !config.repoName.trim()) {
-        diagnostics.push({
-          code: "CONFIG_REPO_NAME_MISSING",
-          message: "\u77E5\u8BC6\u5E93\u914D\u7F6E\u7F3A\u5C11 repoName",
-          severity: "error",
-          path: paths.config
-        });
-      }
-    }
-  }
-  let notesDirectoryExists = false;
-  try {
-    notesDirectoryExists = (await _promises2.default.stat(paths.notes)).isDirectory();
-  } catch (e5) {
-  }
-  if (!notesDirectoryExists) {
-    diagnostics.push({
-      code: "NOTES_DIRECTORY_MISSING",
-      message: "\u7F3A\u5C11 notes \u76EE\u5F55",
-      severity: "error",
-      path: paths.notes
-    });
-  }
-  const tocText = await readText(paths.toc);
-  if (tocText === null) {
-    diagnostics.push({
-      code: "TOC_MISSING",
-      message: "\u7F3A\u5C11\u76EE\u5F55\u771F\u76F8\u6E90 TOC.md",
-      severity: "error",
-      path: paths.toc
-    });
-  }
-  const notes = [];
-  const usedIndexes = /* @__PURE__ */ new Map();
-  const usedIds = /* @__PURE__ */ new Map();
-  if (notesDirectoryExists) {
-    const entries = await _promises2.default.readdir(paths.notes, { withFileTypes: true });
-    entries.sort((left, right) => left.name.localeCompare(right.name));
-    for (const entry of entries) {
-      if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
-      const match = NOTE_DIRECTORY_PATTERN.exec(entry.name);
-      if (!match) continue;
-      const [, index, rawTitle] = match;
-      const title = rawTitle.trim();
-      const directoryPath = _path2.default.join(paths.notes, entry.name);
-      const readmePath = _path2.default.join(directoryPath, "README.md");
-      const configPath = _path2.default.join(directoryPath, ".tnotes.json");
-      const readme = await readText(readmePath);
-      const noteConfigText = await readText(configPath);
-      if (readme === null) {
-        diagnostics.push({
-          code: "NOTE_README_MISSING",
-          message: `\u7B14\u8BB0 ${entry.name} \u7F3A\u5C11 README.md`,
-          severity: "error",
-          path: readmePath
-        });
-        continue;
-      }
-      if (noteConfigText === null) {
-        diagnostics.push({
-          code: "NOTE_CONFIG_MISSING",
-          message: `\u7B14\u8BB0 ${entry.name} \u7F3A\u5C11 .tnotes.json`,
-          severity: "error",
-          path: configPath
-        });
-        continue;
-      }
-      const noteConfig = parseJsonObject(noteConfigText);
-      if (!noteConfig || typeof noteConfig.id !== "string" || !noteConfig.id) {
-        diagnostics.push({
-          code: "NOTE_CONFIG_INVALID",
-          message: `\u7B14\u8BB0 ${entry.name} \u7684\u914D\u7F6E\u65E0\u6CD5\u89E3\u6790\u6216\u7F3A\u5C11 id`,
-          severity: "error",
-          path: configPath
-        });
-        continue;
-      }
-      const existingIndex = usedIndexes.get(index);
-      if (existingIndex) {
-        diagnostics.push({
-          code: "NOTE_INDEX_DUPLICATE",
-          message: `\u7B14\u8BB0\u7F16\u53F7 ${index} \u91CD\u590D\uFF1A${existingIndex}\u3001${entry.name}`,
-          severity: "error",
-          path: directoryPath
-        });
-      } else {
-        usedIndexes.set(index, entry.name);
-      }
-      const existingId = usedIds.get(noteConfig.id);
-      if (existingId) {
-        diagnostics.push({
-          code: "NOTE_ID_DUPLICATE",
-          message: `\u7B14\u8BB0 id ${noteConfig.id} \u91CD\u590D\uFF1A${existingId}\u3001${entry.name}`,
-          severity: "error",
-          path: configPath
-        });
-      } else {
-        usedIds.set(noteConfig.id, entry.name);
-      }
-      notes.push({
-        uuid: noteConfig.id,
-        index,
-        title,
-        dirName: entry.name,
-        directoryPath,
-        readmePath,
-        configPath,
-        config: noteConfig,
-        revision: digest(entry.name, readme, noteConfigText)
-      });
-    }
-  }
-  const noteInfos = notes.map(noteInfoFromSummary);
-  const toc = tocText ? _chunk3R7QSABBcjs.parseTocToTree.call(void 0, tocText.split("\n"), noteInfos) : [];
-  const sidebar = _chunk3R7QSABBcjs.buildSidebarFromTocTree.call(void 0, toc, noteInfos, {
-    sidebarShowNoteId: _nullishCoalesce(_optionalChain([config, 'optionalAccess', _ => _.sidebarShowNoteId]), () => ( true)),
-    sidebarIsCollapsed: true
-  });
-  const schemaVersion = _optionalChain([config, 'optionalAccess', _2 => _2.schemaVersion]);
-  const futureSchema = typeof schemaVersion === "number" && schemaVersion > CURRENT_SCHEMA_VERSION;
-  if (futureSchema) {
-    diagnostics.push({
-      code: "FUTURE_SCHEMA",
-      message: `\u77E5\u8BC6\u5E93 schemaVersion ${schemaVersion} \u9AD8\u4E8E\u5F53\u524D\u652F\u6301\u7248\u672C ${CURRENT_SCHEMA_VERSION}`,
-      severity: "error",
-      path: paths.config
-    });
-  }
-  const health = futureSchema ? { status: "future-schema", diagnostics } : diagnostics.some((diagnostic) => diagnostic.severity === "error") ? { status: "invalid", diagnostics } : { status: "ready", diagnostics };
-  const id = config && typeof config.id === "string" && config.id.trim() ? config.id : `path-${digest(paths.root).slice(0, 24)}`;
-  const revision = digest(
-    paths.root,
-    _nullishCoalesce(configText, () => ( "")),
-    _nullishCoalesce(tocText, () => ( "")),
-    ...notes.map((note) => `${note.uuid}:${note.revision}`)
-  );
-  return {
-    snapshot: {
-      id,
-      rootPath: paths.root,
-      config,
-      health,
-      toc,
-      sidebar,
-      notes,
-      revision
-    },
-    configText,
-    tocText
-  };
-}
-function toNoteInfo(note) {
-  return noteInfoFromSummary(note);
-}
-
-// workspace/workspace.ts
-var NOTE_CONFIG_FIELD_ORDER = [
-  "bilibili",
-  "tnotes",
-  "yuque",
-  "done",
-  "category",
-  "enableDiscussions",
-  "description",
-  "id"
-];
-function validateTitle(title) {
-  const value = title.trim();
-  if (!value || /[\\/\0\r\n]/.test(value) || /[. ]$/.test(value) || /^(con|prn|aux|nul|com[1-9]|lpt[1-9])(?:\.|$)/i.test(value)) {
-    throw new WorkspaceError("INVALID_TITLE", "\u7B14\u8BB0\u6216\u5206\u7EC4\u6807\u9898\u4E0D\u5408\u6CD5", {
-      title
-    });
-  }
-  return value;
-}
-function serializeNoteConfig(config) {
-  const record = config;
-  const sorted = {};
-  for (const field of NOTE_CONFIG_FIELD_ORDER) {
-    if (field in record) sorted[field] = record[field];
-  }
-  for (const [key, value] of Object.entries(record)) {
-    if (!(key in sorted)) sorted[key] = value;
-  }
-  return `${JSON.stringify(sorted, null, 2)}
-`;
-}
-function normalizeTocContent(lines) {
-  const content = _chunk3R7QSABBcjs.processTocEmptyLines.call(void 0, lines).join("\n");
-  return content.endsWith("\n") ? content : `${content}
-`;
-}
-function toNoteInfos(notes) {
-  return notes.map(toNoteInfo);
-}
-function sidebarContent(tocLines, notes, config) {
-  const noteInfos = toNoteInfos(notes);
-  const tree = _chunk3R7QSABBcjs.parseTocToTree.call(void 0, tocLines, noteInfos);
-  return JSON.stringify(
-    _chunk3R7QSABBcjs.buildSidebarFromTocTree.call(void 0, tree, noteInfos, {
-      sidebarShowNoteId: _nullishCoalesce(config.sidebarShowNoteId, () => ( true)),
-      sidebarIsCollapsed: true
-    }),
-    null,
-    2
-  );
-}
-function requireConfig(snapshot) {
-  if (snapshot.health.status === "future-schema") {
-    throw new WorkspaceError(
-      "WORKSPACE_READ_ONLY",
-      "\u77E5\u8BC6\u5E93\u7531\u66F4\u65B0\u7248\u672C\u7684 Core \u521B\u5EFA\uFF0C\u5F53\u524D\u7248\u672C\u53EA\u5141\u8BB8\u8BFB\u53D6"
-    );
-  }
-  if (snapshot.health.status !== "ready" || !snapshot.config) {
-    throw new WorkspaceError("WORKSPACE_INVALID", "\u77E5\u8BC6\u5E93\u914D\u7F6E\u5F02\u5E38\uFF0C\u7981\u6B62\u4FEE\u6539", {
-      diagnostics: snapshot.health.diagnostics
-    });
-  }
-  return snapshot.config;
-}
-function findNote(snapshot, noteUuid) {
-  const note = snapshot.notes.find((item) => item.uuid === noteUuid);
-  if (!note) {
-    throw new WorkspaceError("NOTE_NOT_FOUND", `\u672A\u627E\u5230\u7B14\u8BB0\uFF1A${noteUuid}`, {
-      noteUuid
-    });
-  }
-  return note;
-}
-function assertRevision(actual, expected, subject) {
-  if (actual !== expected) {
-    throw new WorkspaceError(
-      "REVISION_CONFLICT",
-      `${subject} \u5DF2\u88AB\u5176\u4ED6\u7A0B\u5E8F\u4FEE\u6539\uFF0C\u8BF7\u5148\u5904\u7406\u5916\u90E8\u53D8\u66F4`,
-      { actual, expected }
-    );
-  }
-}
-function allocateNoteIndex(notes) {
-  const used = new Set(
-    notes.map((note) => Number.parseInt(note.index, 10)).filter((value) => Number.isInteger(value) && value >= 1 && value <= 9999)
-  );
-  for (let index = 1; index <= 9999; index++) {
-    if (!used.has(index)) return String(index).padStart(4, "0");
-  }
-  throw new WorkspaceError(
-    "NOTE_INDEX_EXHAUSTED",
-    "\u6240\u6709\u7B14\u8BB0\u7F16\u53F7\uFF080001-9999\uFF09\u5747\u5DF2\u4F7F\u7528"
-  );
-}
-function resolveEntryLine(lines, snapshot, entry) {
-  if (entry.type === "line") {
-    if (entry.tocLineIndex < 0 || entry.tocLineIndex >= lines.length) {
-      throw new WorkspaceError("INVALID_TOC_ENTRY", "TOC \u884C\u7D22\u5F15\u65E0\u6548", {
-        tocLineIndex: entry.tocLineIndex
-      });
-    }
-    return entry.tocLineIndex;
-  }
-  if (entry.type === "folder") {
-    try {
-      return _chunk3R7QSABBcjs.findFolderLineIndex.call(void 0, lines, entry.folderPath);
-    } catch (error) {
-      throw new WorkspaceError("INVALID_TOC_ENTRY", "\u672A\u627E\u5230 TOC \u5206\u7EC4", {
-        folderPath: entry.folderPath,
-        cause: error instanceof Error ? error.message : String(error)
-      });
-    }
-  }
-  const note = findNote(snapshot, entry.noteUuid);
-  try {
-    return _chunk3R7QSABBcjs.findTocLineIndex.call(void 0, lines, note.index);
-  } catch (error) {
-    throw new WorkspaceError("INVALID_TOC_ENTRY", "\u672A\u5728 TOC \u4E2D\u627E\u5230\u7B14\u8BB0", {
-      noteUuid: entry.noteUuid,
-      cause: error instanceof Error ? error.message : String(error)
-    });
-  }
-}
-function placementTargetLine(lines, snapshot, placement) {
-  if (placement.type === "note") {
-    return resolveEntryLine(lines, snapshot, {
-      type: "note",
-      noteUuid: placement.targetNoteUuid
-    });
-  }
-  return resolveEntryLine(lines, snapshot, {
-    type: "folder",
-    folderPath: placement.folderPath
-  });
-}
-function insertLineAtPlacement(lines, snapshot, placement, buildLine) {
-  const resolvedPlacement = _nullishCoalesce(placement, () => ( { type: "root", placement: "end" }));
-  if (resolvedPlacement.type === "root") {
-    if (resolvedPlacement.placement === "start") {
-      const firstContent = lines.findIndex((line) => _chunk3R7QSABBcjs.parseTocLine.call(void 0, line).isMatch);
-      lines.splice(firstContent >= 0 ? firstContent : lines.length, 0, buildLine(0));
-    } else {
-      let insertAt = lines.length;
-      while (insertAt > 0 && lines[insertAt - 1] === "") insertAt--;
-      lines.splice(insertAt, 0, buildLine(0));
-    }
-    return;
-  }
-  const targetLine = placementTargetLine(lines, snapshot, resolvedPlacement);
-  const target = _chunk3R7QSABBcjs.parseTocLine.call(void 0, lines[targetLine]);
-  if (!target.isMatch) {
-    throw new WorkspaceError("INVALID_TOC_ENTRY", "\u76EE\u6807 TOC \u6761\u76EE\u65E0\u6548");
-  }
-  if (resolvedPlacement.placement === "inside") {
-    const range = _chunk3R7QSABBcjs.getTocEntrySubtreeRange.call(void 0, lines, targetLine);
-    lines.splice(range.end, 0, buildLine(target.indentLevel + 1));
-  } else if (resolvedPlacement.placement === "before") {
-    lines.splice(targetLine, 0, buildLine(target.indentLevel));
-  } else {
-    const range = _chunk3R7QSABBcjs.getTocEntrySubtreeRange.call(void 0, lines, targetLine);
-    lines.splice(range.end, 0, buildLine(target.indentLevel));
-  }
-}
-function adjustIndent(lines, delta) {
-  return lines.map((line) => {
-    const parsed = _chunk3R7QSABBcjs.parseTocLine.call(void 0, line);
-    if (!parsed.isMatch) return line;
-    const indent = Math.max(0, parsed.indentLevel + delta);
-    return `${" ".repeat(indent * _chunk3R7QSABBcjs.TOC_INDENT_SPACES)}${line.trimStart()}`;
-  });
-}
-async function listFilesRecursively(directoryPath) {
-  const result = [];
-  const entries = await _promises2.default.readdir(directoryPath, { withFileTypes: true });
-  for (const entry of entries) {
-    const entryPath = _path2.default.join(directoryPath, entry.name);
-    if (entry.isDirectory()) {
-      result.push(...await listFilesRecursively(entryPath));
-    } else {
-      result.push(entryPath);
-    }
-  }
-  return result;
-}
-var Workspace = class {
-  constructor(options) {
-    this.queue = new MutationQueue();
-    this.disposed = false;
-    this.paths = createWorkspacePaths(options.rootPath);
-    this.logger = _nullishCoalesce(options.logger, () => ( {}));
-    this.prettierByDefault = _nullishCoalesce(_optionalChain([options, 'access', _3 => _3.format, 'optionalAccess', _4 => _4.prettier]), () => ( true));
-    this.notes = {
-      read: (noteUuid) => this.readNote(noteUuid),
-      save: (input) => this.saveNote(input),
-      create: (input) => this.createNote(input),
-      rename: (input) => this.renameNote(input),
-      updateConfig: (input) => this.updateNoteConfig(input)
-    };
-    this.toc = {
-      move: (input) => this.moveTocEntry(input),
-      createGroup: (input) => this.createTocGroup(input),
-      renameGroup: (input) => this.renameTocGroup(input),
-      previewDelete: (entry) => this.previewDelete(entry),
-      deleteEntry: (input) => this.deleteTocEntry(input),
-      setDone: (input) => this.updateNoteConfig(input)
-    };
-    this.attachments = {
-      writeLocal: (input) => this.writeLocalAttachment(input)
-    };
-  }
-  async inspect() {
-    this.assertActive();
-    return (await scanWorkspace(this.paths)).snapshot;
-  }
-  async refresh() {
-    return this.inspect();
-  }
-  async reconcileTocCompletion() {
-    return this.queue.run(async () => {
-      const scanned = await this.scanReady();
-      const { snapshot, tocText } = scanned;
-      const config = requireConfig(snapshot);
-      const lines = (_nullishCoalesce(tocText, () => ( ""))).split("\n");
-      const completedByIndex = /* @__PURE__ */ new Map();
-      for (const line of lines) {
-        const parsed = _chunk3R7QSABBcjs.parseTocLine.call(void 0, line);
-        if (parsed.noteIndex && !completedByIndex.has(parsed.noteIndex)) {
-          completedByIndex.set(parsed.noteIndex, parsed.completed);
-        }
-      }
-      const changedFiles = [];
-      const writes = [];
-      const updatedNotes = snapshot.notes.map((note) => {
-        const completed = completedByIndex.get(note.index);
-        if (completed === void 0 || completed === note.config.done) return note;
-        const updatedConfig = { ...note.config, done: completed };
-        writes.push({ path: note.configPath, data: serializeNoteConfig(updatedConfig) });
-        changedFiles.push({ path: note.configPath, kind: "updated" });
-        return { ...note, config: updatedConfig };
-      });
-      if (writes.length > 0) {
-        writes.push({
-          path: this.paths.sidebar,
-          data: sidebarContent(lines, updatedNotes, config)
-        });
-        changedFiles.push({ path: this.paths.sidebar, kind: "updated" });
-        await writeFilesAtomically(writes);
-      }
-      const value = await this.inspect();
-      return { value, changedFiles, snapshotRevision: value.revision };
-    });
-  }
-  async dispose() {
-    if (this.disposed) return;
-    this.disposed = true;
-    await this.queue.dispose();
-  }
-  assertActive() {
-    if (this.disposed) {
-      throw new WorkspaceError("WORKSPACE_DISPOSED", "\u5DE5\u4F5C\u533A\u5B9E\u4F8B\u5DF2\u7ECF\u91CA\u653E");
-    }
-  }
-  async scanReady() {
-    this.assertActive();
-    const scanned = await scanWorkspace(this.paths);
-    requireConfig(scanned.snapshot);
-    return scanned;
-  }
-  async readNote(noteUuid) {
-    const snapshot = await this.inspect();
-    const note = findNote(snapshot, noteUuid);
-    return { ...note, content: await _promises2.default.readFile(note.readmePath, "utf8") };
-  }
-  async saveNote(input) {
-    return this.queue.run(async () => {
-      const { snapshot } = await this.scanReady();
-      const config = requireConfig(snapshot);
-      const note = findNote(snapshot, input.noteUuid);
-      assertRevision(note.revision, input.expectedRevision, "\u7B14\u8BB0");
-      const formatted = await _chunkIHFUHB4Jcjs.formatTNotesNote.call(void 0, {
-        content: input.content,
-        noteIndex: note.index,
-        title: note.title,
-        repoOwner: config.author,
-        repoName: config.repoName,
-        noteConfig: note.config,
-        prettier: _nullishCoalesce(input.prettier, () => ( this.prettierByDefault))
-      });
-      const current = await _promises2.default.readFile(note.readmePath, "utf8");
-      const changedFiles = [];
-      if (formatted.content !== current) {
-        await writeFilesAtomically([
-          { path: note.readmePath, data: formatted.content }
-        ]);
-        changedFiles.push({ path: note.readmePath, kind: "updated" });
-      }
-      const value = await this.readNote(input.noteUuid);
-      const refreshed = await this.inspect();
-      return { value, changedFiles, snapshotRevision: refreshed.revision };
-    });
-  }
-  async createNote(input) {
-    return this.queue.run(async () => {
-      const { snapshot, tocText } = await this.scanReady();
-      const config = requireConfig(snapshot);
-      if (input.expectedSnapshotRevision) {
-        assertRevision(
-          snapshot.revision,
-          input.expectedSnapshotRevision,
-          "\u77E5\u8BC6\u5E93\u76EE\u5F55"
-        );
-      }
-      const title = validateTitle(input.title);
-      const index = allocateNoteIndex(snapshot.notes);
-      const dirName = `${index}. ${title}`;
-      const directoryPath = _path2.default.join(this.paths.notes, dirName);
-      assertPathInside(this.paths.notes, directoryPath);
-      try {
-        await _promises2.default.mkdir(directoryPath);
-      } catch (error) {
-        throw new WorkspaceError("FILESYSTEM_ERROR", "\u65E0\u6CD5\u521B\u5EFA\u7B14\u8BB0\u76EE\u5F55", {
-          directoryPath,
-          cause: error instanceof Error ? error.message : String(error)
-        });
-      }
-      const noteConfig = {
-        bilibili: [],
-        tnotes: [],
-        yuque: [],
-        done: false,
-        enableDiscussions: _nullishCoalesce(_optionalChain([input, 'access', _5 => _5.config, 'optionalAccess', _6 => _6.enableDiscussions]), () => ( false)),
-        description: _nullishCoalesce(_optionalChain([input, 'access', _7 => _7.config, 'optionalAccess', _8 => _8.description]), () => ( "")),
-        id: _crypto.randomUUID.call(void 0, )
-      };
-      const readmePath = _path2.default.join(directoryPath, "README.md");
-      const configPath = _path2.default.join(directoryPath, ".tnotes.json");
-      const formatted = await _chunkIHFUHB4Jcjs.formatTNotesNote.call(void 0, {
-        content: _chunk3R7QSABBcjs.getNewNoteReadmeBody.call(void 0, ),
-        noteIndex: index,
-        title,
-        repoOwner: config.author,
-        repoName: config.repoName,
-        noteConfig,
-        prettier: this.prettierByDefault
-      });
-      const newNote = {
-        uuid: noteConfig.id,
-        index,
-        title,
-        dirName,
-        directoryPath,
-        readmePath,
-        configPath,
-        config: noteConfig,
-        revision: ""
-      };
-      const tocLines = (_nullishCoalesce(tocText, () => ( ""))).split("\n");
-      insertLineAtPlacement(
-        tocLines,
-        snapshot,
-        input.placement,
-        (indent) => _chunk3R7QSABBcjs.buildTocLine.call(void 0, toNoteInfo(newNote), indent, false)
-      );
-      const updatedNotes = [...snapshot.notes, newNote];
-      const normalizedToc = normalizeTocContent(tocLines);
-      const normalizedLines = normalizedToc.split("\n");
-      try {
-        await writeFilesAtomically([
-          { path: readmePath, data: formatted.content },
-          { path: configPath, data: serializeNoteConfig(noteConfig) },
-          { path: this.paths.toc, data: normalizedToc },
-          {
-            path: this.paths.sidebar,
-            data: sidebarContent(normalizedLines, updatedNotes, config)
-          }
-        ]);
-      } catch (error) {
-        await _promises2.default.rm(directoryPath, { recursive: true, force: true });
-        throw error;
-      }
-      const value = await this.readNote(noteConfig.id);
-      const refreshed = await this.inspect();
-      return {
-        value,
-        changedFiles: [
-          { path: directoryPath, kind: "created" },
-          { path: readmePath, kind: "created" },
-          { path: configPath, kind: "created" },
-          { path: this.paths.toc, kind: "updated" },
-          { path: this.paths.sidebar, kind: "updated" }
-        ],
-        snapshotRevision: refreshed.revision
-      };
-    });
-  }
-  async renameNote(input) {
-    return this.queue.run(async () => {
-      const { snapshot, tocText } = await this.scanReady();
-      const config = requireConfig(snapshot);
-      const note = findNote(snapshot, input.noteUuid);
-      assertRevision(note.revision, input.expectedRevision, "\u7B14\u8BB0");
-      const title = validateTitle(input.title);
-      const newDirName = `${note.index}. ${title}`;
-      if (newDirName === note.dirName) {
-        const value2 = await this.readNote(note.uuid);
-        return { value: value2, changedFiles: [], snapshotRevision: snapshot.revision };
-      }
-      const newDirectoryPath = _path2.default.join(this.paths.notes, newDirName);
-      assertPathInside(this.paths.notes, newDirectoryPath);
-      try {
-        await _promises2.default.access(newDirectoryPath);
-        throw new WorkspaceError("INVALID_TITLE", "\u76EE\u6807\u7B14\u8BB0\u76EE\u5F55\u5DF2\u7ECF\u5B58\u5728", {
-          newDirectoryPath
-        });
-      } catch (error) {
-        if (error instanceof WorkspaceError) throw error;
-      }
-      const currentContent = await _promises2.default.readFile(note.readmePath, "utf8");
-      const formatted = await _chunkIHFUHB4Jcjs.formatTNotesNote.call(void 0, {
-        content: currentContent,
-        noteIndex: note.index,
-        title,
-        repoOwner: config.author,
-        repoName: config.repoName,
-        noteConfig: note.config,
-        prettier: this.prettierByDefault
-      });
-      const renamedNote = {
-        ...note,
-        title,
-        dirName: newDirName,
-        directoryPath: newDirectoryPath,
-        readmePath: _path2.default.join(newDirectoryPath, "README.md"),
-        configPath: _path2.default.join(newDirectoryPath, ".tnotes.json")
-      };
-      const tocLines = (_nullishCoalesce(tocText, () => ( ""))).split("\n");
-      for (let index = 0; index < tocLines.length; index++) {
-        const parsed = _chunk3R7QSABBcjs.parseTocLine.call(void 0, tocLines[index]);
-        if (parsed.noteIndex === note.index) {
-          tocLines[index] = _chunk3R7QSABBcjs.buildTocLine.call(void 0, 
-            toNoteInfo(renamedNote),
-            parsed.indentLevel,
-            parsed.completed
-          );
-        }
-      }
-      const normalizedToc = normalizeTocContent(tocLines);
-      const updatedNotes = snapshot.notes.map(
-        (item) => item.uuid === note.uuid ? renamedNote : item
-      );
-      await _promises2.default.rename(note.directoryPath, newDirectoryPath);
-      try {
-        await writeFilesAtomically([
-          { path: renamedNote.readmePath, data: formatted.content },
-          { path: this.paths.toc, data: normalizedToc },
-          {
-            path: this.paths.sidebar,
-            data: sidebarContent(normalizedToc.split("\n"), updatedNotes, config)
-          }
-        ]);
-      } catch (error) {
-        await _promises2.default.rename(newDirectoryPath, note.directoryPath);
-        throw error;
-      }
-      const value = await this.readNote(note.uuid);
-      const refreshed = await this.inspect();
-      return {
-        value,
-        changedFiles: [
-          {
-            path: newDirectoryPath,
-            previousPath: note.directoryPath,
-            kind: "renamed"
-          },
-          { path: renamedNote.readmePath, kind: "updated" },
-          { path: this.paths.toc, kind: "updated" },
-          { path: this.paths.sidebar, kind: "updated" }
-        ],
-        snapshotRevision: refreshed.revision
-      };
-    });
-  }
-  async updateNoteConfig(input) {
-    return this.queue.run(async () => {
-      const { snapshot, tocText } = await this.scanReady();
-      const config = requireConfig(snapshot);
-      const note = findNote(snapshot, input.noteUuid);
-      assertRevision(note.revision, input.expectedRevision, "\u7B14\u8BB0");
-      const updatedConfig = { ...note.config, ...input.updates };
-      const writes = [
-        { path: note.configPath, data: serializeNoteConfig(updatedConfig) }
-      ];
-      const changedFiles = [
-        { path: note.configPath, kind: "updated" }
-      ];
-      if (typeof input.updates.done === "boolean") {
-        const lines = (_nullishCoalesce(tocText, () => ( ""))).split("\n");
-        let updated = false;
-        const tempNote = { ...note, config: updatedConfig };
-        for (let index = 0; index < lines.length; index++) {
-          const parsed = _chunk3R7QSABBcjs.parseTocLine.call(void 0, lines[index]);
-          if (parsed.noteIndex === note.index) {
-            lines[index] = _chunk3R7QSABBcjs.buildTocLine.call(void 0, 
-              toNoteInfo(tempNote),
-              parsed.indentLevel,
-              input.updates.done
-            );
-            updated = true;
-          }
-        }
-        if (updated) {
-          const normalizedToc = normalizeTocContent(lines);
-          const updatedNotes = snapshot.notes.map(
-            (item) => item.uuid === note.uuid ? tempNote : item
-          );
-          writes.push(
-            { path: this.paths.toc, data: normalizedToc },
-            {
-              path: this.paths.sidebar,
-              data: sidebarContent(normalizedToc.split("\n"), updatedNotes, config)
-            }
-          );
-          changedFiles.push(
-            { path: this.paths.toc, kind: "updated" },
-            { path: this.paths.sidebar, kind: "updated" }
-          );
-        }
-      }
-      await writeFilesAtomically(writes);
-      const value = await this.readNote(note.uuid);
-      const refreshed = await this.inspect();
-      return { value, changedFiles, snapshotRevision: refreshed.revision };
-    });
-  }
-  async moveTocEntry(input) {
-    return this.queue.run(async () => {
-      const { snapshot, tocText } = await this.scanReady();
-      const config = requireConfig(snapshot);
-      assertRevision(snapshot.revision, input.expectedSnapshotRevision, "\u77E5\u8BC6\u5E93\u76EE\u5F55");
-      const lines = (_nullishCoalesce(tocText, () => ( ""))).split("\n");
-      const sourceLine = resolveEntryLine(lines, snapshot, input.source);
-      const targetLine = resolveEntryLine(lines, snapshot, input.target);
-      const sourceRange = _chunk3R7QSABBcjs.getTocEntrySubtreeRange.call(void 0, lines, sourceLine);
-      if (targetLine >= sourceRange.start && targetLine < sourceRange.end) {
-        throw new WorkspaceError(
-          "INVALID_TOC_ENTRY",
-          "\u4E0D\u80FD\u628A\u76EE\u5F55\u6761\u76EE\u79FB\u52A8\u5230\u81EA\u8EAB\u6216\u81EA\u8EAB\u5B50\u6811\u5185"
-        );
-      }
-      const moving = lines.splice(
-        sourceRange.start,
-        sourceRange.end - sourceRange.start
-      );
-      const adjustedTarget = _chunk3R7QSABBcjs.adjustTocLineIndexAfterSubtreeRemoval.call(void 0, 
-        targetLine,
-        sourceRange.start,
-        sourceRange.end
-      );
-      const target = _chunk3R7QSABBcjs.parseTocLine.call(void 0, lines[adjustedTarget]);
-      if (!target.isMatch) {
-        throw new WorkspaceError("INVALID_TOC_ENTRY", "\u79FB\u52A8\u76EE\u6807\u65E0\u6548");
-      }
-      let insertAt;
-      let indent;
-      if (input.placement === "inside") {
-        insertAt = _chunk3R7QSABBcjs.getTocEntrySubtreeRange.call(void 0, lines, adjustedTarget).end;
-        indent = target.indentLevel + 1;
-      } else if (input.placement === "before") {
-        insertAt = adjustedTarget;
-        indent = target.indentLevel;
-      } else {
-        insertAt = _chunk3R7QSABBcjs.getTocEntrySubtreeRange.call(void 0, lines, adjustedTarget).end;
-        indent = target.indentLevel;
-      }
-      const oldIndent = _chunk3R7QSABBcjs.parseTocLine.call(void 0, moving[0]).indentLevel;
-      lines.splice(insertAt, 0, ...adjustIndent(moving, indent - oldIndent));
-      const normalizedToc = normalizeTocContent(lines);
-      await writeFilesAtomically([
-        { path: this.paths.toc, data: normalizedToc },
-        {
-          path: this.paths.sidebar,
-          data: sidebarContent(normalizedToc.split("\n"), snapshot.notes, config)
-        }
-      ]);
-      const value = await this.inspect();
-      return {
-        value,
-        changedFiles: [
-          { path: this.paths.toc, kind: "updated" },
-          { path: this.paths.sidebar, kind: "updated" }
-        ],
-        snapshotRevision: value.revision
-      };
-    });
-  }
-  async createTocGroup(input) {
-    return this.queue.run(async () => {
-      const { snapshot, tocText } = await this.scanReady();
-      const config = requireConfig(snapshot);
-      assertRevision(snapshot.revision, input.expectedSnapshotRevision, "\u77E5\u8BC6\u5E93\u76EE\u5F55");
-      const title = validateTitle(input.title);
-      const lines = (_nullishCoalesce(tocText, () => ( ""))).split("\n");
-      insertLineAtPlacement(
-        lines,
-        snapshot,
-        input.placement,
-        (indent) => _chunk3R7QSABBcjs.buildFolderTocLine.call(void 0, title, indent)
-      );
-      const normalizedToc = normalizeTocContent(lines);
-      await writeFilesAtomically([
-        { path: this.paths.toc, data: normalizedToc },
-        {
-          path: this.paths.sidebar,
-          data: sidebarContent(normalizedToc.split("\n"), snapshot.notes, config)
-        }
-      ]);
-      const value = await this.inspect();
-      return {
-        value,
-        changedFiles: [
-          { path: this.paths.toc, kind: "updated" },
-          { path: this.paths.sidebar, kind: "updated" }
-        ],
-        snapshotRevision: value.revision
-      };
-    });
-  }
-  async renameTocGroup(input) {
-    return this.queue.run(async () => {
-      const { snapshot, tocText } = await this.scanReady();
-      const config = requireConfig(snapshot);
-      assertRevision(snapshot.revision, input.expectedSnapshotRevision, "\u77E5\u8BC6\u5E93\u76EE\u5F55");
-      const lines = (_nullishCoalesce(tocText, () => ( ""))).split("\n");
-      const lineIndex = resolveEntryLine(lines, snapshot, {
-        type: "folder",
-        folderPath: input.folderPath
-      });
-      const updatedLines = _chunk3R7QSABBcjs.renameFolderLine.call(void 0, lines, lineIndex, validateTitle(input.title));
-      const normalizedToc = normalizeTocContent(updatedLines);
-      await writeFilesAtomically([
-        { path: this.paths.toc, data: normalizedToc },
-        {
-          path: this.paths.sidebar,
-          data: sidebarContent(normalizedToc.split("\n"), snapshot.notes, config)
-        }
-      ]);
-      const value = await this.inspect();
-      return {
-        value,
-        changedFiles: [
-          { path: this.paths.toc, kind: "updated" },
-          { path: this.paths.sidebar, kind: "updated" }
-        ],
-        snapshotRevision: value.revision
-      };
-    });
-  }
-  async previewDelete(entry) {
-    const { snapshot, tocText } = await this.scanReady();
-    const lines = (_nullishCoalesce(tocText, () => ( ""))).split("\n");
-    const lineIndex = resolveEntryLine(lines, snapshot, entry);
-    const indexes = _chunk3R7QSABBcjs.collectNoteIndexesInSubtree.call(void 0, lines, lineIndex);
-    const notes = indexes.map((index) => snapshot.notes.find((note) => note.index === index)).filter((note) => Boolean(note));
-    const filePaths = (await Promise.all(notes.map((note) => listFilesRecursively(note.directoryPath)))).flat();
-    return {
-      entry,
-      notes: notes.map((note) => ({
-        noteUuid: note.uuid,
-        index: note.index,
-        title: note.title,
-        directoryPath: note.directoryPath
-      })),
-      filePaths,
-      directoryPaths: notes.map((note) => note.directoryPath),
-      snapshotRevision: snapshot.revision
-    };
-  }
-  async deleteTocEntry(input) {
-    return this.queue.run(async () => {
-      const { snapshot, tocText } = await this.scanReady();
-      const config = requireConfig(snapshot);
-      assertRevision(snapshot.revision, input.expectedSnapshotRevision, "\u77E5\u8BC6\u5E93\u76EE\u5F55");
-      const lines = (_nullishCoalesce(tocText, () => ( ""))).split("\n");
-      const lineIndex = resolveEntryLine(lines, snapshot, input.entry);
-      const range = _chunk3R7QSABBcjs.getTocEntrySubtreeRange.call(void 0, lines, lineIndex);
-      const indexes = _chunk3R7QSABBcjs.collectNoteIndexesInSubtree.call(void 0, lines, lineIndex);
-      const notes = indexes.map((index) => snapshot.notes.find((note) => note.index === index)).filter((note) => Boolean(note));
-      lines.splice(range.start, range.end - range.start);
-      const remainingNotes = snapshot.notes.filter(
-        (note) => !indexes.includes(note.index)
-      );
-      const normalizedToc = normalizeTocContent(lines);
-      const movedDirectories = [];
-      try {
-        for (const note of notes) {
-          const temporary = _path2.default.join(
-            this.paths.notes,
-            `.${_path2.default.basename(note.directoryPath)}.desk-delete-${_crypto.randomUUID.call(void 0, )}`
-          );
-          await _promises2.default.rename(note.directoryPath, temporary);
-          movedDirectories.push({ original: note.directoryPath, temporary });
-        }
-        await writeFilesAtomically([
-          { path: this.paths.toc, data: normalizedToc },
-          {
-            path: this.paths.sidebar,
-            data: sidebarContent(normalizedToc.split("\n"), remainingNotes, config)
-          }
-        ]);
-      } catch (error) {
-        for (const moved of movedDirectories.reverse()) {
-          await _promises2.default.rename(moved.temporary, moved.original);
-        }
-        throw error;
-      }
-      for (const moved of movedDirectories) {
-        await _promises2.default.rm(moved.temporary, { recursive: true, force: true });
-      }
-      const value = await this.inspect();
-      return {
-        value,
-        changedFiles: [
-          ...notes.map((note) => ({
-            path: note.directoryPath,
-            kind: "deleted"
-          })),
-          { path: this.paths.toc, kind: "updated" },
-          { path: this.paths.sidebar, kind: "updated" }
-        ],
-        snapshotRevision: value.revision
-      };
-    });
-  }
-  async writeLocalAttachment(input) {
-    return this.queue.run(async () => {
-      const { snapshot } = await this.scanReady();
-      const note = findNote(snapshot, input.noteUuid);
-      const assetsPath = _path2.default.join(note.directoryPath, "assets");
-      assertPathInside(note.directoryPath, assetsPath);
-      const requestedName = sanitizeFileName(input.fileName);
-      const extension = _path2.default.extname(requestedName);
-      const base = _path2.default.basename(requestedName, extension);
-      let candidate = requestedName;
-      let suffix = 1;
-      while (true) {
-        try {
-          await _promises2.default.access(_path2.default.join(assetsPath, candidate));
-          candidate = `${base}-${suffix}${extension}`;
-          suffix++;
-        } catch (e6) {
-          break;
-        }
-      }
-      const absolutePath = _path2.default.join(assetsPath, candidate);
-      assertPathInside(assetsPath, absolutePath);
-      await writeFilesAtomically([{ path: absolutePath, data: input.data }]);
-      const value = {
-        absolutePath,
-        markdownPath: `./assets/${candidate}`
-      };
-      const refreshed = await this.inspect();
-      return {
-        value,
-        changedFiles: [{ path: absolutePath, kind: "created" }],
-        snapshotRevision: refreshed.revision
-      };
-    });
-  }
-};
-
-// workspace/index.ts
-function createWorkspace(options) {
-  return new Workspace(options);
-}
-
-
-
-exports.WorkspaceError = WorkspaceError; exports.createWorkspace = createWorkspace;
+exports.WorkspaceError = _chunkAGVER5MXcjs.WorkspaceError; exports.createWorkspace = _chunkAGVER5MXcjs.createWorkspace;