obsidian-dev-utils 19.1.1 → 19.1.2-beta.3

package/dist/lib/esm/obsidian/@types/Dataview/api/inline-api.d.mts

@@ -0,0 +1,186 @@
+/** Fancy wrappers for the JavaScript API, used both by external plugins AND by the dataview javascript view. */
+import type {
+  DateTime,
+  Duration
+} from 'luxon';
+import * as Luxon from 'luxon';
+import type {
+  App,
+  Component
+} from 'obsidian';
+import type {
+  DataviewApi,
+  DataviewIOApi,
+  QueryApiSettings,
+  QueryResult
+} from '../api/plugin-api.d.d.mts';
+import type { Result } from '../api/result.d.d.mts';
+import type { FullIndex } from '../data-index/index.d.d.mts';
+import type { SListItem } from '../data-model/serialized/markdown.d.d.mts';
+import type {
+  DataObject,
+  Grouping,
+  Link,
+  Literal,
+  Values,
+  Widgets
+} from '../data-model/value.d.d.mts';
+import type { Context } from '../expression/context.d.d.mts';
+import type { BoundFunctionImpl } from '../expression/functions.d.d.mts';
+import type {
+  DataviewSettings,
+  ExportSettings
+} from '../settings.d.d.mts';
+import type { DataArray } from './data-array.d.d.mts';
+/** Asynchronous API calls related to file / system IO. */
+export declare class DataviewInlineIOApi {
+  api: DataviewIOApi;
+  currentFile: string;
+  constructor(api: DataviewIOApi, currentFile: string);
+  /** Load the contents of a CSV asynchronously, returning a data array of rows (or undefined if it does not exist). */
+  csv(path: string, originFile?: string): Promise<DataArray<DataObject> | undefined>;
+  /** Asynchronously load the contents of any link or path in an Obsidian vault. */
+  load(path: Link | string, originFile?: string): Promise<string | undefined>;
+  /** Normalize a link or path relative to an optional origin file. Returns a textual fully-qualified-path. */
+  normalize(path: Link | string, originFile?: string): string;
+}
+export declare class DataviewInlineApi {
+  /**
+   * The raw dataview indices, which track file <-> metadata relations. Use these if the intuitive API does not support
+   * your use case.
+   */
+  index: FullIndex;
+  /** The component that handles the lifetime of this view. Use it if you are adding custom event handlers/components. */
+  component: Component;
+  /** The path to the current file this script is running in. */
+  currentFilePath: string;
+  /**
+   * The container which holds the output of this view. You can directly append fields to this, if you wish, though
+   * the rendering API is likely to be easier for straight-forward purposes.
+   */
+  container: HTMLElement;
+  /** Directly access the Obsidian app object, such as for reaching out to other plugins. */
+  app: App;
+  /** The general plugin API which much of this inline API delegates to. */
+  api: DataviewApi;
+  /** Settings which determine defaults, incl. many rendering options. */
+  settings: DataviewSettings;
+  /** Evaluation context which expressions can be evaluated in. */
+  evaluationContext: Context;
+  /** Value utilities which allow for type-checking and comparisons. */
+  value: typeof Values;
+  /** Widget utility functions for creating built-in widgets. */
+  widget: typeof Widgets;
+  /** IO utilities which are largely asynchronous. */
+  io: DataviewInlineIOApi;
+  /** Re-exporting of luxon for people who can't easily require it. Sorry! */
+  luxon: typeof Luxon;
+  /** Dataview functions which can be called from DataviewJS. */
+  func: Record<string, BoundFunctionImpl>;
+  constructor(api: DataviewApi, component: Component, container: HTMLElement, currentFilePath: string);
+  /** Return an array of paths (as strings) corresponding to pages which match the query. */
+  pagePaths(query?: string): DataArray<string>;
+  /** Map a page path to the actual data contained within that page. */
+  page(path: string | Link): DataObject | undefined;
+  /** Return an array of page objects corresponding to pages which match the query. */
+  pages(query?: string): DataArray<any>;
+  /** Return the information about the current page. */
+  current(): Record<string, any> | undefined;
+  /** Execute a Dataview query, returning the results in programmatic form. */
+  query(source: string, originFile?: string, settings?: QueryApiSettings): Promise<Result<QueryResult, string>>;
+  /** Error-throwing version of {@link query}. */
+  tryQuery(source: string, originFile?: string, settings?: QueryApiSettings): Promise<QueryResult>;
+  /** Execute a Dataview query, returning the results in Markdown. */
+  queryMarkdown(source: string, originFile?: string, settings?: QueryApiSettings): Promise<Result<string, string>>;
+  /** Error-throwing version of {@link queryMarkdown}. */
+  tryQueryMarkdown(source: string, originFile?: string, settings?: QueryApiSettings): Promise<string>;
+  /**
+   * Evaluate a dataview expression (like '2 + 2' or 'link("hello")'), returning the evaluated result.
+   * This takes an optional second argument which provides definitions for variables, such as:
+   *
+   * ```
+   * dv.evaluate("x + 6", { x: 2 }) = 8
+   * dv.evaluate('link(target)', { target: "Okay" }) = [[Okay]]
+   * ```
+   *
+   * Note that `this` is implicitly available and refers to the current file.
+   *
+   * This method returns a Result type instead of throwing an error; you can check the result of the
+   * execution via `result.successful` and obtain `result.value` or `result.error` accordingly. If
+   * you'd rather this method throw on an error, use `dv.tryEvaluate`.
+   */
+  evaluate(expression: string, context?: DataObject): Result<Literal, string>;
+  /** Error-throwing version of `dv.evaluate`. */
+  tryEvaluate(expression: string, context?: DataObject): Literal;
+  /** Execute a Dataview query and embed it into the current view. */
+  execute(source: string): Promise<void>;
+  /** Execute a DataviewJS query and embed it into the current view. */
+  executeJs(code: string): Promise<void>;
+  /**
+   * Convert an input element or array into a Dataview data-array. If the input is already a data array,
+   * it is returned unchanged.
+   */
+  array(raw: any): DataArray<any>;
+  /** Return true if the given value is a javascript array OR a dataview data array. */
+  isArray(raw: any): raw is DataArray<any> | Array<any>;
+  /** Return true if the given value is a dataview data array; this returns FALSE for plain JS arrays. */
+  isDataArray(raw: unknown): raw is DataArray<any>;
+  /** Create a dataview file link to the given path. */
+  fileLink(path: string, embed?: boolean, display?: string): Link;
+  /** Create a dataview section link to the given path. */
+  sectionLink(path: string, section: string, embed?: boolean, display?: string): Link;
+  /** Create a dataview block link to the given path. */
+  blockLink(path: string, blockId: string, embed?: boolean, display?: string): Link;
+  /** Attempt to extract a date from a string, link or date. */
+  date(pathlike: string | Link | DateTime): DateTime | null;
+  /** Attempt to extract a duration from a string or duration. */
+  duration(dur: string | Duration): Duration | null;
+  /** Parse a raw textual value into a complex Dataview type, if possible. */
+  parse(value: string): Literal;
+  /** Convert a basic JS type into a Dataview type by parsing dates, links, durations, and so on. */
+  literal(value: any): Literal;
+  /** Deep clone the given literal, returning a new literal which is independent of the original. */
+  clone(value: Literal): Literal;
+  /**
+   * Compare two arbitrary JavaScript values using Dataview's default comparison rules. Returns a negative value if
+   * a < b, 0 if a = b, and a positive value if a > b.
+   */
+  compare(a: any, b: any): number;
+  /** Return true if the two given JavaScript values are equal using Dataview's default comparison rules. */
+  equal(a: any, b: any): boolean;
+  /** Render an HTML element, containing arbitrary text. */
+  el<K extends keyof HTMLElementTagNameMap>(el: K, text: any, { container, ...options }?: DomElementInfo & {
+    container?: HTMLElement;
+  }): HTMLElementTagNameMap[K];
+  /** Render an HTML header; the level can be anything from 1 - 6. */
+  header(level: number, text: any, options?: DomElementInfo): HTMLHeadingElement;
+  /** Render an HTML paragraph, containing arbitrary text. */
+  paragraph(text: any, options?: DomElementInfo): HTMLParagraphElement;
+  /** Render an inline span, containing arbitrary text. */
+  span(text: any, options?: DomElementInfo): HTMLSpanElement;
+  /**
+   * Render HTML from the output of a template "view" saved as a file in the vault.
+   * Takes a filename and arbitrary input data.
+   */
+  view(viewName: string, input: any): Promise<void>;
+  /** Render a dataview list of the given values. */
+  list(values?: any[] | DataArray<any>): Promise<void>;
+  /** Render a dataview table with the given headers, and the 2D array of values. */
+  table(headers: string[], values?: any[][] | DataArray<any>): Promise<void>;
+  /** Render a dataview task view with the given tasks. */
+  taskList(tasks: Grouping<SListItem>, groupByFile?: boolean): Promise<void>;
+  /** Render a table directly to markdown, returning the markdown. */
+  markdownTable(headers: string[], values?: any[][] | DataArray<any>, settings?: Partial<ExportSettings>): string;
+  /** Render a list directly to markdown, returning the markdown. */
+  markdownList(values?: any[] | DataArray<any> | undefined, settings?: Partial<ExportSettings>): string;
+  /** Render at ask list directly to markdown, returning the markdown. */
+  markdownTaskList(values: Grouping<SListItem>, settings?: Partial<ExportSettings>): string;
+}
+/**
+ * Evaluate a script where 'this' for the script is set to the given context. Allows you to define global variables.
+ */
+export declare function evalInContext(script: string, context: any): any;
+/**
+ * Evaluate a script possibly asynchronously, if the script contains `async/await` blocks.
+ */
+export declare function asyncEvalInContext(script: string, context: any): Promise<any>;

