obsidian-dev-utils 16.3.0 → 16.4.0

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

@@ -1,192 +1,209 @@
 /** The general, externally accessible plugin API (available at `app.plugins.plugins.dataview.api` or as global `DataviewAPI`). */
-import type { App, Component, MarkdownPostProcessorContext } from "obsidian";
-import type { FullIndex } from "../data-index/index.d.ts";
-import type { DataObject, Grouping, Link, Literal, Values, Widgets } from "../data-model/value.d.ts";
-import type { DataArray } from "./data-array.d.ts";
-import type { BoundFunctionImpl } from "../expression/functions.d.ts";
-import type { Context } from "../expression/context.d.ts";
-import type { IdentifierMeaning } from "../query/engine.d.ts";
-import type { DateTime, Duration } from "luxon";
-import * as Luxon from "luxon";
-import type { CompareOperator } from "compare-versions";
-import type { DataviewSettings, ExportSettings } from "../settings.d.ts";
-import type { SListItem } from "../data-model/serialized/markdown.d.ts";
-import type { Result } from "../api/result.d.ts";
-import type { Query } from "../query/query.d.ts";
+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.ts';
+import type { FullIndex } from '../data-index/index.d.ts';
+import type { SListItem } from '../data-model/serialized/markdown.d.ts';
+import type {
+  DataObject,
+  Grouping,
+  Link,
+  Literal,
+  Values,
+  Widgets
+} from '../data-model/value.d.ts';
+import type { Context } from '../expression/context.d.ts';
+import type { BoundFunctionImpl } from '../expression/functions.d.ts';
+import type { IdentifierMeaning } from '../query/engine.d.ts';
+import type { Query } from '../query/query.d.ts';
+import type {
+  DataviewSettings,
+  ExportSettings
+} from '../settings.d.ts';
+import type { DataArray } from './data-array.d.ts';
 /** 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;
+  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;
+  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;
+  type: 'table';
+  headers: string[];
+  values: Literal[][];
+  idMeaning: IdentifierMeaning;
 };
 /** The result of executing a list query. */
 export type ListResult = {
-    type: "list";
-    values: Literal[];
-    primaryMeaning: IdentifierMeaning;
+  type: 'list';
+  values: Literal[];
+  primaryMeaning: IdentifierMeaning;
 };
 /** The result of executing a task query. */
 export type TaskResult = {
-    type: "task";
-    values: Grouping<SListItem>;
+  type: 'task';
+  values: Grouping<SListItem>;
 };
 /** The result of executing a calendar query. */
 export type CalendarResult = {
-    type: "calendar";
-    values: {
-        date: DateTime;
-        link: Link;
-        value?: Literal[];
-    }[];
+  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;
+  /** 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/obsidian/@types/Dataview/api/result.d.ts

@@ -1,38 +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;
+  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;
+  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>;
+  /** 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/obsidian/@types/Dataview/data-import/csv.d.ts

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

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

@@ -1,19 +1,19 @@
 /** Parse inline fields and other embedded metadata in a line. */
-import type { Literal } from "../data-model/value.d.ts";
+import type { Literal } from '../data-model/value.d.ts';
 /** 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 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>>;
@@ -34,8 +34,8 @@ 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;
+  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;

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

@@ -1,8 +1,19 @@
 /** Importer for markdown documents. */
-import type { InlineField } from "../data-import/inline-field.d.ts";
-import type { ListItem, PageMetadata } from "../data-model/markdown.d.ts";
-import type { Literal, Link } from "../data-model/value.d.ts";
-import type { CachedMetadata, FileStats, FrontMatterCache, HeadingCache } from "obsidian";
+import type {
+  CachedMetadata,
+  FileStats,
+  FrontMatterCache,
+  HeadingCache
+} from 'obsidian';
+import type { InlineField } from '../data-import/inline-field.d.ts';
+import type {
+  ListItem,
+  PageMetadata
+} from '../data-model/markdown.d.ts';
+import type {
+  Link,
+  Literal
+} from '../data-model/value.d.ts';
 /** 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. */
@@ -13,15 +24,20 @@ export declare function extractAliases(metadata: FrontMatterCache): string[];
 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[];
+  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[]>];
+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. */

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

@@ -1,32 +1,32 @@
-type LocalForage = typeof import("localforage");
+type LocalForage = typeof import('localforage');
 
-import type { PageMetadata } from "../data-model/markdown.d.ts";
+import type { PageMetadata } from '../data-model/markdown.d.ts';
 /** 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;
+  /** 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;
+  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/obsidian/@types/Dataview/data-import/web-worker/import-impl.d.ts

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