obsidian-typings 1.1.6 → 2.0.0

package/CHANGELOG.md

@@ -0,0 +1,118 @@
+# Changelog
+
+## 2.0.0
+
+-   Split up typings codebase into separate files
+-   Added `/implementations` submodule which provides additional code imports
+    -   `InternalPluginName`
+    -   `createTFile` and `createTFolder` functions
+    -   `CustomArrayDictImpl`
+-   Added typings for:
+    -   Missing `Platform` constants
+    -   `HotkeysSettingTab`
+    -   `LinkUpdaters`
+    -   `DragManager`
+-   Fixed typings for:
+    -   `enable` is async (`Plugin`)
+    -   Return type of `getEnabledPluginById` (`InternalPlugins`)
+    -   Return type of `saveAttachment` (`App`)
+    -   Return type of `importAttachments` (`App`)
+    -   Parameter order of `getAvailablePathForAttachments` (`Vault`)
+-   Improved compatibility with older and newer Node and TS configurations
+
+## 1.1.6
+
+-   Refactored `InternalPlugin` instance structure
+-   Fixed return type of `splitLeafOrActive`, returns `WorkspaceLeaf`
+
+## 1.1.5
+
+-   **DEPRECATED:** `app.isMobile` will be removed in a future version, prefer usage of `Platform.isMobile`
+-   **DEPRECATED:** `app.account` has been removed
+-   Fix `getFileInfo`, returns `undefined` if file does not exist
+
+## 1.1.4
+
+-   **NOTE:** the global `app` variable has been removed from the official Obsidian API as of 1.6.0, it will _not_ be re-added by `obsidian-typings`.
+-   **DEPRECATED:** `loadProgress` has been made inaccessible in version 1.6.0
+-   **DEPRECATED:** `collapsed`/`collapsible` properties of `TreeItem` have been removed in 1.6.0
+-   `showRibbon` setting was added
+-   `footnotes` were added to `MetadataCache`
+-   Added typings for `DomElementInfo` to allow for adding event listeners directly within `createEl`
+-   Added `instance` to `InternalPlugin` definitions
+-   New methods/variables added in 1.6.0/1.6.1 have gotten preliminary typings
+
+## 1.1.3
+
+-   Use obsidian as a peer dependency when installing the package
+
+## 1.1.2
+
+-   Renamed `Editor` to `BaseEditor` and `ExtendedEditor` to `Editor`, as most components and views directly make use of
+    the `Editor` class (and `BaseEditor` is never used directly)
+
+## 1.1.1
+
+-   Fix incorrect return type for `loadLocalStorage` function
+
+## 1.1.0
+
+-   Add typings for Live Preview Editor instances (`MarkdownView`, `MarkdownEditView`, `MarkdownScrollableEditView`, ...)
+-   Improved typings for `MetadataEditor` and `PropertyWidgetType`
+-   Add basic typings for Vim CM plugin to `@codemirror/view` module
+-   Moved all interfaces and classes under the `obsidian` module
+-   Removed commented trigger functions from `Events`-derived classes
+-   Removed duplicated definitions
+-   Sorted file interfaces alphabetically, applied dprint formatting
+
+## 1.0.8
+
+-   Add `aliases` widget type to `PropertyWidgetType`
+-   Allow arbitrary widgets for `PropertyWidgetType`
+
+## 1.0.7
+
+-   Fix `setType` and `unsetType` of `app.metadataTypeManager` not being marked as `async`
+
+## 1.0.6
+
+-   Fix unnecessary typings for overridden `trigger` functions on `Events`-derived classes
+-   Fix `revealInFolder` for file-explorer plugin not accepting `TFile` inputs
+
+## v1.0.5
+
+-   Fix some methods on `Menu` and `MenuItem` not being chainable
+
+## v1.0.4
+
+-   Added missing EventRef types
+    -   **View Registry:** `view-registered`, `view-unregistered`, `extensions-updated`
+    -   **Metadata Cache:** `initialized`, `finished`
+    -   **Workspace:** `hover-link`, `tab-group-menu`, `swipe`, `layout-ready`, `url-menu`, `search:results-menu`, `receive-text-menu`,
+        `receive-files-menu`, `canvas:selection-menu`, `canvas:node-menu`, `canvas:node-connection-drop-menu`, `canvas:edge-menu`
+    -   **Workspace Leaf:** `history-change`, `leaf-menu`
+-   Added missing typings for `Menu` and `MenuItem` classes
+-   Added missing typings for `Tree` and `TreeItem` classes (used in `Outline` and `FileExplorer` plugin views)
+-   Set vertical height for a split leaf item via `setDimension`
+-   Bumped `electron-types` version
+
+## v1.0.3
+
+-   Change `electron-types` types inclusion
+-   Added note in `README.md` on automatically including new types
+-   Fix lambda definitions and tsc compilation
+
+## v1.0.2
+
+-   Changed `any` type to `unknown` to enforcing explicit type casting
+-   Fixed `CONTRIBUTING.md` link in `README.md`
+-   Added badges to `README.md`
+
+## v1.0.1
+
+-   Automated npm publishing
+
+## v1.0.0 (initial npm release)
+
+-   Made package installable via npm
+-   Clarified README, added contribution guidelines