package/dist/lib/esm/obsidian/@types/Dataview/api/plugin-api.d.mts

@@ -0,0 +1,209 @@
+/** The general, externally accessible plugin API (available at `app.plugins.plugins.dataview.api` or as global `DataviewAPI`). */
+import type { CompareOperator } from 'compare-versions';
+import type {
+  DateTime,
+  Duration
+} from 'luxon';
+import * as Luxon from 'luxon';
+import type {
+  App,
+  Component,
+  MarkdownPostProcessorContext
+} from 'obsidian';
+import type { Result } from '../api/result.d.d.mts';
+import type { FullIndex } from '../data-index/index.d.d.mts';
+import type { SListItem } from '../data-model/serialized/markdown.d.d.mts';
+import type {
+  DataObject,
+  Grouping,
+  Link,
+  Literal,
+  Values,
+  Widgets
+} from '../data-model/value.d.d.mts';
+import type { Context } from '../expression/context.d.d.mts';
+import type { BoundFunctionImpl } from '../expression/functions.d.d.mts';
+import type { IdentifierMeaning } from '../query/engine.d.d.mts';
+import type { Query } from '../query/query.d.d.mts';
+import type {
+  DataviewSettings,
+  ExportSettings
+} from '../settings.d.d.mts';
+import type { DataArray } from './data-array.d.d.mts';
+/** Asynchronous API calls related to file / system IO. */
+export declare class DataviewIOApi {
+  api: DataviewApi;
+  constructor(api: DataviewApi);
+  /** Load the contents of a CSV asynchronously, returning a data array of rows (or undefined if it does not exist). */
+  csv(path: Link | string, originFile?: string): Promise<DataArray<DataObject> | undefined>;
+  /** Asynchronously load the contents of any link or path in an Obsidian vault. */
+  load(path: Link | string, originFile?: string): Promise<string | undefined>;
+  /** Normalize a link or path relative to an optional origin file. Returns a textual fully-qualified-path. */
+  normalize(path: Link | string, originFile?: string): string;
+}
+/** Global API for accessing the Dataview API, executing dataview queries, and  */
+export declare class DataviewApi {
+  app: App;
+  index: FullIndex;
+  settings: DataviewSettings;
+  private verNum;
+  /** Evaluation context which expressions can be evaluated in. */
+  evaluationContext: Context;
+  /** IO API which supports asynchronous loading of data directly. */
+  io: DataviewIOApi;
+  /** Dataview functions which can be called from DataviewJS. */
+  func: Record<string, BoundFunctionImpl>;
+  /** Value utility functions for comparisons and type-checking. */
+  value: typeof Values;
+  /** Widget utility functions for creating built-in widgets. */
+  widget: typeof Widgets;
+  /** Re-exporting of luxon for people who can't easily require it. Sorry! */
+  luxon: typeof Luxon;
+  constructor(app: App, index: FullIndex, settings: DataviewSettings, verNum: string);
+  /** Utilities to check the current Dataview version and compare it to SemVer version ranges. */
+  version: {
+    current: string;
+    compare: (op: CompareOperator, ver: string) => boolean;
+    satisfies: (range: string) => boolean;
+  };
+  /** Return an array of paths (as strings) corresponding to pages which match the query. */
+  pagePaths(query?: string, originFile?: string): DataArray<string>;
+  /** Map a page path to the actual data contained within that page. */
+  page(path: string | Link, originFile?: string): Record<string, Literal> | undefined;
+  /** Return an array of page objects corresponding to pages which match the source query. */
+  pages(query?: string, originFile?: string): DataArray<Record<string, Literal>>;
+  /** Remaps important metadata to add data arrays.  */
+  private _addDataArrays;
+  /**
+   * Convert an input element or array into a Dataview data-array. If the input is already a data array,
+   * it is returned unchanged.
+   */
+  array(raw: unknown): DataArray<any>;
+  /** Return true if the given value is a javascript array OR a dataview data array. */
+  isArray(raw: unknown): raw is DataArray<any> | Array<any>;
+  /** Return true if the given value is a dataview data array; this returns FALSE for plain JS arrays. */
+  isDataArray(raw: unknown): raw is DataArray<any>;
+  /** Create a dataview file link to the given path. */
+  fileLink(path: string, embed?: boolean, display?: string): Link;
+  /** Create a dataview section link to the given path. */
+  sectionLink(path: string, section: string, embed?: boolean, display?: string): Link;
+  /** Create a dataview block link to the given path. */
+  blockLink(path: string, blockId: string, embed?: boolean, display?: string): Link;
+  /** Attempt to extract a date from a string, link or date. */
+  date(pathlike: string | Link | DateTime): DateTime | null;
+  /** Attempt to extract a duration from a string or duration. */
+  duration(str: string | Duration): Duration | null;
+  /** Parse a raw textual value into a complex Dataview type, if possible. */
+  parse(value: string): Literal;
+  /** Convert a basic JS type into a Dataview type by parsing dates, links, durations, and so on. */
+  literal(value: any): Literal;
+  /** Deep clone the given literal, returning a new literal which is independent of the original. */
+  clone(value: Literal): Literal;
+  /**
+   * Compare two arbitrary JavaScript values using Dataview's default comparison rules. Returns a negative value if
+   * a < b, 0 if a = b, and a positive value if a > b.
+   */
+  compare(a: any, b: any): number;
+  /** Return true if the two given JavaScript values are equal using Dataview's default comparison rules. */
+  equal(a: any, b: any): boolean;
+  /**
+   * Execute an arbitrary Dataview query, returning a query result which:
+   *
+   * 1. Indicates the type of query,
+   * 2. Includes the raw AST of the parsed query.
+   * 3. Includes the output in the form relevant to that query type.
+   *
+   * List queries will return a list of objects ({ id, value }); table queries return a header array
+   * and a 2D array of values; and task arrays return a Grouping<Task> type which allows for recursive
+   * task nesting.
+   */
+  query(source: string | Query, originFile?: string, settings?: QueryApiSettings): Promise<Result<QueryResult, string>>;
+  /** Error-throwing version of {@link query}. */
+  tryQuery(source: string, originFile?: string, settings?: QueryApiSettings): Promise<QueryResult>;
+  /** Execute an arbitrary dataview query, returning the results in well-formatted markdown. */
+  queryMarkdown(source: string | Query, originFile?: string, settings?: Partial<QueryApiSettings & ExportSettings>): Promise<Result<string, string>>;
+  /** Error-throwing version of {@link queryMarkdown}. */
+  tryQueryMarkdown(source: string | Query, originFile?: string, settings?: Partial<QueryApiSettings & ExportSettings>): Promise<string>;
+  /**
+   * Evaluate a dataview expression (like '2 + 2' or 'link("hello")'), returning the evaluated result.
+   * This takes an optional second argument which provides definitions for variables, such as:
+   *
+   * ```
+   * dv.evaluate("x + 6", { x: 2 }) = 8
+   * dv.evaluate('link(target)', { target: "Okay" }) = [[Okay]]
+   * ```
+   *
+   * This method returns a Result type instead of throwing an error; you can check the result of the
+   * execution via `result.successful` and obtain `result.value` or `result.error` accordingly. If
+   * you'd rather this method throw on an error, use `dv.tryEvaluate`.
+   */
+  evaluate(expression: string, context?: DataObject, originFile?: string): Result<Literal, string>;
+  /** Error-throwing version of `dv.evaluate`. */
+  tryEvaluate(expression: string, context?: DataObject, originFile?: string): Literal;
+  /** Evaluate an expression in the context of the given file. */
+  evaluateInline(expression: string, origin: string): Result<Literal, string>;
+  /**
+   * Execute the given query, rendering results into the given container using the components lifecycle.
+   * Your component should be a *real* component which calls onload() on it's child components at some point,
+   * or a MarkdownPostProcessorContext!
+   *
+   * Note that views made in this way are live updating and will automatically clean themselves up when
+   * the component is unloaded or the container is removed.
+   */
+  execute(source: string, container: HTMLElement, component: Component | MarkdownPostProcessorContext, filePath: string): Promise<void>;
+  /**
+   * Execute the given DataviewJS query, rendering results into the given container using the components lifecycle.
+   * See {@link execute} for general rendering semantics.
+   */
+  executeJs(code: string, container: HTMLElement, component: Component | MarkdownPostProcessorContext, filePath: string): Promise<void>;
+  /** Render a dataview list of the given values. */
+  list(values: any[] | DataArray<any> | undefined, container: HTMLElement, component: Component, filePath: string): Promise<void>;
+  /** Render a dataview table with the given headers, and the 2D array of values. */
+  table(headers: string[], values: any[][] | DataArray<any> | undefined, container: HTMLElement, component: Component, filePath: string): Promise<void>;
+  /** Render a dataview task view with the given tasks. */
+  taskList(tasks: Grouping<SListItem>, groupByFile: boolean | undefined, container: HTMLElement, component: Component, filePath?: string): Promise<void>;
+  /** Render an arbitrary value into a container. */
+  renderValue(value: any, container: HTMLElement, component: Component, filePath: string, inline?: boolean): Promise<void>;
+  /** Render data to a markdown table. */
+  markdownTable(headers: string[] | undefined, values: any[][] | DataArray<any> | undefined, settings?: Partial<ExportSettings>): string;
+  /** Render data to a markdown list. */
+  markdownList(values: any[] | DataArray<any> | undefined, settings?: Partial<ExportSettings>): string;
+  /** Render tasks or list items to a markdown task list. */
+  markdownTaskList(values: Grouping<SListItem>, settings?: Partial<ExportSettings>): string;
+}
+/** The result of executing a table query. */
+export type TableResult = {
+  type: 'table';
+  headers: string[];
+  values: Literal[][];
+  idMeaning: IdentifierMeaning;
+};
+/** The result of executing a list query. */
+export type ListResult = {
+  type: 'list';
+  values: Literal[];
+  primaryMeaning: IdentifierMeaning;
+};
+/** The result of executing a task query. */
+export type TaskResult = {
+  type: 'task';
+  values: Grouping<SListItem>;
+};
+/** The result of executing a calendar query. */
+export type CalendarResult = {
+  type: 'calendar';
+  values: {
+    date: DateTime;
+    link: Link;
+    value?: Literal[];
+  }[];
+};
+/** The result of executing a query of some sort. */
+export type QueryResult = TableResult | ListResult | TaskResult | CalendarResult;
+/** Settings when querying the dataview API. */
+export type QueryApiSettings = {
+  /** If present, then this forces queries to include/exclude the implicit id field (such as with `WITHOUT ID`). */
+  forceId?: boolean;
+};
+/** Determines if source-path has a `?no-dataview` annotation that disables dataview. */
+export declare function isDataviewDisabled(sourcePath: string): boolean;

