@mnaoumov/obsidian-lib 10.6.0 → 10.8.0

package/dist/lib/esm/command-handlers/open-git-hub-command-handler.d.mts

@@ -0,0 +1,43 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Shared browser-opening behavior for GitHub commands.
+ */
+import type { Promisable } from 'type-fest';
+import type { CommandHandlerConstructorParams } from './command-handler.mjs';
+import { GlobalCommandHandler } from './global-command-handler.mjs';
+/**
+ * Constructor parameters for {@link OpenGitHubCommandHandler}.
+ */
+export interface OpenGitHubCommandHandlerConstructorParams extends CommandHandlerConstructorParams {
+    /**
+     * The plugin's repository, as `owner/name`.
+     */
+    readonly gitHubRepo: string;
+}
+/**
+ * Base class for commands that open a page in the plugin's GitHub repository.
+ */
+export declare abstract class OpenGitHubCommandHandler extends GlobalCommandHandler {
+    /**
+     * The plugin's repository, as `owner/name`.
+     */
+    protected readonly gitHubRepo: string;
+    /**
+     * Constructs a new instance.
+     *
+     * @param params - Constructor parameters.
+     */
+    constructor(params: OpenGitHubCommandHandlerConstructorParams);
+    /**
+     * Opens the page in the browser when the command is available.
+     */
+    execute(): Promise<void>;
+    /**
+     * Builds the destination URL.
+     *
+     * @returns The link.
+     */
+    protected abstract getUrl(): Promisable<string>;
+}

package/dist/lib/esm/command-handlers/open-git-hub-command-handler.mjs