package/README.md

@@ -1,7 +1,7 @@
-
 <center>
 
 # Obsidian Extended Typings
+
 </center>
 
 ---
@@ -21,13 +21,14 @@
     </a>
 </div>
 
-
-
 ---
+
 <div align="center">
 <h4>
  <a href="https://github.com/Fevol/obsidian-typings/blob/main/CHANGELOG.md">CHANGELOG</a>
  <span>&nbsp;·&nbsp;</span>
+ <a href="https://github.com/Fevol/obsidian-typings/blob/main/MIGRATION.md">MIGRATION</a>
+ <span>&nbsp;·&nbsp;</span>
  <a href="https://www.npmjs.com/package/obsidian-typings">NPM</a>
  <span>&nbsp;·&nbsp;</span>
  <a href="https://github.com/Fevol/obsidian-typings/blob/main/CONTRIBUTING.md">CONTRIBUTING</a>
@@ -35,81 +36,159 @@
 </h4>
 </div>
 
-
 ---
 
+This repository contains TypeScript typings for undocumented [Obsidian API](https://github.com/obsidianmd/obsidian-api/blob/master/obsidian.d.ts) methods and variables, including additional descriptions and example uses.
 
-This repository contains TypeScript typings for undocumented [Obsidian](https://obsidian.md/) API functions and variables and additional descriptions, 
-essentially extending the official [Obsidian API](https://github.com/obsidianmd/obsidian-api/blob/master/obsidian.d.ts).
+Be aware that the typings currently only cover a subset of the full API: while most of the `App` interface and its sub-interfaces are covered, this package does not yet provide typings for views like `Graph`, `Canvas`, ... — contributions for these would be very welcome!
 
-Be aware that the typings currently only cover a subset of all methods: most of the `App` interface and its sub-interfaces
-are covered, but typings for views like `Graph`, `Canvas`, ... are still missing -- contributions for these would be very welcome!
+## Set-up
+1. **Installation**
 
-## Installation
+   _Install using_: `npm install --save-dev obsidian-typings`
 
-There are three options for installing this package:
-1. **Explicit type importing** <br> Each typing has to be imported explicitly from `obsidian-typings` instead of `obsidian`, e.g. `import {App, MarkdownView} from "obsidian-typings"`. <br> _Install via:_ `npm install --save-dev  obsidian-typings`
 
-2. **Automatic type extending** (recommended) <br> The typings are automatically added to the existing `obsidian` module, so you can use them without any changes to your code. <br> _Install via:_ `npm install --save-dev @types/obsidian-typings@npm:obsidian-typings`.
+2. **Add `obsidian-typings` to `types` in `tsconfig.json`** (_recommended_) <span id="add-types-setting-to-tsconfig-json"></span>
 
-3. **Add extended typings as submodule** <br> Your IDE will likely pick up the typings automatically when the project is added as a submodule for your plugin, this also makes it simpler to test and submit features to the repository. <br> _Install via:_ `git submodule add https://github.com/Fevol/obsidian-typings.git typings` (or any other folder)
+    If you want to have all overridden types of `obsidian-typings` available in your project without explicit imports, add the following to your `tsconfig.json`:
 
+    ```json
+    {
+        "compilerOptions": {
+            "...": "...",
+            "types": [
+                "obsidian-typings"
+            ]
+        }
+    }
+    ```
 
 > [!WARNING]
-> If your IDE or TS compiler is not able to pick up the types from `obsidian-typings` but they were installed properly, you will need to adapt your `tsconfig.json` as follows:
+>
+> If you added the `types` field to your `tsconfig.json`, and `@types/some-package-name` does not get recognized anymore, you may need to re-add it to `types`:
 > ```json
 > {
 >     "compilerOptions": {
->         ...
+>         "...": "...",
 >         "types": [
->             "obsidian-typings"
+>             "obsidian-typings",
+>             "some-package-name"
 >         ]
 >     }
 > }
-> ```
-> (Add `"obsidian-typings"` to the `types` array for `compilerOptions`)
+
+3. **Explicit type importing**
+
+   If you prefer not to add `obsidian-typings` to your `types`, you can also add `import "obsidian-typings";` to any project file.
+
+
+
+4. **Using `obsidian-typings/implementations`** <span id="using-obsidian-typings-implementations"></span>
+
+    Depending on how your project is set up, `import { X } from "obsidian-typings/implementations";` may not work straight out of the box, e.g., if you have `"moduleResolution": "node"` or `"node10"` in your `tsconfig.json`
+
+    To solve this, you can add the following to your `tsconfig.json`:
+
+    ```json
+    {
+        "compilerOptions": {
+            ...
+            "paths": {
+                "obsidian-typings/implementations": [
+                    "./node_modules/obsidian-typings/dist/implementations.d.ts",
+                    "./node_modules/obsidian-typings/dist/implementations.cjs"
+                ]
+            }
+        }
+    }
+    ```
+
+## Usage
+
+### `obsidian` module internals
+
+To access types from the `obsidian` module, the import syntax does not change:
+
+```ts
+import { App } from "obsidian";
+
+function printInternalPlugins(app: App): void {
+  console.log(app.internalPlugins);
+}
+```
+
+### `obsidian-typings` additional interfaces
+
+Additional interfaces added by this package (which do not exist in the official API), can be imported using:
+
+```ts
+import { InternalPlugins } from "obsidian-typings";
+
+const internalPlugins: InternalPlugins = this.app.internalPlugins;
+```
+
+### `obsidian-typings/implementations`
+
+Additional helper functions/types/... added by this package can be used by importing from `obsidian-typings/implementations`:
+
+```ts
+import { InternalPluginName } from "obsidian-typings/implementations";
+
+this.app.internalPlugins.getEnabledPluginById(InternalPluginName.FileExplorer);
+```
+
+(The list of all available implementations can be found in the [implementations](https://github.com/Fevol/obsidian-typings/tree/main/src/implementations) folder.)
+
+### Extend with your own typings
+
+If you need to extend the typings provided by this package, add the following to any `.d.ts` file in your project:
+
+```ts
+declare module "obsidian-typings" {
+  interface PluginsPluginsRecord {
+    myPlugin: MyPlugin;
+  }
+}
+```
 
 ## Disclaimer
 
 > [!WARNING]
+>
 > Make sure to read below section in detail before using these typings.
 
 Please be aware that there is a good reason why (some of) the functions and types defined here are not included with the official API definitions:
-- The methods are not fully defined, and will be changed or removed in the near-future
-- There is a high risk of the code behaving unexpectedly if used improperly
-- The function was never meant to be used
 
-Please use the functions and variables provided with caution. Be prepared to update your code if the API changes,
-and only use the functions if you are confident that you understand what they will do. Reference the [official API](https://github.com/obsidianmd/obsidian-api/blob/master/obsidian.d.ts) 
-first to see if your problem may be solved with a documented function, or search
-in the #plugin-dev channel of the Obsidian Discord server. Some functions will also contain `@remark` TSDoc tags that provide
-alternatives or better solutions.
+-   The methods are not fully defined, and will be changed or removed in the near-future
+-   There is a high risk of the code behaving unexpectedly if used improperly
+-   The function was never meant to be used
 
-Methods marked `@internal` are especially risky to use: these are either not fully typed yet, or are solely intended
-to be used internally by the Obsidian app.
+Please use the functions and variables provided with caution. Be prepared to update your code if the API changes, and only use the functions if you are confident that you understand what they will do. Reference the [official API](https://github.com/obsidianmd/obsidian-api/blob/master/obsidian.d.ts) first to see if your problem may be solved with a documented function, or search in the #plugin-dev channel of the Obsidian Discord server. Some functions will also contain `@remark` TSDoc tags that provide alternatives or better solutions.
 
-Furthermore, there is a very high chance that there are mistakes in the typings, despite best efforts.
-All types had to be deduced from either context, manually running the function, or from the minified app code. 
-You _**should**_ verify that the code behaves as expected, both with regard to the expected (input/output)types, as well as what 
-the function description promises.
+Methods marked `@internal` are especially risky to use: these are either not fully typed yet, or are solely intended to be used internally by the Obsidian app.
 
-With these scary disclaimers out of the way, hopefully these typings will help you in removing 90% of the `@ts-ignore`s
-you have in your codebase, or discover solutions that didn't seem possible before.
+Furthermore, there is a very high chance that there are mistakes in the typings, despite best efforts. All types had to be deduced from either context, manually running the function, or from the minified app code. You _**should**_ verify that the code behaves as expected, both with regard to the expected (input/output)types, as well as what the function description promises.
 
+With these scary disclaimers out of the way, hopefully these typings will help you in removing 90% of the `@ts-ignore`s you have in your codebase, or discover solutions that didn't seem possible before.
 
-> [!NOTE] 
+> [!NOTE]
+>
 > **TL;DR:** Use at your own risk, verify that the code behaves as expected, and be prepared to update your code if the API changes.
-> 
+>
 > `@internal` methods are especially risky to use.
-> 
+>
 > `@remark` tags give some warnings about the inputs/outputs of the function, or provide better alternatives.
-> 
+>
 > `@tutorial` gives additional information on how to use the function in your plugin.
 
 
+## Migration
+
+If you were using a `1.x.x` version of this package, you may need to follow the [Migration guide](MIGRATION.md) after updating to `2.0.0` or newer.
+
+
 ## Contributing
 
-Feel free to start typing any part of the Obsidian API that is not yet typed, or fixing/adding additional descriptions to existing typings.
-If you are unsure about anything, don't hesitate to open an issue.
+Feel free to start typing any part of the Obsidian API that is not yet typed, or fixing/adding additional descriptions to existing typings. If you are unsure about anything, don't hesitate to open an issue.
 
 A brief tutorial is available on how you can get started with adding new typings, or fixing existing ones, see: [CONTRIBUTING.md](CONTRIBUTING.md).

package/dist/implementations.cjs

@@ -0,0 +1,137 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+*/
+
+"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);
+
+// src/implementations/index.ts
+var implementations_exports = {};
+__export(implementations_exports, {
+  CustomArrayDictImpl: () => CustomArrayDictImpl,
+  InternalPluginName: () => InternalPluginName,
+  createTFile: () => createTFile,
+  createTFolder: () => createTFolder
+});
+module.exports = __toCommonJS(implementations_exports);
+
+// src/implementations/createTFile.ts
+var import_obsidian = require("obsidian");
+function createTFile(vault, path) {
+  let file = vault.getFileByPath(path);
+  if (file) {
+    return file;
+  }
+  file = new import_obsidian.TFile(vault, path);
+  file.parent = createTFolder(vault, vault.adapter.path.dirname(path));
+  return file;
+}
+
+// src/implementations/createTFolder.ts
+var import_obsidian2 = require("obsidian");
+function createTFolder(vault, path) {
+  let folder = vault.getFolderByPath(path);
+  if (folder) {
+    return folder;
+  }
+  folder = new import_obsidian2.TFolder(vault, path);
+  folder.parent = createTFolder(vault, vault.adapter.path.dirname(path));
+  return folder;
+}
+
+// src/implementations/CustomArrayDictImpl.ts
+var CustomArrayDictImpl = class {
+  data = {};
+  add(key, value) {
+    if (!this.data.hasOwnProperty(key))
+      this.data[key] = [];
+    const values = this.data[key];
+    if (!values.includes(value))
+      values.push(value);
+  }
+  remove(key, value) {
+    const values = this.data[key];
+    if (!values)
+      return;
+    values.remove(value);
+    if (values.length === 0)
+      delete this.data[key];
+  }
+  removeKey(key) {
+    delete this.data[key];
+  }
+  get(key) {
+    return this.data.hasOwnProperty(key) ? this.data[key] : null;
+  }
+  keys() {
+    return Object.keys(this.data);
+  }
+  clear(key) {
+    delete this.data[key];
+  }
+  clearAll() {
+    this.data = {};
+  }
+  contains(key, value) {
+    const values = this.data[key];
+    return values && values.contains(value) || false;
+  }
+  count() {
+    let ans = 0;
+    for (const key in this.data) {
+      if (this.data.hasOwnProperty(key))
+        ans += this.data[key].length;
+    }
+    return ans;
+  }
+};
+
+// src/implementations/InternalPluginName.ts
+var InternalPluginName = {
+  AudioRecorder: "audio-recorder",
+  Backlink: "backlink",
+  Bookmarks: "bookmarks",
+  Canvas: "canvas",
+  CommandPalette: "command-palette",
+  DailyNotes: "daily-notes",
+  EditorStatus: "editor-status",
+  FileExplorer: "file-explorer",
+  FileRecovery: "file-recovery",
+  GlobalSearch: "global-search",
+  Graph: "graph",
+  MarkdownImporter: "markdown-importer",
+  NoteComposer: "note-composer",
+  OutgoingLink: "outgoing-link",
+  Outline: "outline",
+  PagePreview: "page-preview",
+  Properties: "properties",
+  Publish: "publish",
+  RandomNote: "random-note",
+  SlashCommand: "slash-command",
+  Slides: "slides",
+  Starred: "starred",
+  Switcher: "switcher",
+  Sync: "sync",
+  TagPane: "tag-pane",
+  Templates: "templates",
+  WordCount: "word-count",
+  Workspaces: "workspaces",
+  ZkPrefixer: "zk-prefixer"
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/implementations/index.ts", "../src/implementations/createTFile.ts", "../src/implementations/createTFolder.ts", "../src/implementations/CustomArrayDictImpl.ts", "../src/implementations/InternalPluginName.ts"],
  "sourcesContent": ["export { createTFile } from \"./createTFile.ts\";\nexport { createTFolder } from \"./createTFolder.ts\";\nexport * from \"./CustomArrayDictImpl.ts\";\nexport * from \"./InternalPluginName.ts\";\n", "import {\n    TFile,\n    type Vault\n} from \"obsidian\";\nimport { createTFolder } from \"./index.ts\";\n\ntype TFileConstructor = { new(vault: Vault, path: string): TFile };\n\n/**\n * Creates and properly initializes the instance of TFile even the underlying file does not exist.\n * This doesn't create the missing file on the file system.\n */\nexport function createTFile(vault: Vault, path: string): TFile {\n    let file = vault.getFileByPath(path);\n    if (file) {\n        return file;\n    }\n\n    file = new (TFile as TFileConstructor)(vault, path);\n    file.parent = createTFolder(vault, vault.adapter.path.dirname(path));\n    return file;\n}\n", "import {\n    TFolder,\n    type Vault\n} from \"obsidian\";\n\ntype TFolderConstructor = { new(vault: Vault, path: string): TFolder };\n\n/**\n * Creates and properly initializes the instance of TFolder even the underlying folder does not exist.\n * This doesn't create the missing folder on the file system.\n */\nexport function createTFolder(vault: Vault, path: string): TFolder {\n    let folder = vault.getFolderByPath(path);\n    if (folder) {\n        return folder;\n    }\n\n    folder = new (TFolder as TFolderConstructor)(vault, path);\n    folder.parent = createTFolder(vault, vault.adapter.path.dirname(path));\n    return folder;\n}\n", "import type {\n    CustomArrayDict,\n    CustomArrayDictDataRecord\n} from \"../obsidian/types.d.ts\";\n\nexport class CustomArrayDictImpl<T> implements CustomArrayDict<T> {\n    public data: CustomArrayDictDataRecord<T> = {};\n\n    public add(key: string, value: T): void {\n        if (!(this.data.hasOwnProperty(key)))\n            this.data[key] = [] as T[];\n\n        const values = this.data[key]!;\n\n        if (!values.includes(value))\n            values.push(value);\n    }\n\n    public remove(key: string, value: T): void {\n        const values = this.data[key];\n        if (!values)\n            return;\n        values.remove(value);\n\n        if (values.length === 0)\n            delete this.data[key];\n    }\n\n    public removeKey(key: string): void {\n        delete this.data[key];\n    }\n\n    public get(key: string): T[] | null {\n        return this.data.hasOwnProperty(key) ? this.data[key]! : null;\n    }\n\n    public keys(): string[] {\n        return Object.keys(this.data);\n    }\n\n    public clear(key: string): void {\n        delete this.data[key];\n    }\n\n    public clearAll(): void {\n        this.data = {};\n    }\n\n    public contains(key: string, value: T): boolean {\n        const values = this.data[key];\n        return values && values.contains(value) || false;\n    }\n\n    public count(): number {\n        let ans = 0;\n        for (const key in this.data) {\n            if (this.data.hasOwnProperty(key))\n                ans += this.data[key]!.length;\n        }\n\n        return ans;\n    }\n}\n", "export const InternalPluginName = {\n    AudioRecorder: \"audio-recorder\",\n    Backlink: \"backlink\",\n    Bookmarks: \"bookmarks\",\n    Canvas: \"canvas\",\n    CommandPalette: \"command-palette\",\n    DailyNotes: \"daily-notes\",\n    EditorStatus: \"editor-status\",\n    FileExplorer: \"file-explorer\",\n    FileRecovery: \"file-recovery\",\n    GlobalSearch: \"global-search\",\n    Graph: \"graph\",\n    MarkdownImporter: \"markdown-importer\",\n    NoteComposer: \"note-composer\",\n    OutgoingLink: \"outgoing-link\",\n    Outline: \"outline\",\n    PagePreview: \"page-preview\",\n    Properties: \"properties\",\n    Publish: \"publish\",\n    RandomNote: \"random-note\",\n    SlashCommand: \"slash-command\",\n    Slides: \"slides\",\n    Starred: \"starred\",\n    Switcher: \"switcher\",\n    Sync: \"sync\",\n    TagPane: \"tag-pane\",\n    Templates: \"templates\",\n    WordCount: \"word-count\",\n    Workspaces: \"workspaces\",\n    ZkPrefixer: \"zk-prefixer\"\n} as const;\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACAA,sBAGO;AASA,SAAS,YAAY,OAAc,MAAqB;AAC3D,MAAI,OAAO,MAAM,cAAc,IAAI;AACnC,MAAI,MAAM;AACN,WAAO;AAAA,EACX;AAEA,SAAO,IAAK,sBAA2B,OAAO,IAAI;AAClD,OAAK,SAAS,cAAc,OAAO,MAAM,QAAQ,KAAK,QAAQ,IAAI,CAAC;AACnE,SAAO;AACX;;;ACrBA,IAAAA,mBAGO;AAQA,SAAS,cAAc,OAAc,MAAuB;AAC/D,MAAI,SAAS,MAAM,gBAAgB,IAAI;AACvC,MAAI,QAAQ;AACR,WAAO;AAAA,EACX;AAEA,WAAS,IAAK,yBAA+B,OAAO,IAAI;AACxD,SAAO,SAAS,cAAc,OAAO,MAAM,QAAQ,KAAK,QAAQ,IAAI,CAAC;AACrE,SAAO;AACX;;;ACfO,IAAM,sBAAN,MAA2D;AAAA,EACvD,OAAqC,CAAC;AAAA,EAEtC,IAAI,KAAa,OAAgB;AACpC,QAAI,CAAE,KAAK,KAAK,eAAe,GAAG;AAC9B,WAAK,KAAK,GAAG,IAAI,CAAC;AAEtB,UAAM,SAAS,KAAK,KAAK,GAAG;AAE5B,QAAI,CAAC,OAAO,SAAS,KAAK;AACtB,aAAO,KAAK,KAAK;AAAA,EACzB;AAAA,EAEO,OAAO,KAAa,OAAgB;AACvC,UAAM,SAAS,KAAK,KAAK,GAAG;AAC5B,QAAI,CAAC;AACD;AACJ,WAAO,OAAO,KAAK;AAEnB,QAAI,OAAO,WAAW;AAClB,aAAO,KAAK,KAAK,GAAG;AAAA,EAC5B;AAAA,EAEO,UAAU,KAAmB;AAChC,WAAO,KAAK,KAAK,GAAG;AAAA,EACxB;AAAA,EAEO,IAAI,KAAyB;AAChC,WAAO,KAAK,KAAK,eAAe,GAAG,IAAI,KAAK,KAAK,GAAG,IAAK;AAAA,EAC7D;AAAA,EAEO,OAAiB;AACpB,WAAO,OAAO,KAAK,KAAK,IAAI;AAAA,EAChC;AAAA,EAEO,MAAM,KAAmB;AAC5B,WAAO,KAAK,KAAK,GAAG;AAAA,EACxB;AAAA,EAEO,WAAiB;AACpB,SAAK,OAAO,CAAC;AAAA,EACjB;AAAA,EAEO,SAAS,KAAa,OAAmB;AAC5C,UAAM,SAAS,KAAK,KAAK,GAAG;AAC5B,WAAO,UAAU,OAAO,SAAS,KAAK,KAAK;AAAA,EAC/C;AAAA,EAEO,QAAgB;AACnB,QAAI,MAAM;AACV,eAAW,OAAO,KAAK,MAAM;AACzB,UAAI,KAAK,KAAK,eAAe,GAAG;AAC5B,eAAO,KAAK,KAAK,GAAG,EAAG;AAAA,IAC/B;AAEA,WAAO;AAAA,EACX;AACJ;;;AC9DO,IAAM,qBAAqB;AAAA,EAC9B,eAAe;AAAA,EACf,UAAU;AAAA,EACV,WAAW;AAAA,EACX,QAAQ;AAAA,EACR,gBAAgB;AAAA,EAChB,YAAY;AAAA,EACZ,cAAc;AAAA,EACd,cAAc;AAAA,EACd,cAAc;AAAA,EACd,cAAc;AAAA,EACd,OAAO;AAAA,EACP,kBAAkB;AAAA,EAClB,cAAc;AAAA,EACd,cAAc;AAAA,EACd,SAAS;AAAA,EACT,aAAa;AAAA,EACb,YAAY;AAAA,EACZ,SAAS;AAAA,EACT,YAAY;AAAA,EACZ,cAAc;AAAA,EACd,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,UAAU;AAAA,EACV,MAAM;AAAA,EACN,SAAS;AAAA,EACT,WAAW;AAAA,EACX,WAAW;AAAA,EACX,YAAY;AAAA,EACZ,YAAY;AAChB;",
  "names": ["import_obsidian"]
}