package/dist/lib/esm/obsidian/@types/Dataview/api/result.d.mts

@@ -0,0 +1,38 @@
+/** Functional return type for error handling. */
+export declare class Success<T, E> {
+  value: T;
+  successful: true;
+  constructor(value: T);
+  map<U>(f: (a: T) => U): Result<U, E>;
+  flatMap<U>(f: (a: T) => Result<U, E>): Result<U, E>;
+  mapErr<U>(f: (e: E) => U): Result<T, U>;
+  bimap<T2, E2>(succ: (a: T) => T2, _fail: (b: E) => E2): Result<T2, E2>;
+  orElse(_value: T): T;
+  cast<U>(): Result<U, E>;
+  orElseThrow(_message?: (e: E) => string): T;
+}
+/** Functional return type for error handling. */
+export declare class Failure<T, E> {
+  error: E;
+  successful: false;
+  constructor(error: E);
+  map<U>(_f: (a: T) => U): Result<U, E>;
+  flatMap<U>(_f: (a: T) => Result<U, E>): Result<U, E>;
+  mapErr<U>(f: (e: E) => U): Result<T, U>;
+  bimap<T2, E2>(_succ: (a: T) => T2, fail: (b: E) => E2): Result<T2, E2>;
+  orElse(value: T): T;
+  cast<U>(): Result<U, E>;
+  orElseThrow(message?: (e: E) => string): T;
+}
+export type Result<T, E> = Success<T, E> | Failure<T, E>;
+/** Monadic 'Result' type which encapsulates whether a procedure succeeded or failed, as well as it's return value. */
+export declare namespace Result {
+  /** Construct a new success result wrapping the given value. */
+  function success<T, E>(value: T): Result<T, E>;
+  /** Construct a new failure value wrapping the given error. */
+  function failure<T, E>(error: E): Result<T, E>;
+  /** Join two results with a bi-function and return a new result. */
+  function flatMap2<T1, T2, O, E>(first: Result<T1, E>, second: Result<T2, E>, f: (a: T1, b: T2) => Result<O, E>): Result<O, E>;
+  /** Join two results with a bi-function and return a new result. */
+  function map2<T1, T2, O, E>(first: Result<T1, E>, second: Result<T2, E>, f: (a: T1, b: T2) => O): Result<O, E>;
+}