@@ -0,0 +1,33 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { GlobalCommandHandler } from "./global-command-handler.mjs";
+class OpenGitHubCommandHandler extends GlobalCommandHandler {
+  /**
+   * The plugin's repository, as `owner/name`.
+   */
+  gitHubRepo;
+  /**
+   * Constructs a new instance.
+   *
+   * @param params - Constructor parameters.
+   */
+  constructor(params) {
+    super(params);
+    this.gitHubRepo = params.gitHubRepo;
+  }
+  /**
+   * Opens the page in the browser when the command is available.
+   */
+  async execute() {
+    if (this.canExecute()) {
+      window.open(await this.getUrl(), "_blank");
+    }
+  }
+}
+export {
+  OpenGitHubCommandHandler
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/components/index.d.mts

@@ -32,5 +32,6 @@ export * as 'rename-delete-handler-component' from './rename-delete-handler-comp
 export * as 'rmdir-guard-component' from './rmdir-guard-component.mjs';
 export * as 'settings-facet-component' from './settings-facet-component.mjs';
 export * as 'settings-migration-component' from './settings-migration-component.mjs';
+export * as 'style-sheet-component' from './style-sheet-component.mjs';
 export * as 'syntax-highlighting-component' from './syntax-highlighting-component.mjs';
 export * as 'templates-language-component' from './templates-language-component.mjs';

package/dist/lib/esm/components/index.mjs

@@ -36,6 +36,7 @@ import * as rename_delete_handler_component from "./rename-delete-handler-compon
 import * as rmdir_guard_component from "./rmdir-guard-component.mjs";
 import * as settings_facet_component from "./settings-facet-component.mjs";
 import * as settings_migration_component from "./settings-migration-component.mjs";
+import * as style_sheet_component from "./style-sheet-component.mjs";
 import * as syntax_highlighting_component from "./syntax-highlighting-component.mjs";
 import * as templates_language_component from "./templates-language-component.mjs";
 export {
@@ -72,7 +73,8 @@ export {
   rmdir_guard_component as "rmdir-guard-component",
   settings_facet_component as "settings-facet-component",
   settings_migration_component as "settings-migration-component",
+  style_sheet_component as "style-sheet-component",
   syntax_highlighting_component as "syntax-highlighting-component",
   templates_language_component as "templates-language-component"
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/components/style-sheet-component.d.mts

@@ -0,0 +1,79 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Attaches a plugin stylesheet to the main window and every popout window, including popouts opened later, and
+ * removes it on unload.
+ *
+ * The stylesheet is a constructed `CSSStyleSheet` adopted through `document.adoptedStyleSheets`, so the plugin
+ * creates no `<style>` element (which the community review flags) and adds no CSS snippet to the user's list.
+ * A constructed sheet can be adopted only by a document of the realm that constructed it, so each window gets its
+ * own sheet, built with that window's `CSSStyleSheet` constructor. Constructable stylesheets need Electron 28 or
+ * iOS 16.4, both below the oldest runtime Obsidian supports.
+ */
+import type { App, Component } from 'obsidian';
+import { ComponentEx } from './component-ex.mjs';
+/**
+ * Parameters for {@link registerStyle}.
+ */
+export interface RegisterStyleParams extends StyleSheetComponentConstructorParams {
+    /**
+     * The component that owns the stylesheet: the stylesheet is removed when it unloads.
+     */
+    readonly component: Component;
+}
+/**
+ * Parameters for the {@link StyleSheetComponent} constructor.
+ */
+export interface StyleSheetComponentConstructorParams {
+    /**
+     * The Obsidian app instance.
+     */
+    readonly app: App;
+    /**
+     * The CSS to attach.
+     */
+    readonly css: string;
+}
+/**
+ * Attaches a stylesheet to the main window and every popout window while loaded.
+ */
+export declare class StyleSheetComponent extends ComponentEx {
+    /**
+     * The CSS currently attached.
+     *
+     * @returns The CSS.
+     */
+    get css(): string;
+    /**
+     * The Obsidian app instance.
+     */
+    protected readonly app: App;
+    private _css;
+    private readonly styleSheetsByWindow;
+    /**
+     * Creates a new instance of the `StyleSheetComponent` class.
+     *
+     * @param params - The {@link StyleSheetComponentConstructorParams}.
+     */
+    constructor(params: StyleSheetComponentConstructorParams);
+    /**
+     * Attaches the stylesheet to every window, now and as popouts open.
+     */
+    onload(): void;
+    /**
+     * Replaces the attached CSS in every window.
+     *
+     * @param css - The new CSS.
+     */
+    setCss(css: string): void;
+    private attach;
+}
+/**
+ * Attaches a stylesheet to the main window and every popout window, including popouts opened later, until the
+ * owning component unloads.
+ *
+ * @param params - The {@link RegisterStyleParams}.
+ * @returns The {@link StyleSheetComponent}, whose {@link StyleSheetComponent.setCss} replaces the CSS.
+ */
+export declare function registerStyle(params: RegisterStyleParams): StyleSheetComponent;

package/dist/lib/esm/components/style-sheet-component.mjs

@@ -0,0 +1,109 @@
+/*
+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 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;
+}
+
+ensureBrowserProcess();
+})();
+
+import { castTo } from "@mnaoumov/typescript-lib/object-utils";
+import { AllWindowsEventComponent } from "./all-windows-event-component.mjs";
+import { ComponentEx } from "./component-ex.mjs";
+class StyleSheetComponent extends ComponentEx {
+  /**
+   * The CSS currently attached.
+   *
+   * @returns The CSS.
+   */
+  get css() {
+    return this._css;
+  }
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  _css;
+  styleSheetsByWindow = /* @__PURE__ */ new Map();
+  /**
+   * Creates a new instance of the `StyleSheetComponent` class.
+   *
+   * @param params - The {@link StyleSheetComponentConstructorParams}.
+   */
+  constructor(params) {
+    super();
+    this.app = params.app;
+    this._css = params.css;
+  }
+  /**
+   * Attaches the stylesheet to every window, now and as popouts open.
+   */
+  onload() {
+    super.onload();
+    this.register(() => {
+      for (const [win, styleSheet] of this.styleSheetsByWindow) {
+        win.document.adoptedStyleSheets = win.document.adoptedStyleSheets.filter((sheet) => sheet !== styleSheet);
+      }
+      this.styleSheetsByWindow.clear();
+    });
+    this.registerEvent(this.app.workspace.on("window-close", (_workspaceWindow, win) => {
+      this.styleSheetsByWindow.delete(win);
+    }));
+    const allWindowsEventComponent = this.addChild(new AllWindowsEventComponent(this.app));
+    allWindowsEventComponent.registerAllWindowsHandler((win) => {
+      this.attach(win);
+    });
+  }
+  /**
+   * Replaces the attached CSS in every window.
+   *
+   * @param css - The new CSS.
+   */
+  setCss(css) {
+    this._css = css;
+    for (const styleSheet of this.styleSheetsByWindow.values()) {
+      styleSheet.replaceSync(css);
+    }
+  }
+  attach(win) {
+    if (this.styleSheetsByWindow.has(win)) {
+      return;
+    }
+    const styleSheet = new (castTo(win)).CSSStyleSheet();
+    styleSheet.replaceSync(this._css);
+    win.document.adoptedStyleSheets = [...win.document.adoptedStyleSheets, styleSheet];
+    this.styleSheetsByWindow.set(win, styleSheet);
+  }
+}
+function registerStyle(params) {
+  const { app, component, css } = params;
+  return component.addChild(new StyleSheetComponent({ app, css }));
+}
+export {
+  StyleSheetComponent,
+  registerStyle
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/data-stores/data-store-locations.d.mts

@@ -0,0 +1,60 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ * Append-only, anchored discovery of history-preserving transport transitions.
+ */
+import type { DataStoreTransportConstructorParams } from './data-store-transport.mjs';
+import { DataStoreTransport } from './data-store-transport.mjs';
+/**
+A transport destination. Keep the original open parameters as the discovery anchor.
+ */
+export interface DataStoreLocation {
+    /**
+    Vault-relative parent of the plugin/store subtree.
+     */
+    readonly folder: string;
+    /**
+     * New document encoding.
+     *
+     * @default `'markdown'`
+     */
+    readonly format?: 'json' | 'markdown';
+}
+/**
+Anchored relocation coordinator; source histories are never removed.
+ */
+export declare class DataStoreLocations {
+    private readonly params;
+    /**
+    All readers, oldest first; the last transport is the active writer.
+     *
+     * @returns All retained reader transports in transition order.
+     */
+    get transports(): DataStoreTransport[];
+    private readonly anchor;
+    private readonly initial;
+    private locations;
+    /**
+     * Creates a coordinator without adapter calls.
+     *
+     * @param params - Permanent discovery anchor and store identity.
+     */
+    constructor(params: DataStoreTransportConstructorParams);
+    /**
+     * Discovers and finishes pending copies before allowing a writer to switch destinations.
+     * Conflicting branches and reordered incomplete chains fail closed until delivery is complete.
+     *
+     * @returns A promise that resolves after discovery and verification.
+     */
+    refresh(): Promise<void>;
+    /**
+     * Announces a transition durably at the anchor, then copies and verifies before activation.
+     * Retrying the same destination finishes an interrupted copy.
+     *
+     * @param location - Requested destination.
+     * @returns A promise that resolves when the new writer is ready.
+     */
+    relocate(location: DataStoreLocation): Promise<void>;
+    private createTransport;
+    private validateLocation;
+}

package/dist/lib/esm/data-stores/data-store-locations.mjs

@@ -0,0 +1,160 @@
+/*
+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 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;
+}
+
+ensureBrowserProcess();
+})();
+
+import { ensureNonNullable } from "@mnaoumov/typescript-lib/type-guards";
+import { DataStoreTransport } from "./data-store-transport.mjs";
+const MAX_LOCATIONS = 32;
+class DataStoreLocations {
+  /**
+   * Creates a coordinator without adapter calls.
+   *
+   * @param params - Permanent discovery anchor and store identity.
+   */
+  constructor(params) {
+    this.params = params;
+    this.anchor = new DataStoreTransport(params);
+    this.initial = { folder: params.folder ?? "Plugin data", format: params.format ?? "markdown" };
+    this.locations = [this.initial];
+  }
+  params;
+  /**
+  All readers, oldest first; the last transport is the active writer.
+   *
+   * @returns All retained reader transports in transition order.
+   */
+  get transports() {
+    return this.locations.map((location) => this.createTransport(location));
+  }
+  anchor;
+  initial;
+  locations;
+  /**
+   * Discovers and finishes pending copies before allowing a writer to switch destinations.
+   * Conflicting branches and reordered incomplete chains fail closed until delivery is complete.
+   *
+   * @returns A promise that resolves after discovery and verification.
+   */
+  async refresh() {
+    const transitions = [];
+    for (const path of await this.anchor.list()) {
+      if (!path.startsWith(`${this.anchor.root}/locations-v1/`) || !path.endsWith(".json")) {
+        continue;
+      }
+      const value = await this.anchor.read(path);
+      if (!isTransition(value)) {
+        throw new Error("Incomplete or invalid data-store transition");
+      }
+      this.validateLocation(value.from);
+      this.validateLocation(value.to);
+      transitions.push(value);
+    }
+    const locations = [this.initial];
+    let currentIdentity = identity(this.initial);
+    while (transitions.length > 0) {
+      const sourceIdentity = currentIdentity;
+      const next = transitions.filter((transition) => identity(transition.from) === sourceIdentity);
+      const targets = new Set(next.map((transition) => identity(transition.to)));
+      if (targets.size !== 1) {
+        throw new Error("Conflicting or incomplete data-store relocation chain");
+      }
+      const target = ensureNonNullable(next[0]);
+      if (locations.some((location) => identity(location) === identity(target.to)) || locations.length >= MAX_LOCATIONS) {
+        throw new Error("Data-store relocation loop or location limit");
+      }
+      locations.push(target.to);
+      currentIdentity = identity(target.to);
+      for (const transition of next) {
+        transitions.splice(transitions.indexOf(transition), 1);
+      }
+    }
+    for (const location of locations) {
+      this.validateLocation(location, locations);
+    }
+    for (const location of locations.slice(1)) {
+      const target = this.createTransport(location);
+      for (const source of locations.slice(0, locations.indexOf(location))) {
+        const transport = this.createTransport(source);
+        if (transport.root !== target.root) {
+          await transport.copyHistoryTo(target);
+        }
+      }
+    }
+    this.locations = locations;
+  }
+  /**
+   * Announces a transition durably at the anchor, then copies and verifies before activation.
+   * Retrying the same destination finishes an interrupted copy.
+   *
+   * @param location - Requested destination.
+   * @returns A promise that resolves when the new writer is ready.
+   */
+  async relocate(location) {
+    this.validateLocation(location);
+    await this.refresh();
+    this.validateLocation(location);
+    const from = ensureNonNullable(this.locations.at(-1));
+    if (identity(from) === identity(location)) {
+      return;
+    }
+    if (this.locations.some((previous) => identity(previous) === identity(location)) || this.locations.length >= MAX_LOCATIONS) {
+      throw new Error("Data-store relocation loop or location limit");
+    }
+    const value = { format: 1, from, to: location };
+    await this.anchor.write(`${this.anchor.root}/locations-v1/${window.crypto.randomUUID()}.json`, value);
+    await this.refresh();
+  }
+  createTransport(location) {
+    return new DataStoreTransport({ ...this.params, folder: location.folder, format: location.format ?? "markdown" });
+  }
+  validateLocation(location, locations = this.locations) {
+    const transport = this.createTransport(location);
+    for (const previous of locations) {
+      const root = this.createTransport(previous).root;
+      if (transport.root !== root && (transport.root.startsWith(`${root}/`) || root.startsWith(`${transport.root}/`))) {
+        throw new Error("Overlapping data-store relocation roots");
+      }
+    }
+  }
+}
+function identity(location) {
+  return `${location.folder}:${location.format ?? "markdown"}`;
+}
+function isLocation(value) {
+  return typeof value === "object" && value !== null && "folder" in value && typeof value.folder === "string" && (!("format" in value) || value.format === "json" || value.format === "markdown");
+}
+function isTransition(value) {
+  return typeof value === "object" && value !== null && "format" in value && value.format === 1 && "from" in value && isLocation(value.from) && "to" in value && isLocation(value.to);
+}
+export {
+  DataStoreLocations
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/data-stores/data-store-locations.ts"],"sourcesContent":["/* eslint-disable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n/**\n * @file\n * Append-only, anchored discovery of history-preserving transport transitions.\n */\n\nimport { ensureNonNullable } from '@mnaoumov/typescript-lib/type-guards';\n\nimport type { DataStoreTransportConstructorParams } from './data-store-transport.ts';\n\nimport { DataStoreTransport } from './data-store-transport.ts';\n\nconst MAX_LOCATIONS = 32;\n\n/**\nA transport destination. Keep the original open parameters as the discovery anchor.\n */\nexport interface DataStoreLocation {\n  /**\n  Vault-relative parent of the plugin/store subtree.\n   */\n  readonly folder: string;\n  /**\n   * New document encoding.\n   *\n   * @default `'markdown'`\n   */\n  readonly format?: 'json' | 'markdown';\n}\n\ninterface Transition {\n  readonly format: 1;\n  readonly from: DataStoreLocation;\n  readonly to: DataStoreLocation;\n}\n\n/**\nAnchored relocation coordinator; source histories are never removed.\n */\nexport class DataStoreLocations {\n  /**\n  All readers, oldest first; the last transport is the active writer.\n   *\n   * @returns All retained reader transports in transition order.\n   */\n  public get transports(): DataStoreTransport[] {\n    return this.locations.map((location) => this.createTransport(location));\n  }\n\n  private readonly anchor: DataStoreTransport;\n  private readonly initial: DataStoreLocation;\n\n  private locations: DataStoreLocation[];\n\n  /**\n   * Creates a coordinator without adapter calls.\n   *\n   * @param params - Permanent discovery anchor and store identity.\n   */\n  public constructor(private readonly params: DataStoreTransportConstructorParams) {\n    this.anchor = new DataStoreTransport(params);\n    this.initial = { folder: params.folder ?? 'Plugin data', format: params.format ?? 'markdown' };\n    this.locations = [this.initial];\n  }\n\n  /**\n   * Discovers and finishes pending copies before allowing a writer to switch destinations.\n   * Conflicting branches and reordered incomplete chains fail closed until delivery is complete.\n   *\n   * @returns A promise that resolves after discovery and verification.\n   */\n  public async refresh(): Promise<void> {\n    const transitions: Transition[] = [];\n    for (const path of await this.anchor.list()) {\n      if (!path.startsWith(`${this.anchor.root}/locations-v1/`) || !path.endsWith('.json')) {\n        continue;\n      }\n      const value = await this.anchor.read(path);\n      if (!isTransition(value)) {\n        throw new Error('Incomplete or invalid data-store transition');\n      }\n      this.validateLocation(value.from);\n      this.validateLocation(value.to);\n      transitions.push(value);\n    }\n    const locations = [this.initial];\n    let currentIdentity = identity(this.initial);\n    while (transitions.length > 0) {\n      const sourceIdentity = currentIdentity;\n      const next = transitions.filter((transition) => identity(transition.from) === sourceIdentity);\n      const targets = new Set(next.map((transition) => identity(transition.to)));\n      if (targets.size !== 1) {\n        throw new Error('Conflicting or incomplete data-store relocation chain');\n      }\n      const target = ensureNonNullable(next[0]);\n      if (locations.some((location) => identity(location) === identity(target.to)) || locations.length >= MAX_LOCATIONS) {\n        throw new Error('Data-store relocation loop or location limit');\n      }\n      locations.push(target.to);\n      currentIdentity = identity(target.to);\n      for (const transition of next) {\n        transitions.splice(transitions.indexOf(transition), 1);\n      }\n    }\n    // Validate the entire chain before making any copies or activating a writer.\n    for (const location of locations) {\n      this.validateLocation(location, locations);\n    }\n    for (const location of locations.slice(1)) {\n      const target = this.createTransport(location);\n      for (const source of locations.slice(0, locations.indexOf(location))) {\n        const transport = this.createTransport(source);\n        if (transport.root !== target.root) {\n          await transport.copyHistoryTo(target);\n        }\n      }\n    }\n    this.locations = locations;\n  }\n\n  /**\n   * Announces a transition durably at the anchor, then copies and verifies before activation.\n   * Retrying the same destination finishes an interrupted copy.\n   *\n   * @param location - Requested destination.\n   * @returns A promise that resolves when the new writer is ready.\n   */\n  public async relocate(location: DataStoreLocation): Promise<void> {\n    this.validateLocation(location);\n    await this.refresh();\n    this.validateLocation(location);\n    const from = ensureNonNullable(this.locations.at(-1));\n    if (identity(from) === identity(location)) {\n      return;\n    }\n    if (this.locations.some((previous) => identity(previous) === identity(location)) || this.locations.length >= MAX_LOCATIONS) {\n      throw new Error('Data-store relocation loop or location limit');\n    }\n    const value: Transition = { format: 1, from, to: location };\n    await this.anchor.write(`${this.anchor.root}/locations-v1/${window.crypto.randomUUID()}.json`, value);\n    await this.refresh();\n  }\n\n  private createTransport(location: DataStoreLocation): DataStoreTransport {\n    return new DataStoreTransport({ ...this.params, folder: location.folder, format: location.format ?? 'markdown' });\n  }\n\n  private validateLocation(location: DataStoreLocation, locations: readonly DataStoreLocation[] = this.locations): void {\n    const transport = this.createTransport(location);\n    for (const previous of locations) {\n      const root = this.createTransport(previous).root;\n      if (transport.root !== root && (transport.root.startsWith(`${root}/`) || root.startsWith(`${transport.root}/`))) {\n        throw new Error('Overlapping data-store relocation roots');\n      }\n    }\n  }\n}\n\n/* eslint-enable n/no-unsupported-features/node-builtins -- These are Obsidian renderer Web APIs, not Node builtins. */\n\nfunction identity(location: DataStoreLocation): string {\n  return `${location.folder}:${location.format ?? 'markdown'}`;\n}\n\nfunction isLocation(value: unknown): value is DataStoreLocation {\n  return typeof value === 'object' && value !== null && 'folder' in value && typeof value.folder === 'string'\n    && (!('format' in value) || value.format === 'json' || value.format === 'markdown');\n}\n\nfunction isTransition(value: unknown): value is Transition {\n  return typeof value === 'object' && value !== null && 'format' in value && value.format === 1\n    && 'from' in value && isLocation(value.from) && 'to' in value && isLocation(value.to);\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/data-stores/data-store-seeds.d.mts

@@ -50,7 +50,7 @@ export interface DataStoreSeedsConstructorParams {
      */
     readonly share: boolean;
     /**
-     * Store-scoped, bounded Markdown transport. Include the consumer schema version in its store id.
+     * Store-scoped, bounded transport. Include the consumer schema version in its store id.
      */
     readonly transport: DataStoreTransport;
 }