@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/cjs/frontmatter-formatting.cjs

@@ -0,0 +1,448 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for("Symbol.asyncDispose");
+  symbolConstructor.dispose ??= symbolConstructor.for("Symbol.dispose");
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return "/";
+    },
+    env: {},
+    platform: "android"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+  if (existingProcess.versions?.node) {
+    return;
+  }
+  const existingProcessRecord = existingProcess;
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+  existingProcessRecord["browser"] = true;
+}
+
+function keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/closebrackets",
+    "@codemirror/comment",
+    "@codemirror/fold",
+    "@codemirror/gutter",
+    "@codemirror/highlight",
+    "@codemirror/history",
+    "@codemirror/matchbrackets",
+    "@codemirror/panel",
+    "@codemirror/rangeset",
+    "@codemirror/rectangular-selection",
+    "@codemirror/stream-parser",
+    "@codemirror/tooltip"
+  ]);
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    if (globalThis.app.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var frontmatter_formatting_exports = {};
+__export(frontmatter_formatting_exports, {
+  enableFrontmatterFormattingPreservation: () => enableFrontmatterFormattingPreservation,
+  preserveFrontmatterFormatting: () => preserveFrontmatterFormatting
+});
+module.exports = __toCommonJS(frontmatter_formatting_exports);
+var import_object_utils = require('@mnaoumov/typescript-lib/object-utils');
+var import_string = require('@mnaoumov/typescript-lib/string');
+var import_obsidian = require('obsidian');
+var import_yaml = require('yaml');
+var import_frontmatter = require('./frontmatter.cjs');
+const EDIT_SCRIPT_CELL_LIMIT = 1e4;
+const EMPTY_MAPPING_FRAGMENT = "{}";
+const OBSIDIAN_STRINGIFY_OPTIONS = {
+  aliasDuplicateObjects: false,
+  lineWidth: 0,
+  // eslint-disable-next-line unicorn/name-replacements -- `nullStr` is the `yaml` package's own option name.
+  nullStr: ""
+};
+const PLACEHOLDER_KEY = "k";
+const SECOND_TO_LAST_INDEX = -2;
+const TRAILING_NEWLINE_REG_EXP = /\n$/;
+const UNRESOLVED_TAG_WARNING_CODE = "TAG_RESOLVE_FAILED";
+function enableFrontmatterFormattingPreservation() {
+  (0, import_frontmatter.registerFrontmatterFormattingPreserver)(preserveFrontmatterFormatting);
+}
+function preserveFrontmatterFormatting(content, newFrontmatter) {
+  const frontmatterInfo = (0, import_obsidian.getFrontMatterInfo)(content);
+  if (!frontmatterInfo.exists || Object.keys(newFrontmatter).length === 0) {
+    return null;
+  }
+  const splicedBody = spliceFrontmatterBody(frontmatterInfo.frontmatter, newFrontmatter);
+  return splicedBody === null ? null : (0, import_string.insertAt)({
+    $string: content,
+    endIndex: frontmatterInfo.to,
+    startIndex: frontmatterInfo.from,
+    substring: splicedBody
+  });
+}
+function buildEditScript(oldArray, newArray) {
+  const rawSteps = buildRawEditScript(oldArray, newArray);
+  const steps = [];
+  for (let index = 0; index < rawSteps.length; index++) {
+    const step = (0, import_object_utils.castTo)(rawSteps[index]);
+    const nextStep = rawSteps[index + 1];
+    if (step.kind === "remove" && nextStep?.kind === "insert" && checkIsMergeable(oldArray[step.oldIndex], newArray[nextStep.newIndex])) {
+      steps.push({ kind: "merge", newIndex: nextStep.newIndex, oldIndex: step.oldIndex });
+      index++;
+      continue;
+    }
+    if (step.kind !== "remove") {
+      steps.push({ kind: step.kind, newIndex: step.newIndex, oldIndex: step.oldIndex });
+    }
+  }
+  return steps;
+}
+function buildRawEditScript(oldArray, newArray) {
+  const oldLength = oldArray.length;
+  const newLength = newArray.length;
+  const commonLengths = Array.from({ length: oldLength + 1 }, () => Array.from({ length: newLength + 1 }, () => 0));
+  for (let oldIndex2 = oldLength - 1; oldIndex2 >= 0; oldIndex2--) {
+    for (let newIndex2 = newLength - 1; newIndex2 >= 0; newIndex2--) {
+      const row = (0, import_object_utils.castTo)(commonLengths[oldIndex2]);
+      const nextRow = (0, import_object_utils.castTo)(commonLengths[oldIndex2 + 1]);
+      row[newIndex2] = (0, import_object_utils.isDeepEqual)(oldArray[oldIndex2], newArray[newIndex2]) ? (0, import_object_utils.castTo)(nextRow[newIndex2 + 1]) + 1 : Math.max((0, import_object_utils.castTo)(nextRow[newIndex2]), (0, import_object_utils.castTo)(row[newIndex2 + 1]));
+    }
+  }
+  const steps = [];
+  let oldIndex = 0;
+  let newIndex = 0;
+  while (oldIndex < oldLength && newIndex < newLength) {
+    if ((0, import_object_utils.isDeepEqual)(oldArray[oldIndex], newArray[newIndex])) {
+      steps.push({ kind: "keep", newIndex, oldIndex });
+      oldIndex++;
+      newIndex++;
+      continue;
+    }
+    const removalRow = (0, import_object_utils.castTo)(commonLengths[oldIndex + 1]);
+    const insertionRow = (0, import_object_utils.castTo)(commonLengths[oldIndex]);
+    const removalCommonLength = (0, import_object_utils.castTo)(removalRow[newIndex]);
+    const insertionCommonLength = (0, import_object_utils.castTo)(insertionRow[newIndex + 1]);
+    if (removalCommonLength >= insertionCommonLength) {
+      steps.push({ kind: "remove", newIndex: -1, oldIndex });
+      oldIndex++;
+    } else {
+      steps.push({ kind: "insert", newIndex, oldIndex: -1 });
+      newIndex++;
+    }
+  }
+  for (; oldIndex < oldLength; oldIndex++) {
+    steps.push({ kind: "remove", newIndex: -1, oldIndex });
+  }
+  for (; newIndex < newLength; newIndex++) {
+    steps.push({ kind: "insert", newIndex, oldIndex: -1 });
+  }
+  return steps;
+}
+function checkCarriesIndent(item, indent) {
+  return import_yaml.CST.stringify(item).replace(/^\n+/, "").startsWith(" ".repeat(indent));
+}
+function checkHasAnchorOrAlias(contents) {
+  let hasAnchorOrAlias = false;
+  (0, import_yaml.visit)(contents, {
+    Node(_key, node) {
+      if (!(0, import_yaml.isAlias)(node) && node.anchor === void 0) {
+        return void 0;
+      }
+      hasAnchorOrAlias = true;
+      return import_yaml.visit.BREAK;
+    }
+  });
+  return hasAnchorOrAlias;
+}
+function checkIsMergeable(oldValue, newValue) {
+  return (0, import_frontmatter.checkIsPlainObject)(oldValue) && (0, import_frontmatter.checkIsPlainObject)(newValue) || Array.isArray(oldValue) && Array.isArray(newValue);
+}
+function checkIsSemanticMatch(splicedBody, newFrontmatter) {
+  let splicedValue;
+  try {
+    splicedValue = (0, import_obsidian.parseYaml)(splicedBody);
+  } catch {
+    return false;
+  }
+  return (0, import_object_utils.isDeepEqual)(splicedValue, (0, import_obsidian.parseYaml)((0, import_obsidian.stringifyYaml)(newFrontmatter)));
+}
+function createMapItem(key, value, indent) {
+  const fragment = (0, import_yaml.stringify)({ [key]: value }, OBSIDIAN_STRINGIFY_OPTIONS);
+  return fragment.trimEnd() === EMPTY_MAPPING_FRAGMENT ? null : liftFragmentItem(fragment, indent, true);
+}
+function createSeqItem(value, indent) {
+  return liftFragmentItem((0, import_yaml.stringify)([value], OBSIDIAN_STRINGIFY_OPTIONS), indent, true);
+}
+function createSpaceToken(indent) {
+  return {
+    indent,
+    offset: -1,
+    source: " ".repeat(indent),
+    type: "space"
+  };
+}
+function didMergeMap(token, oldObject, newObject) {
+  normalizeItemIndents(token);
+  const itemsByKey = /* @__PURE__ */ new Map();
+  for (const item of token.items) {
+    const key = readItemKey(item);
+    if (key === null || itemsByKey.has(key)) {
+      return false;
+    }
+    itemsByKey.set(key, item);
+  }
+  const mergedItems = [];
+  for (const [key, newValue] of Object.entries(newObject)) {
+    const item = itemsByKey.get(key);
+    if (!item) {
+      const createdItem = createMapItem(key, newValue, token.indent);
+      if (createdItem !== null) {
+        mergedItems.push(createdItem);
+      }
+      continue;
+    }
+    mergeItemValue(item, oldObject[key], newValue, token.indent, false);
+    mergedItems.push(item);
+  }
+  if (mergedItems.length === 0) {
+    return false;
+  }
+  finalizeItems(mergedItems);
+  token.items = (0, import_object_utils.castTo)(mergedItems);
+  return true;
+}
+function didMergeSeq(token, oldArray, newArray) {
+  if (oldArray.length * newArray.length > EDIT_SCRIPT_CELL_LIMIT) {
+    return false;
+  }
+  normalizeItemIndents(token);
+  const mergedItems = [];
+  for (const step of buildEditScript(oldArray, newArray)) {
+    if (step.kind === "insert") {
+      mergedItems.push(createSeqItem(newArray[step.newIndex], token.indent));
+      continue;
+    }
+    const item = (0, import_object_utils.castTo)(token.items[step.oldIndex]);
+    if (step.kind === "merge") {
+      mergeItemValue(item, oldArray[step.oldIndex], newArray[step.newIndex], token.indent, true);
+    }
+    mergedItems.push(item);
+  }
+  if (mergedItems.length === 0) {
+    return false;
+  }
+  finalizeItems(mergedItems);
+  token.items = (0, import_object_utils.castTo)(mergedItems);
+  return true;
+}
+function didNormalizeFirstItemIndent(precedingTokens, collection) {
+  const firstItem = (0, import_object_utils.castTo)(collection.items[0]);
+  if (collection.indent === 0 || checkCarriesIndent(firstItem, collection.indent)) {
+    return true;
+  }
+  const lastToken = precedingTokens?.at(-1);
+  if (lastToken?.type !== "space" || precedingTokens?.at(SECOND_TO_LAST_INDEX)?.type !== "newline") {
+    return false;
+  }
+  precedingTokens.pop();
+  firstItem.start.unshift(lastToken);
+  return true;
+}
+function emitMapItemTokens(value, indent, shouldPreferFlow) {
+  const fragment = shouldPreferFlow ? `${PLACEHOLDER_KEY}: ${stringifyFlow(value)}` : (0, import_yaml.stringify)({ [PLACEHOLDER_KEY]: value }, OBSIDIAN_STRINGIFY_OPTIONS);
+  const item = liftFragmentItem(fragment, indent, false);
+  return { separatorTokens: (0, import_object_utils.castTo)(item.sep), value: item.value };
+}
+function emitSeqItem(value, indent, shouldPreferFlow) {
+  const fragment = shouldPreferFlow ? `- ${stringifyFlow(value)}` : (0, import_yaml.stringify)([value], OBSIDIAN_STRINGIFY_OPTIONS);
+  return liftFragmentItem(fragment, indent, false);
+}
+function finalizeItems(items) {
+  const firstItem = (0, import_object_utils.castTo)(items[0]);
+  while (firstItem.start[0]?.type === "newline") {
+    firstItem.start.shift();
+  }
+}
+function indentLines(text, indent) {
+  if (indent === 0) {
+    return text;
+  }
+  const padding = " ".repeat(indent);
+  return text.split("\n").map((line) => line === "" ? line : padding + line).join("\n");
+}
+function liftFragmentItem(fragment, indent, shouldCarryIndent) {
+  const root = (0, import_yaml.parseDocument)(indentLines(fragment, indent), { keepSourceTokens: true }).contents?.srcToken;
+  const item = (0, import_object_utils.castTo)((0, import_object_utils.castTo)(root).items[0]);
+  if (shouldCarryIndent && indent > 0) {
+    item.start.unshift(createSpaceToken(indent));
+  }
+  return item;
+}
+function mergeItemValue(item, oldValue, newValue, parentIndent, isSeqItem) {
+  if ((0, import_object_utils.isDeepEqual)(oldValue, newValue)) {
+    return;
+  }
+  const valueToken = item.value;
+  const precedingTokens = isSeqItem ? item.start : item.sep;
+  if (valueToken?.type === "block-map" && (0, import_frontmatter.checkIsPlainObject)(oldValue) && (0, import_frontmatter.checkIsPlainObject)(newValue) && didNormalizeFirstItemIndent(precedingTokens, valueToken) && didMergeMap(valueToken, oldValue, newValue) || valueToken?.type === "block-seq" && Array.isArray(oldValue) && Array.isArray(newValue) && didNormalizeFirstItemIndent(precedingTokens, valueToken) && didMergeSeq(valueToken, oldValue, newValue)) {
+    return;
+  }
+  replaceItemValue(item, newValue, parentIndent, valueToken?.type === "flow-collection", isSeqItem);
+}
+function normalizeItemIndents(collection) {
+  for (const [index, item] of collection.items.entries()) {
+    const nextItem = (0, import_object_utils.castTo)(collection.items[index + 1]);
+    if (!nextItem || item.value) {
+      continue;
+    }
+    const trailingTokens = item.sep?.length ? item.sep : item.start;
+    const lastToken = trailingTokens.at(-1);
+    if (lastToken?.type !== "space" || trailingTokens.at(SECOND_TO_LAST_INDEX)?.type !== "newline") {
+      continue;
+    }
+    trailingTokens.pop();
+    nextItem.start.unshift(lastToken);
+  }
+}
+function readItemKey(item) {
+  return !item.key || !import_yaml.CST.isScalar(item.key) ? null : (0, import_object_utils.castTo)(import_yaml.CST.resolveAsScalar(item.key)).value;
+}
+function replaceItemValue(item, newValue, indent, shouldPreferFlow, isSeqItem) {
+  if (isSeqItem) {
+    setItemValue(item, emitSeqItem(newValue, indent, shouldPreferFlow).value);
+    return;
+  }
+  const emittedTokens = emitMapItemTokens(newValue, indent, shouldPreferFlow);
+  item.sep = emittedTokens.separatorTokens;
+  setItemValue(item, emittedTokens.value);
+}
+function setItemValue(item, value) {
+  if (value === void 0) {
+    delete item.value;
+    return;
+  }
+  item.value = value;
+}
+function spliceFrontmatterBody(source, newFrontmatter) {
+  const tokens = [...new import_yaml.Parser().parse(source)];
+  const documents = [...new import_yaml.Composer({ keepSourceTokens: true }).compose(tokens, true)];
+  const document = documents.length === 1 ? documents[0] : void 0;
+  if (!document || document.errors.length > 0 || document.warnings.some((warning) => warning.code === UNRESOLVED_TAG_WARNING_CODE)) {
+    return null;
+  }
+  const contents = document.contents;
+  const rootToken = contents?.srcToken;
+  if (!contents || rootToken?.type !== "block-map" || checkHasAnchorOrAlias(contents)) {
+    return null;
+  }
+  const oldFrontmatter = (0, import_object_utils.castTo)(document.toJS());
+  if (!didMergeMap(rootToken, oldFrontmatter, (0, import_object_utils.castTo)(newFrontmatter))) {
+    return null;
+  }
+  const emittedBody = tokens.map((token) => import_yaml.CST.stringify(token)).join("");
+  const splicedBody = `${emittedBody.replace(TRAILING_NEWLINE_REG_EXP, "")}
+`;
+  return checkIsSemanticMatch(splicedBody, newFrontmatter) ? splicedBody : null;
+}
+function stringifyFlow(value) {
+  return (0, import_yaml.stringify)(value, {
+    ...OBSIDIAN_STRINGIFY_OPTIONS,
+    collectionStyle: "flow",
+    flowCollectionPadding: false
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  enableFrontmatterFormattingPreservation,
+  preserveFrontmatterFormatting
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/frontmatter-formatting.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Rewrites a note's YAML front matter by splicing its concrete syntax tree, so every region a change does not reach\n * keeps the exact bytes its author wrote \u2014 comments and the whitespace inside them, quoting style, blank lines,\n * indentation width, flow versus block collections, and folded and literal scalars.\n *\n * Obsidian's own `processFrontMatter()` parses the block to a plain object and re-stringifies the whole of it, so a\n * callback that changes one key rewrites every other. Re-emitting the parsed document instead of the raw text does not\n * fix that: five of the losses survive every emit option the `yaml` package offers. Splicing the CST does fix it,\n * because an untouched token is never re-emitted at all \u2014 {@link https://github.com/eemeli/yaml | the library} keeps\n * each token's original source text and {@link https://eemeli.org/yaml/#cst-parser | `CST.stringify`} concatenates it.\n *\n * This module is DELIBERATELY not on the default path. It needs the `yaml` package's CST API, which Obsidian does not\n * hand to plugins through its module map \u2014 that map is `obsidian`, `@codemirror/*` and `@lezer/*` and nothing else \u2014\n * so the package cannot be marked external and lands in the consuming plugin's `main.js`, about 100 KB of it. A plugin\n * opts in by calling {@link enableFrontmatterFormattingPreservation} once, and only it pays.\n */\n\nimport type { GenericObject } from '@mnaoumov/typescript-lib/type-guards';\nimport type {\n  Node,\n  ParsedNode\n} from 'yaml';\n\nimport {\n  castTo,\n  isDeepEqual\n} from '@mnaoumov/typescript-lib/object-utils';\nimport { insertAt } from '@mnaoumov/typescript-lib/string';\nimport {\n  getFrontMatterInfo,\n  parseYaml,\n  stringifyYaml\n} from 'obsidian';\nimport {\n  Composer,\n  CST,\n  isAlias,\n  parseDocument,\n  Parser,\n  stringify,\n  visit\n} from 'yaml';\n\nimport {\n  checkIsPlainObject,\n  registerFrontmatterFormattingPreserver\n} from './frontmatter.ts';\n\n/**\n * A block or flow collection token whose items the splice rearranges.\n */\ntype CollectionToken = CST.BlockMap | CST.BlockSequence;\n\n/**\n * One step of the edit script {@link buildEditScript} derives for a sequence.\n *\n * `keep` reuses the old item's token untouched, `merge` reuses it and rewrites its value in place, and `insert`\n * emits a brand new item. A removal produces no step at all \u2014 it is simply an old index no step names.\n */\ninterface EditStep {\n  readonly kind: 'insert' | 'keep' | 'merge';\n  readonly newIndex: number;\n  readonly oldIndex: number;\n}\n\n/**\n * The `sep` and `value` tokens of a freshly emitted block-map item, ready to be transplanted onto an existing one.\n */\ninterface MapItemTokens {\n  readonly separatorTokens: CST.SourceToken[];\n  readonly value: CST.Token | undefined;\n}\n\n/**\n * A sequence long enough that the quadratic edit script stops being worth its cost.\n *\n * A front matter sequence is a tag list or an alias list, so this is never approached in practice; it is here so that a\n * pathological one degrades to a whole-collection re-emit instead of stalling the write queue.\n */\nconst EDIT_SCRIPT_CELL_LIMIT = 10_000;\n\n/**\n * What a mapping emits as when every one of its values is `undefined`, i.e. when it has nothing to write at all.\n */\nconst EMPTY_MAPPING_FRAGMENT = '{}';\n\n/**\n * The options Obsidian itself passes to `stringify()`, read out of its bundle.\n *\n * Every fragment this module emits goes through them, so a fragment it writes is byte-identical to the one the\n * parse-and-stringify path would have written for the same value.\n */\nconst OBSIDIAN_STRINGIFY_OPTIONS = {\n  aliasDuplicateObjects: false,\n  lineWidth: 0,\n  // eslint-disable-next-line unicorn/name-replacements -- `nullStr` is the `yaml` package's own option name.\n  nullStr: ''\n} as const;\n\n/**\n * The key a fragment is emitted under when only its value is wanted. Never reaches the output.\n */\nconst PLACEHOLDER_KEY = 'k';\n\n/**\n * The `Array.at()` index of the token before the last one, which is where a newline sits when an indent follows it.\n */\nconst SECOND_TO_LAST_INDEX = -2;\n\nconst TRAILING_NEWLINE_REG_EXP = /\\n$/;\n\nconst UNRESOLVED_TAG_WARNING_CODE = 'TAG_RESOLVE_FAILED';\n\n/**\n * One step of the raw edit script, before removals are folded into the insertions that follow them.\n */\ninterface RawEditStep {\n  readonly kind: 'insert' | 'keep' | 'remove';\n  readonly newIndex: number;\n  readonly oldIndex: number;\n}\n\n/**\n * What `CST.resolveAsScalar` hands back for a key: the scalar's own text, never a schema-resolved value.\n */\ninterface ResolvedScalar {\n  readonly value: string;\n}\n\n/**\n * Registers this module's engine as the front matter formatting preserver for every write this library performs.\n *\n * Call it once, from a plugin's `onloadImpl()`. It takes effect for `processFrontmatter()`, `applyFileChanges()` and\n * every other path that reaches `setFrontmatter()`, including the ones the calling plugin does not invoke itself.\n *\n * There is one preserver per realm, so two plugins that both call this simply agree.\n */\nexport function enableFrontmatterFormattingPreservation(): void {\n  registerFrontmatterFormattingPreserver(preserveFrontmatterFormatting);\n}\n\n/**\n * Rewrites the front matter of a note, keeping the original bytes of everything the change does not reach.\n *\n * It is the engine {@link enableFrontmatterFormattingPreservation} registers, and can be called directly as well.\n *\n * `null` means \"this one is not mine\": the block does not exist, the new front matter is empty (both are the\n * parse-and-stringify path's business, unchanged), or the splice could not be proved faithful. The proof is not\n * hand-waved \u2014 the spliced block is re-parsed and compared against the value the parse-and-stringify path would have\n * produced for the same input, and any difference returns `null`. That is what makes this strictly better than that\n * path or identical to it, and never worse.\n *\n * @param content - The note to rewrite the front matter of.\n * @param newFrontmatter - The front matter to write.\n * @returns The new note, or `null` when the caller should parse the block and write the whole of it out again instead.\n */\nexport function preserveFrontmatterFormatting(content: string, newFrontmatter: object): null | string {\n  const frontmatterInfo = getFrontMatterInfo(content);\n  if (!frontmatterInfo.exists || Object.keys(newFrontmatter).length === 0) {\n    return null;\n  }\n\n  const splicedBody = spliceFrontmatterBody(frontmatterInfo.frontmatter, newFrontmatter);\n  return splicedBody === null\n    ? null\n    : insertAt({\n      $string: content,\n      endIndex: frontmatterInfo.to,\n      startIndex: frontmatterInfo.from,\n      substring: splicedBody\n    });\n}\n\n/**\n * Derives the edit script that turns `oldArray` into `newArray`, reusing as many of the old items as it can.\n *\n * A longest-common-subsequence diff over value equality is what recovers the AUTHOR's operation. Replaying the\n * mutation an array method performed instead \u2014 `[a, b, c].splice(1, 1)` writes `[1] = 'c'` then truncates \u2014 would\n * overwrite `b`'s node with `c`'s value and delete `c`'s node, so `b`'s comment would end up annotating `c`: exactly\n * the misattribution this module exists to prevent.\n *\n * A removal immediately followed by an insertion of the same shape is folded into a single `merge`, so an item edited\n * in place (`[{ qty: 1 }]` to `[{ qty: 2 }]`) keeps its own node and its comments rather than being rebuilt.\n *\n * @param oldArray - The sequence as the source holds it.\n * @param newArray - The sequence as it is to be written.\n * @returns The steps to apply, in output order.\n */\nfunction buildEditScript(oldArray: readonly unknown[], newArray: readonly unknown[]): EditStep[] {\n  const rawSteps = buildRawEditScript(oldArray, newArray);\n  const steps: EditStep[] = [];\n\n  for (let index = 0; index < rawSteps.length; index++) {\n    const step = castTo<RawEditStep>(rawSteps[index]);\n    const nextStep = rawSteps[index + 1];\n    if (\n      step.kind === 'remove' && nextStep?.kind === 'insert'\n      && checkIsMergeable(oldArray[step.oldIndex], newArray[nextStep.newIndex])\n    ) {\n      steps.push({ kind: 'merge', newIndex: nextStep.newIndex, oldIndex: step.oldIndex });\n      index++;\n      continue;\n    }\n\n    if (step.kind !== 'remove') {\n      steps.push({ kind: step.kind, newIndex: step.newIndex, oldIndex: step.oldIndex });\n    }\n  }\n\n  return steps;\n}\n\nfunction buildRawEditScript(oldArray: readonly unknown[], newArray: readonly unknown[]): RawEditStep[] {\n  const oldLength = oldArray.length;\n  const newLength = newArray.length;\n  const commonLengths = Array.from({ length: oldLength + 1 }, () => Array.from({ length: newLength + 1 }, () => 0));\n\n  for (let oldIndex = oldLength - 1; oldIndex >= 0; oldIndex--) {\n    for (let newIndex = newLength - 1; newIndex >= 0; newIndex--) {\n      const row = castTo<number[]>(commonLengths[oldIndex]);\n      const nextRow = castTo<number[]>(commonLengths[oldIndex + 1]);\n      row[newIndex] = isDeepEqual(oldArray[oldIndex], newArray[newIndex])\n        ? castTo<number>(nextRow[newIndex + 1]) + 1\n        : Math.max(castTo<number>(nextRow[newIndex]), castTo<number>(row[newIndex + 1]));\n    }\n  }\n\n  const steps: RawEditStep[] = [];\n  let oldIndex = 0;\n  let newIndex = 0;\n\n  while (oldIndex < oldLength && newIndex < newLength) {\n    if (isDeepEqual(oldArray[oldIndex], newArray[newIndex])) {\n      steps.push({ kind: 'keep', newIndex, oldIndex });\n      oldIndex++;\n      newIndex++;\n      continue;\n    }\n\n    const removalRow = castTo<number[]>(commonLengths[oldIndex + 1]);\n    const insertionRow = castTo<number[]>(commonLengths[oldIndex]);\n    const removalCommonLength = castTo<number>(removalRow[newIndex]);\n    const insertionCommonLength = castTo<number>(insertionRow[newIndex + 1]);\n    if (removalCommonLength >= insertionCommonLength) {\n      steps.push({ kind: 'remove', newIndex: -1, oldIndex });\n      oldIndex++;\n    } else {\n      steps.push({ kind: 'insert', newIndex, oldIndex: -1 });\n      newIndex++;\n    }\n  }\n\n  for (; oldIndex < oldLength; oldIndex++) {\n    steps.push({ kind: 'remove', newIndex: -1, oldIndex });\n  }\n\n  for (; newIndex < newLength; newIndex++) {\n    steps.push({ kind: 'insert', newIndex, oldIndex: -1 });\n  }\n\n  return steps;\n}\n\nfunction checkCarriesIndent(item: CST.CollectionItem, indent: number): boolean {\n  return CST.stringify(item).replace(/^\\n+/, '').startsWith(' '.repeat(indent));\n}\n\nfunction checkHasAnchorOrAlias(contents: ParsedNode): boolean {\n  let hasAnchorOrAlias = false;\n\n  visit(contents, {\n    Node(_key: unknown, node: Node): symbol | undefined {\n      if (!isAlias(node) && node.anchor === undefined) {\n        return undefined;\n      }\n\n      hasAnchorOrAlias = true;\n      return visit.BREAK;\n    }\n  });\n\n  return hasAnchorOrAlias;\n}\n\nfunction checkIsMergeable(oldValue: unknown, newValue: unknown): boolean {\n  return (checkIsPlainObject(oldValue) && checkIsPlainObject(newValue)) || (Array.isArray(oldValue) && Array.isArray(newValue));\n}\n\n/**\n * Checks the spliced block against the one the parse-and-stringify path would have written for the same value.\n *\n * Comparing the two PARSED values rather than the two texts is the whole point: the texts are supposed to differ \u2014 that\n * is the formatting this module preserves \u2014 while the values must not. Comparing against that path's output rather than\n * against `newFrontmatter` itself is what makes the guarantee exact, since both sides then carry the same round-trip\n * losses, `undefined` values dropped and timestamps read back as dates among them.\n *\n * @param splicedBody - The spliced block text.\n * @param newFrontmatter - The front matter that was to be written.\n * @returns Whether the spliced block reads back as the value the parse-and-stringify path would have written.\n */\nfunction checkIsSemanticMatch(splicedBody: string, newFrontmatter: object): boolean {\n  let splicedValue: unknown;\n\n  try {\n    splicedValue = parseYaml(splicedBody);\n    /*\n     * v8 ignore start -- A net, not a path: `parseYaml` THROWS on a block it cannot read rather than reporting it, and\n     * a splice could produce one. A 36 000-mutation differential fuzz found 93 that did, every one of them the\n     * valueless-item shape `normalizeItemIndents` now repairs, and none at all afterwards \u2014 so there is no input left\n     * to pin this with, and the contract that it upholds (decline, never throw) is the one this module's callers rely\n     * on. Do not delete it on the strength of that: it is the reason a future shape is a fallback rather than a crash.\n     */\n  } catch {\n    return false;\n    /* v8 ignore stop */\n  }\n\n  return isDeepEqual(splicedValue, parseYaml(stringifyYaml(newFrontmatter)));\n}\n\nfunction createMapItem(key: string, value: unknown, indent: number): CST.CollectionItem | null {\n  const fragment = stringify({ [key]: value }, OBSIDIAN_STRINGIFY_OPTIONS);\n  // An empty mapping means the value is `undefined`, which the rewrite path drops as well. Drop the key with it.\n  return fragment.trimEnd() === EMPTY_MAPPING_FRAGMENT ? null : liftFragmentItem(fragment, indent, true);\n}\n\nfunction createSeqItem(value: unknown, indent: number): CST.CollectionItem {\n  return liftFragmentItem(stringify([value], OBSIDIAN_STRINGIFY_OPTIONS), indent, true);\n}\n\nfunction createSpaceToken(indent: number): CST.SourceToken {\n  return {\n    indent,\n    offset: -1,\n    source: ' '.repeat(indent),\n    type: 'space'\n  };\n}\n\n/**\n * Rebuilds a block map's items so it represents `newObject`, reusing each surviving key's own item token.\n *\n * The items are rebuilt in the NEW object's key order rather than the source's, so a callback that sorts or reorders\n * keys still sorts them \u2014 the reordered key simply takes its comment, its quoting and its value formatting with it.\n *\n * `false` means the caller should re-emit this whole collection instead: a duplicate key, a key no string can name, or\n * a nested merge that gave up.\n *\n * @param token - The block map to rebuild.\n * @param oldObject - The mapping as the source holds it.\n * @param newObject - The mapping to write.\n * @returns Whether the token now represents `newObject`.\n */\nfunction didMergeMap(token: CST.BlockMap, oldObject: GenericObject, newObject: GenericObject): boolean {\n  normalizeItemIndents(token);\n  const itemsByKey = new Map<string, CST.CollectionItem>();\n\n  for (const item of token.items) {\n    const key = readItemKey(item);\n    if (key === null || itemsByKey.has(key)) {\n      return false;\n    }\n\n    itemsByKey.set(key, item);\n  }\n\n  const mergedItems: CST.CollectionItem[] = [];\n\n  for (const [key, newValue] of Object.entries(newObject)) {\n    const item = itemsByKey.get(key);\n\n    if (!item) {\n      const createdItem = createMapItem(key, newValue, token.indent);\n      if (createdItem !== null) {\n        mergedItems.push(createdItem);\n      }\n\n      continue;\n    }\n\n    mergeItemValue(item, oldObject[key], newValue, token.indent, false);\n    mergedItems.push(item);\n  }\n\n  if (mergedItems.length === 0) {\n    return false;\n  }\n\n  finalizeItems(mergedItems);\n  token.items = castTo<CST.BlockMap['items']>(mergedItems);\n  return true;\n}\n\n/**\n * Rebuilds a block sequence's items so it represents `newArray`, reusing the token of every item that survives.\n *\n * @param token - The block sequence to rebuild.\n * @param oldArray - The sequence as the source holds it.\n * @param newArray - The sequence to write.\n * @returns Whether the token now represents `newArray`.\n */\nfunction didMergeSeq(token: CST.BlockSequence, oldArray: readonly unknown[], newArray: readonly unknown[]): boolean {\n  if (oldArray.length * newArray.length > EDIT_SCRIPT_CELL_LIMIT) {\n    return false;\n  }\n\n  normalizeItemIndents(token);\n  const mergedItems: CST.CollectionItem[] = [];\n\n  for (const step of buildEditScript(oldArray, newArray)) {\n    if (step.kind === 'insert') {\n      mergedItems.push(createSeqItem(newArray[step.newIndex], token.indent));\n      continue;\n    }\n\n    const item = castTo<CST.CollectionItem>(token.items[step.oldIndex]);\n    if (step.kind === 'merge') {\n      mergeItemValue(item, oldArray[step.oldIndex], newArray[step.newIndex], token.indent, true);\n    }\n\n    mergedItems.push(item);\n  }\n\n  if (mergedItems.length === 0) {\n    return false;\n  }\n\n  finalizeItems(mergedItems);\n  token.items = castTo<CST.BlockSequence['items']>(mergedItems);\n  return true;\n}\n\n/**\n * Gives a nested collection's first item the leading indent of its own, so the items become interchangeable.\n *\n * A nested collection's first item carries no indent in the source: the indent sits in whatever precedes the\n * collection \u2014 the separator's trailing spaces, or the dash of the sequence item it belongs to. Every later item\n * carries its own. Removing or reordering the first item without repairing that leaves the survivor doubly indented,\n * so the indent is moved out of the separator and onto the item before anything is rearranged.\n *\n * The one shape it cannot repair is a first item written INLINE with what precedes it (`- name: a`), where there is no\n * indent to move because the item is not at the start of its line. Such a collection is re-emitted whole instead.\n *\n * @param precedingTokens - The separator tokens that sit between the parent and the collection.\n * @param collection - The collection whose first item is to carry its own indent.\n * @returns Whether the collection's items are now interchangeable.\n */\nfunction didNormalizeFirstItemIndent(precedingTokens: CST.SourceToken[] | undefined, collection: CollectionToken): boolean {\n  // A parsed block collection always holds at least one item, or it would not have parsed as a collection at all.\n  const firstItem = castTo<CST.CollectionItem>(collection.items[0]);\n\n  if (collection.indent === 0 || checkCarriesIndent(firstItem, collection.indent)) {\n    return true;\n  }\n\n  const lastToken = precedingTokens?.at(-1);\n  if (lastToken?.type !== 'space' || precedingTokens?.at(SECOND_TO_LAST_INDEX)?.type !== 'newline') {\n    return false;\n  }\n\n  precedingTokens.pop();\n  firstItem.start.unshift(lastToken);\n  return true;\n}\n\nfunction emitMapItemTokens(value: unknown, indent: number, shouldPreferFlow: boolean): MapItemTokens {\n  const fragment = shouldPreferFlow\n    ? `${PLACEHOLDER_KEY}: ${stringifyFlow(value)}`\n    : stringify({ [PLACEHOLDER_KEY]: value }, OBSIDIAN_STRINGIFY_OPTIONS);\n  const item = liftFragmentItem(fragment, indent, false);\n  return { separatorTokens: castTo<CST.SourceToken[]>(item.sep), value: item.value };\n}\n\nfunction emitSeqItem(value: unknown, indent: number, shouldPreferFlow: boolean): CST.CollectionItem {\n  const fragment = shouldPreferFlow ? `- ${stringifyFlow(value)}` : stringify([value], OBSIDIAN_STRINGIFY_OPTIONS);\n  return liftFragmentItem(fragment, indent, false);\n}\n\n/**\n * Makes the merged items of a collection joinable again, whatever the merge did to their order.\n *\n * An item that was not first can carry the blank line that separated it from its predecessor, which becomes a leading\n * blank line once it IS first, and nothing in the item tokens themselves shows it. Every item already ends in its own\n * newline, because Obsidian's front matter block always ends in one, so reordering never joins two items on one line.\n *\n * @param items - The merged items, mutated in place.\n */\nfunction finalizeItems(items: CST.CollectionItem[]): void {\n  const firstItem = castTo<CST.CollectionItem>(items[0]);\n  while (firstItem.start[0]?.type === 'newline') {\n    firstItem.start.shift();\n  }\n}\n\nfunction indentLines(text: string, indent: number): string {\n  if (indent === 0) {\n    return text;\n  }\n\n  const padding = ' '.repeat(indent);\n  return text.split('\\n').map((line) => line === '' ? line : padding + line).join('\\n');\n}\n\n/**\n * Parses a freshly emitted fragment and hands back its one collection item, indented to sit where it is going.\n *\n * The fragment's own lines are indented before parsing, so every token inside it carries the absolute indent the\n * output needs. The item's OWN leading indent is not part of that \u2014 a first item never carries one, the indent being\n * supplied by whatever precedes the collection \u2014 so it is prepended as a token, which is what makes the item uniform\n * with its new siblings and therefore free to be reordered or to become the first.\n *\n * The fragment was produced by `stringify` a line above the call, as a one-item block collection, so it always parses\n * back as one \u2014 which is why this reads the item out rather than checking for it. Were that ever to stop holding, the\n * resulting throw is caught by `setFrontmatter`'s seam, which reports it and writes the block the ordinary way.\n *\n * @param fragment - The emitted YAML fragment, at indent zero.\n * @param indent - The indent the item will sit at.\n * @param shouldCarryIndent - Whether to prepend the item's own leading indent token.\n * @returns The item.\n */\nfunction liftFragmentItem(fragment: string, indent: number, shouldCarryIndent: boolean): CST.CollectionItem {\n  const root = parseDocument(indentLines(fragment, indent), { keepSourceTokens: true }).contents?.srcToken;\n  const item = castTo<CST.CollectionItem>(castTo<CollectionToken>(root).items[0]);\n\n  if (shouldCarryIndent && indent > 0) {\n    item.start.unshift(createSpaceToken(indent));\n  }\n\n  return item;\n}\n\n/**\n * Rewrites an item's value in place where it can, and re-emits the whole value where it cannot.\n *\n * @param item - The collection item to rewrite the value of.\n * @param oldValue - The value the source holds.\n * @param newValue - The value to write.\n * @param parentIndent - The indent of the collection the item belongs to.\n * @param isSeqItem - Whether the item is a sequence item, which carries no `sep` and no key.\n */\nfunction mergeItemValue(item: CST.CollectionItem, oldValue: unknown, newValue: unknown, parentIndent: number, isSeqItem: boolean): void {\n  if (isDeepEqual(oldValue, newValue)) {\n    // Untouched: its bytes stay exactly as its author wrote them. This is the whole point of the module.\n    return;\n  }\n\n  const valueToken = item.value;\n  const precedingTokens = isSeqItem ? item.start : item.sep;\n\n  if (\n    (valueToken?.type === 'block-map' && checkIsPlainObject(oldValue) && checkIsPlainObject(newValue)\n      && didNormalizeFirstItemIndent(precedingTokens, valueToken) && didMergeMap(valueToken, oldValue, newValue)) || (valueToken?.type === 'block-seq' && Array.isArray(oldValue) && Array.isArray(newValue)\n        && didNormalizeFirstItemIndent(precedingTokens, valueToken) && didMergeSeq(valueToken, oldValue, newValue))\n  ) {\n    return;\n  }\n\n  replaceItemValue(item, newValue, parentIndent, valueToken?.type === 'flow-collection', isSeqItem);\n}\n\n/**\n * Gives every item of a collection the indent of its own line, so that any of them can be removed or moved.\n *\n * An item with NO VALUE \u2014 a bare `-`, or `key:` with nothing after it \u2014 absorbs the newline that ends its line AND the\n * indent of the line after it, because the parser has nothing else to hang them on. Removing or moving such an item\n * therefore takes its successor's indent with it, and the block that comes back does not parse at all.\n *\n * Measured: over a 36 000-mutation differential fuzz this ONE shape accounted for every splice the safety net had to\n * refuse on unreadable output \u2014 93 of them \u2014 so it is a fidelity fix rather than a correctness one, the safety net\n * having already made each of those a fallback.\n *\n * @param collection - The collection whose items are to carry their own indent.\n */\nfunction normalizeItemIndents(collection: CollectionToken): void {\n  for (const [index, item] of collection.items.entries()) {\n    const nextItem = castTo<CST.CollectionItem | undefined>(collection.items[index + 1]);\n    if (!nextItem || item.value) {\n      continue;\n    }\n\n    // A map item hangs them on its `sep`, a sequence item on its `start`, that being all it has.\n    const trailingTokens = item.sep?.length ? item.sep : item.start;\n    const lastToken = trailingTokens.at(-1);\n    if (lastToken?.type !== 'space' || trailingTokens.at(SECOND_TO_LAST_INDEX)?.type !== 'newline') {\n      continue;\n    }\n\n    trailingTokens.pop();\n    nextItem.start.unshift(lastToken);\n  }\n}\n\n/**\n * Names the key an item is addressed by, or `null` when no string can name it.\n *\n * `resolveAsScalar` yields the scalar's TEXT rather than a schema-resolved value, so the answer is always a string \u2014\n * and it is the same string the plain-object projection both sides of the merge are compared through, which is what\n * lets a `42:` key match the projection's `'42'` without quoting it on the way out.\n *\n * @param item - The item to name the key of.\n * @returns The key, or `null` when the key is a collection rather than a scalar.\n */\nfunction readItemKey(item: CST.CollectionItem): null | string {\n  return !item.key || !CST.isScalar(item.key) ? null : castTo<ResolvedScalar>(CST.resolveAsScalar(item.key)).value;\n}\n\nfunction replaceItemValue(item: CST.CollectionItem, newValue: unknown, indent: number, shouldPreferFlow: boolean, isSeqItem: boolean): void {\n  if (isSeqItem) {\n    setItemValue(item, emitSeqItem(newValue, indent, shouldPreferFlow).value);\n    return;\n  }\n\n  const emittedTokens = emitMapItemTokens(newValue, indent, shouldPreferFlow);\n  // eslint-disable-next-line unicorn/name-replacements -- `sep` is the `yaml` package's own property name.\n  item.sep = emittedTokens.separatorTokens;\n  setItemValue(item, emittedTokens.value);\n}\n\n/**\n * Assigns an item's value token, removing the property outright when the emitted value has none.\n *\n * A key with a `null` value emits as `key:` with nothing after the separator, so the item genuinely has no value\n * token \u2014 and under `exactOptionalPropertyTypes` that is a property to delete, not one to set to `undefined`.\n *\n * @param item - The item to assign the value token of.\n * @param value - The value token, or `undefined` when the emitted value has none.\n */\nfunction setItemValue(item: CST.CollectionItem, value: CST.Token | undefined): void {\n  if (value === undefined) {\n    delete item.value;\n    return;\n  }\n\n  item.value = value;\n}\n\n/**\n * Splices the text INSIDE a front matter block's delimiters, leaving both `---` lines untouched.\n *\n * @param source - The front matter block's text.\n * @param newFrontmatter - The front matter to write.\n * @returns The new block text, or `null` when the splice could not be proved faithful.\n */\nfunction spliceFrontmatterBody(source: string, newFrontmatter: object): null | string {\n  const tokens = [...new Parser().parse(source)];\n  const documents = [...new Composer({ keepSourceTokens: true }).compose(tokens, true)];\n  // A second document is reachable \u2014 a `...` end marker starts one \u2014 and splicing the first would emit both.\n  const document = documents.length === 1 ? documents[0] : undefined;\n\n  if (!document || document.errors.length > 0 || document.warnings.some((warning) => warning.code === UNRESOLVED_TAG_WARNING_CODE)) {\n    return null;\n  }\n\n  const contents = document.contents;\n  const rootToken = contents?.srcToken;\n  // An anchor is a second name for a node, so a splice that moves or drops one of the two silently rewrites the other.\n  // Nothing here is worth that risk for a construct Obsidian's own property editor cannot produce.\n  if (!contents || rootToken?.type !== 'block-map' || checkHasAnchorOrAlias(contents)) {\n    return null;\n  }\n\n  // A block-map root always projects to a plain object, so this is a cast rather than a check. Anything that made it\n  // untrue would still be caught downstream: the merge would write a mapping the safety net then refuses.\n  const oldFrontmatter = castTo<GenericObject>(document.toJS());\n\n  if (!didMergeMap(rootToken, oldFrontmatter, castTo<GenericObject>(newFrontmatter))) {\n    return null;\n  }\n\n  // Every token, not just the root collection's: a comment before or after the mapping belongs to the DOCUMENT, so\n  // `CST.stringify(contents.srcToken)` alone silently drops both.\n  const emittedBody = tokens.map((token) => CST.stringify(token)).join('');\n\n  // The replaced region has to end in exactly one newline, as Obsidian's front matter block always does, or the closing\n  // `---` moves off its own line. A block whose last key was dropped can emit none, so it is normalized, not trusted.\n  const splicedBody = `${emittedBody.replace(TRAILING_NEWLINE_REG_EXP, '')}\\n`;\n\n  return checkIsSemanticMatch(splicedBody, newFrontmatter) ? splicedBody : null;\n}\n\nfunction stringifyFlow(value: unknown): string {\n  return stringify(value, {\n    ...OBSIDIAN_STRINGIFY_OPTIONS,\n    collectionStyle: 'flow',\n    flowCollectionPadding: false\n  });\n}\n"],
  "mappings": "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",
  "names": ["oldIndex", "newIndex"]
}


package/dist/lib/cjs/frontmatter-formatting.d.cts

@@ -0,0 +1,44 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * Rewrites a note's YAML front matter by splicing its concrete syntax tree, so every region a change does not reach
+ * keeps the exact bytes its author wrote — comments and the whitespace inside them, quoting style, blank lines,
+ * indentation width, flow versus block collections, and folded and literal scalars.
+ *
+ * Obsidian's own `processFrontMatter()` parses the block to a plain object and re-stringifies the whole of it, so a
+ * callback that changes one key rewrites every other. Re-emitting the parsed document instead of the raw text does not
+ * fix that: five of the losses survive every emit option the `yaml` package offers. Splicing the CST does fix it,
+ * because an untouched token is never re-emitted at all — {@link https://github.com/eemeli/yaml | the library} keeps
+ * each token's original source text and {@link https://eemeli.org/yaml/#cst-parser | `CST.stringify`} concatenates it.
+ *
+ * This module is DELIBERATELY not on the default path. It needs the `yaml` package's CST API, which Obsidian does not
+ * hand to plugins through its module map — that map is `obsidian`, `@codemirror/*` and `@lezer/*` and nothing else —
+ * so the package cannot be marked external and lands in the consuming plugin's `main.js`, about 100 KB of it. A plugin
+ * opts in by calling {@link enableFrontmatterFormattingPreservation} once, and only it pays.
+ */
+/**
+ * Registers this module's engine as the front matter formatting preserver for every write this library performs.
+ *
+ * Call it once, from a plugin's `onloadImpl()`. It takes effect for `processFrontmatter()`, `applyFileChanges()` and
+ * every other path that reaches `setFrontmatter()`, including the ones the calling plugin does not invoke itself.
+ *
+ * There is one preserver per realm, so two plugins that both call this simply agree.
+ */
+export declare function enableFrontmatterFormattingPreservation(): void;
+/**
+ * Rewrites the front matter of a note, keeping the original bytes of everything the change does not reach.
+ *
+ * It is the engine {@link enableFrontmatterFormattingPreservation} registers, and can be called directly as well.
+ *
+ * `null` means "this one is not mine": the block does not exist, the new front matter is empty (both are the
+ * parse-and-stringify path's business, unchanged), or the splice could not be proved faithful. The proof is not
+ * hand-waved — the spliced block is re-parsed and compared against the value the parse-and-stringify path would have
+ * produced for the same input, and any difference returns `null`. That is what makes this strictly better than that
+ * path or identical to it, and never worse.
+ *
+ * @param content - The note to rewrite the front matter of.
+ * @param newFrontmatter - The front matter to write.
+ * @returns The new note, or `null` when the caller should parse the block and write the whole of it out again instead.
+ */
+export declare function preserveFrontmatterFormatting(content: string, newFrontmatter: object): null | string;