package/dist/lib/esm/obsidian/@types/Dataview/data-import/common.d.mts

@@ -0,0 +1,3 @@
+/** Common utilities for extracting tags, links, and other business from metadata. */
+/** Extract all tags from the given source string. */
+export declare function extractTags(source: string): Set<string>;

package/dist/lib/esm/obsidian/@types/Dataview/data-import/csv.d.mts

@@ -0,0 +1,3 @@
+import type { DataObject } from '../data-model/value.d.d.mts';
+/** Parse a CSV file into a collection of data rows. */
+export declare function parseCsv(content: string): DataObject[];

package/dist/lib/esm/obsidian/@types/Dataview/data-import/inline-field.d.mts

@@ -0,0 +1,42 @@
+/** Parse inline fields and other embedded metadata in a line. */
+import type { Literal } from '../data-model/value.d.d.mts';
+/** A parsed inline field. */
+export interface InlineField {
+  /** The raw parsed key. */
+  key: string;
+  /** The raw value of the field. */
+  value: string;
+  /** The start column of the field. */
+  start: number;
+  /** The start column of the *value* for the field. */
+  startValue: number;
+  /** The end column of the field. */
+  end: number;
+  /** If this inline field was defined via a wrapping ('[' or '('), then the wrapping that was used. */
+  wrapping?: string;
+}
+/** The wrapper characters that can be used to define an inline field. */
+export declare const INLINE_FIELD_WRAPPERS: Readonly<Record<string, string>>;
+/** Parse a textual inline field value into something we can work with. */
+export declare function parseInlineValue(value: string): Literal;
+/** Extracts inline fields of the form '[key:: value]' from a line of text. This is done in a relatively
+ * "robust" way to avoid failing due to bad nesting or other interfering Markdown symbols:
+ *
+ * - Look for any wrappers ('[' and '(') in the line, trying to parse whatever comes after it as an inline key::.
+ * - If successful, scan until you find a matching end bracket, and parse whatever remains as an inline value.
+ */
+export declare function extractInlineFields(line: string, includeTaskFields?: boolean): InlineField[];
+/** Attempt to extract a full-line field (Key:: Value consuming the entire content line). */
+export declare function extractFullLineField(text: string): InlineField | undefined;
+export declare const CREATED_DATE_REGEX: RegExp;
+export declare const DUE_DATE_REGEX: RegExp;
+export declare const DONE_DATE_REGEX: RegExp;
+export declare const SCHEDULED_DATE_REGEX: RegExp;
+export declare const START_DATE_REGEX: RegExp;
+export declare const EMOJI_REGEXES: {
+  regex: RegExp;
+  key: string;
+}[];
+/** Sets or replaces the value of an inline field; if the value is 'undefined', deletes the key. */
+export declare function setInlineField(source: string, key: string, value?: string): string;
+export declare function setEmojiShorthandCompletionField(source: string, value?: string): string;

package/dist/lib/esm/obsidian/@types/Dataview/data-import/markdown-file.d.mts

@@ -0,0 +1,52 @@
+/** Importer for markdown documents. */
+import type {
+  CachedMetadata,
+  FileStats,
+  FrontMatterCache,
+  HeadingCache
+} from 'obsidian';
+import type { InlineField } from '../data-import/inline-field.d.d.mts';
+import type {
+  ListItem,
+  PageMetadata
+} from '../data-model/markdown.d.d.mts';
+import type {
+  Link,
+  Literal
+} from '../data-model/value.d.d.mts';
+/** Extract markdown metadata from the given Obsidian markdown file. */
+export declare function parsePage(path: string, contents: string, stat: FileStats, metadata: CachedMetadata): PageMetadata;
+/** Extract tags intelligently from frontmatter. Handles arrays, numbers, and strings. */
+export declare function extractTags(metadata: FrontMatterCache): string[];
+/** Extract aliases intelligently from frontmatter. Handles arrays, numbers, and strings.  */
+export declare function extractAliases(metadata: FrontMatterCache): string[];
+/** Split a frontmatter list into separate elements; handles actual lists, comma separated lists, and single elements. */
+export declare function splitFrontmatterTagOrAlias(data: any, on: RegExp): string[];
+/** Parse raw (newline-delimited) markdown, returning inline fields, list items, and other metadata. */
+export declare function parseMarkdown(path: string, contents: string[], metadata: CachedMetadata, linksByLine: Record<number, Link[]>): {
+  fields: Map<string, Literal[]>;
+  lists: ListItem[];
+};
+export declare const LIST_ITEM_REGEX: RegExp;
+/**
+ * Parse list items from the page + metadata. This requires some additional parsing above whatever Obsidian provides,
+ * since Obsidian only gives line numbers.
+ */
+export declare function parseLists(
+  path: string,
+  content: string[],
+  metadata: CachedMetadata,
+  linksByLine: Record<number, Link[]>
+): [ListItem[], Map<string, Literal[]>];
+/** Recursively convert frontmatter into fields. We have to dance around YAML structure. */
+export declare function parseFrontmatter(value: any): Literal;
+/** Add a parsed inline field to the output map. */
+export declare function addRawInlineField(field: InlineField, output: Map<string, Literal[]>): void;
+/** Add a raw inline field to an output map, canonicalizing as needed. */
+export declare function addInlineField(key: string, value: Literal, output: Map<string, Literal[]>): void;
+/** Given a raw list of inline field values, add normalized keys and squash them. */
+export declare function finalizeInlineFields(fields: Map<string, Literal[]>): Map<string, Literal>;
+/** Copy all fields of 'source' into 'target'. */
+export declare function mergeFieldGroups(target: Map<string, Literal[]>, source: Map<string, Literal[]>): void;
+/** Find the header that is most immediately above the given line number. */
+export declare function findPreviousHeader(line: number, headers: HeadingCache[]): string | undefined;

package/dist/lib/esm/obsidian/@types/Dataview/data-import/persister.d.mts

@@ -0,0 +1,32 @@
+type LocalForage = typeof import('localforage');
+
+import type { PageMetadata } from '../data-model/markdown.d.d.mts';
+/** A piece of data that has been cached for a specific version and time. */
+export interface Cached<T> {
+  /** The version of Dataview that the data was written to cache with. */
+  version: string;
+  /** The time that the data was written to cache. */
+  time: number;
+  /** The data that was cached. */
+  data: T;
+}
+/** Simpler wrapper for a file-backed cache for arbitrary metadata. */
+export declare class LocalStorageCache {
+  appId: string;
+  version: string;
+  persister: LocalForage;
+  constructor(appId: string, version: string);
+  /** Drop the entire cache instance and re-create a new fresh instance. */
+  recreate(): Promise<void>;
+  /** Load file metadata by path. */
+  loadFile(path: string): Promise<Cached<Partial<PageMetadata>> | null | undefined>;
+  /** Store file metadata by path. */
+  storeFile(path: string, data: Partial<PageMetadata>): Promise<void>;
+  /** Drop old file keys that no longer exist. */
+  synchronize(existing: string[] | Set<string>): Promise<Set<string>>;
+  /** Obtain a list of all metadata keys. */
+  allKeys(): Promise<string[]>;
+  /** Obtain a list of all persisted files. */
+  allFiles(): Promise<string[]>;
+  fileKey(path: string): string;
+}

package/dist/lib/esm/obsidian/@types/Dataview/data-import/web-worker/import-entry.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/lib/esm/obsidian/@types/Dataview/data-import/web-worker/import-impl.d.mts

@@ -0,0 +1,6 @@
+import type {
+  CachedMetadata,
+  FileStats
+} from 'obsidian';
+import type { PageMetadata } from '../../data-model/markdown.d.d.mts';
+export declare function runImport(path: string, contents: string, stats: FileStats, metadata: CachedMetadata): Partial<PageMetadata>;

package/dist/lib/esm/obsidian/@types/Dataview/data-import/web-worker/import-manager.d.mts

@@ -0,0 +1,37 @@
+/** Controls and creates Dataview file importers, allowing for asynchronous loading and parsing of files. */
+import type {
+  Component,
+  MetadataCache,
+  TFile,
+  Vault
+} from 'obsidian';
+/** Callback when a file is resolved. */
+type FileCallback = (p: any) => void;
+/** Multi-threaded file parser which debounces rapid file requests automatically. */
+export declare class FileImporter extends Component {
+  numWorkers: number;
+  vault: Vault;
+  metadataCache: MetadataCache;
+  workers: Worker[];
+  /** Tracks which workers are actively parsing a file, to make sure we properly delegate results. */
+  busy: boolean[];
+  /** List of files which have been queued for a reload. */
+  reloadQueue: TFile[];
+  /** Fast-access set which holds the list of files queued to be reloaded; used for debouncing. */
+  reloadSet: Set<string>;
+  /** Paths -> promises for file reloads which have not yet been queued. */
+  callbacks: Map<string, [FileCallback, FileCallback][]>;
+  constructor(numWorkers: number, vault: Vault, metadataCache: MetadataCache);
+  /**
+   * Queue the given file for reloading. Multiple reload requests for the same file in a short time period will be de-bounced
+   * and all be resolved by a single actual file reload.
+   */
+  reload<T>(file: TFile): Promise<T>;
+  /** Finish the parsing of a file, potentially queueing a new file. */
+  private finish;
+  /** Send a new task to the given worker ID. */
+  private send;
+  /** Find the next available, non-busy worker; return undefined if all workers are busy. */
+  private nextAvailableWorker;
+}
+export {};