@mnaoumov/obsidian-lib 10.10.0 → 10.12.0

package/dist/lib/esm/components/workspace-layout-state-component.mjs

@@ -0,0 +1,404 @@
+/*
+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 { snapshot } from "@mnaoumov/typescript-lib/array";
+import { invokeAsyncSafely } from "@mnaoumov/typescript-lib/async";
+import { isDataStoreJsonValue } from "../data-stores/data-store-replica.mjs";
+import { getObsidianLibState } from "../obsidian-lib-state.mjs";
+import { ComponentEx } from "./component-ex.mjs";
+import { around } from "./monkey-around-component.mjs";
+const WORKSPACE_LAYOUT_STATE_LAYOUT_KEY = "obsidianLibLayoutStateV1";
+const SHARED_STATE_KEY = "workspaceLayoutStateV1";
+const KNOWN_PLUGIN_RECORD_FIELD_COUNT = 2;
+class WorkspaceLayoutStateKeyImpl {
+  key;
+  app;
+  defaultValue;
+  isValid;
+  pluginId;
+  subscribe;
+  constructor(params) {
+    this.app = params.app;
+    this.defaultValue = params.defaultValue;
+    this.isValid = params.isValid;
+    this.key = params.key;
+    this.pluginId = params.pluginId;
+    this.subscribe = params.subscribe;
+  }
+  get(leaf) {
+    return this.resolve(readRawValue(getSharedState(), this.pluginId, this.key, getLeafId(leaf)));
+  }
+  has(leaf) {
+    return readRawValue(getSharedState(), this.pluginId, this.key, getLeafId(leaf)) !== void 0;
+  }
+  onChange(callback) {
+    return this.subscribe((change) => {
+      if (change.key !== this.key) {
+        return;
+      }
+      callback({
+        leaf: change.leafId === null ? null : this.app.workspace.getLeafById(change.leafId),
+        leafId: change.leafId,
+        oldValue: this.resolve(change.oldValue),
+        value: this.resolve(change.newValue)
+      });
+    });
+  }
+  set(value, leaf) {
+    assertJsonValue(value);
+    this.write(cloneJson(value), getLeafId(leaf));
+  }
+  unset(leaf) {
+    this.write(void 0, getLeafId(leaf));
+  }
+  resolve(rawValue) {
+    return cloneJson(rawValue !== void 0 && this.isValid(rawValue) ? rawValue : this.defaultValue);
+  }
+  write(newValue, leafId) {
+    const state = getSharedState();
+    const oldValue = readRawValue(state, this.pluginId, this.key, leafId);
+    if (JSON.stringify(oldValue) === JSON.stringify(newValue)) {
+      return;
+    }
+    if (newValue === void 0) {
+      delete ensureBucket(state, this.pluginId, leafId)[this.key];
+    } else {
+      ensureBucket(state, this.pluginId, leafId)[this.key] = newValue;
+    }
+    this.app.workspace.requestSaveLayout();
+    const change = { key: this.key, leafId, newValue, oldValue, pluginId: this.pluginId };
+    for (const subscription of snapshot(state.subscriptions)) {
+      subscription.onRecordChange(change);
+    }
+  }
+}
+class WorkspaceLayoutStateComponent extends ComponentEx {
+  /**
+   * The Obsidian app instance.
+   */
+  app;
+  /**
+   * The id of the plugin the values belong to.
+   */
+  pluginId;
+  layoutLoadListeners = /* @__PURE__ */ new Set();
+  recordChangeListeners = /* @__PURE__ */ new Set();
+  /**
+   * Creates a new workspace layout state component.
+   *
+   * @param params - The parameters.
+   * @throws A `TypeError` if the plugin id is empty.
+   */
+  constructor(params) {
+    super();
+    if (!params.pluginId) {
+      throw new TypeError("The plugin id must not be empty");
+    }
+    this.app = params.app;
+    this.pluginId = params.pluginId;
+  }
+  /**
+   * Defines a typed key.
+   *
+   * @typeParam T - The value type.
+   * @param definition - The key definition.
+   * @returns The key handle.
+   * @throws A `TypeError` if the key is empty or the default value is not JSON-safe.
+   */
+  defineKey(definition) {
+    if (!definition.key) {
+      throw new TypeError("The key must not be empty");
+    }
+    assertJsonValue(definition.defaultValue);
+    return new WorkspaceLayoutStateKeyImpl({
+      app: this.app,
+      defaultValue: cloneJson(definition.defaultValue),
+      isValid: definition.isValid ?? ((_value) => true),
+      key: definition.key,
+      pluginId: this.pluginId,
+      subscribe: (listener) => this.subscribeToRecordChanges(listener)
+    });
+  }
+  /**
+   * Subscribes to layout loads: a saved workspace loaded, the layout restored at startup, or the saved layout read when
+   * the component is first loaded after layout-ready. Every value may have changed.
+   *
+   * @param callback - Called after the layout is loaded, once its leaves exist.
+   * @returns A function that unsubscribes. Unloading the component unsubscribes too.
+   */
+  onLayoutLoad(callback) {
+    this.layoutLoadListeners.add(callback);
+    return () => {
+      this.layoutLoadListeners.delete(callback);
+    };
+  }
+  /**
+   * Subscribes to the shared installation, installing it when nobody has yet.
+   */
+  onload() {
+    super.onload();
+    const state = getSharedState();
+    const subscription = {
+      install: () => installLayoutState(this.app, state),
+      onLayoutLoad: () => {
+        for (const listener of snapshot(this.layoutLoadListeners)) {
+          invokeListener(listener);
+        }
+      },
+      onRecordChange: (change) => {
+        if (change.pluginId !== this.pluginId) {
+          return;
+        }
+        for (const listener of snapshot(this.recordChangeListeners)) {
+          invokeListener(() => {
+            listener(change);
+          });
+        }
+      }
+    };
+    state.subscriptions.push(subscription);
+    state.installation ??= { owner: subscription, uninstall: subscription.install() };
+    this.register(() => {
+      this.layoutLoadListeners.clear();
+      this.recordChangeListeners.clear();
+      state.subscriptions.splice(state.subscriptions.indexOf(subscription), 1);
+      if (state.installation?.owner !== subscription) {
+        return;
+      }
+      state.installation.uninstall();
+      const nextOwner = state.subscriptions[0];
+      state.installation = nextOwner ? { owner: nextOwner, uninstall: nextOwner.install() } : null;
+    });
+  }
+  subscribeToRecordChanges(listener) {
+    this.recordChangeListeners.add(listener);
+    return () => {
+      this.recordChangeListeners.delete(listener);
+    };
+  }
+}
+function parseWorkspaceLayoutStateRecord(value) {
+  if (!isJsonObject(value)) {
+    return { plugins: {} };
+  }
+  const plugins = {};
+  const rawPlugins = value["plugins"];
+  if (isJsonObject(rawPlugins)) {
+    for (const [pluginId, rawPluginRecord] of Object.entries(rawPlugins)) {
+      const pluginRecord = parsePluginRecord(rawPluginRecord);
+      if (pluginRecord) {
+        plugins[pluginId] = pluginRecord;
+      }
+    }
+  }
+  return { ...cloneJson(value), plugins };
+}
+function serializeWorkspaceLayoutStateRecord(record, layout) {
+  const leafIds = collectLeafIds(layout);
+  const serialized = cloneJson(record);
+  const plugins = serialized.plugins;
+  for (const [pluginId, pluginRecord] of Object.entries(plugins)) {
+    for (const [leafId, bucket] of Object.entries(pluginRecord.leaves)) {
+      if (!leafIds.has(leafId) || Object.keys(bucket).length === 0) {
+        delete pluginRecord.leaves[leafId];
+      }
+    }
+    const isEmpty = Object.keys(pluginRecord.workspace).length === 0 && Object.keys(pluginRecord.leaves).length === 0 && Object.keys(pluginRecord).length === KNOWN_PLUGIN_RECORD_FIELD_COUNT;
+    if (isEmpty) {
+      delete plugins[pluginId];
+    }
+  }
+  return Object.keys(plugins).length === 0 && Object.keys(serialized).length === 1 ? null : serialized;
+}
+function assertJsonValue(value) {
+  if (!isDataStoreJsonValue(value)) {
+    throw new TypeError("A workspace layout state value must be JSON-safe");
+  }
+}
+function cloneJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+function collectLeafIds(layout) {
+  const leafIds = /* @__PURE__ */ new Set();
+  function visit(item) {
+    if (!isPlainRecord(item)) {
+      return;
+    }
+    const id = item["id"];
+    if (item["type"] === "leaf" && typeof id === "string") {
+      leafIds.add(id);
+    }
+    const children = item["children"];
+    if (Array.isArray(children)) {
+      for (const child of children) {
+        visit(child);
+      }
+    }
+  }
+  if (isPlainRecord(layout)) {
+    for (const rootKey of ["main", "left", "right", "floating"]) {
+      visit(layout[rootKey]);
+    }
+  }
+  return leafIds;
+}
+function ensureBucket(state, pluginId, leafId) {
+  const pluginRecord = state.record.plugins[pluginId] ?? { leaves: {}, workspace: {} };
+  state.record.plugins[pluginId] = pluginRecord;
+  if (leafId === null) {
+    return pluginRecord.workspace;
+  }
+  const bucket = pluginRecord.leaves[leafId] ?? {};
+  pluginRecord.leaves[leafId] = bucket;
+  return bucket;
+}
+function getBucket(state, pluginId, leafId) {
+  const pluginRecord = state.record.plugins[pluginId];
+  if (!pluginRecord) {
+    return null;
+  }
+  return leafId === null ? pluginRecord.workspace : pluginRecord.leaves[leafId] ?? null;
+}
+function getLayoutRecordValue(layout) {
+  return isPlainRecord(layout) ? layout[WORKSPACE_LAYOUT_STATE_LAYOUT_KEY] : void 0;
+}
+function getLeafId(leaf) {
+  return leaf ? leaf.id : null;
+}
+function getSharedState() {
+  return getObsidianLibState(SHARED_STATE_KEY, {
+    installation: null,
+    isHydrated: false,
+    record: { plugins: {} },
+    subscriptions: []
+  }).value;
+}
+function installLayoutState(app, state) {
+  let isUninstalled = false;
+  const uninstallPatch = around(app.workspace, {
+    getLayout: (next) => function patchedGetLayout() {
+      const layout = next.call(this);
+      const record = serializeWorkspaceLayoutStateRecord(state.record, layout);
+      if (record) {
+        layout[WORKSPACE_LAYOUT_STATE_LAYOUT_KEY] = record;
+      }
+      return layout;
+    },
+    setLayout: (next) => async function patchedSetLayout(layout) {
+      state.record = parseWorkspaceLayoutStateRecord(getLayoutRecordValue(layout));
+      state.isHydrated = true;
+      try {
+        await next.call(this, layout);
+      } finally {
+        notifyLayoutLoad(state);
+      }
+    }
+  });
+  if (!state.isHydrated && app.workspace.layoutReady) {
+    invokeAsyncSafely(async () => {
+      const saved = await app.workspace.readWorkspaceFile();
+      if (isUninstalled || state.isHydrated) {
+        return;
+      }
+      mergeMissing(state.record, parseWorkspaceLayoutStateRecord(getLayoutRecordValue(saved)));
+      state.isHydrated = true;
+      notifyLayoutLoad(state);
+    });
+  }
+  return () => {
+    isUninstalled = true;
+    uninstallPatch();
+  };
+}
+function invokeListener(listener) {
+  try {
+    listener();
+  } catch (error) {
+    console.error("A workspace layout state listener failed", error);
+  }
+}
+function isJsonObject(value) {
+  return isPlainRecord(value) && isDataStoreJsonValue(value);
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function mergeMissing(target, source) {
+  for (const [pluginId, sourcePlugin] of Object.entries(source.plugins)) {
+    const targetPlugin = target.plugins[pluginId];
+    if (!targetPlugin) {
+      target.plugins[pluginId] = sourcePlugin;
+      continue;
+    }
+    for (const [key, value] of Object.entries(sourcePlugin.workspace)) {
+      targetPlugin.workspace[key] ??= value;
+    }
+    for (const [leafId, bucket] of Object.entries(sourcePlugin.leaves)) {
+      targetPlugin.leaves[leafId] ??= bucket;
+    }
+  }
+}
+function notifyLayoutLoad(state) {
+  for (const subscription of snapshot(state.subscriptions)) {
+    subscription.onLayoutLoad();
+  }
+}
+function parsePluginRecord(value) {
+  if (!isJsonObject(value)) {
+    return null;
+  }
+  const leaves = {};
+  const rawLeaves = value["leaves"];
+  if (isJsonObject(rawLeaves)) {
+    for (const [leafId, bucket] of Object.entries(rawLeaves)) {
+      if (isJsonObject(bucket)) {
+        leaves[leafId] = cloneJson(bucket);
+      }
+    }
+  }
+  const rawWorkspace = value["workspace"];
+  return {
+    ...cloneJson(value),
+    leaves,
+    workspace: isJsonObject(rawWorkspace) ? cloneJson(rawWorkspace) : {}
+  };
+}
+function readRawValue(state, pluginId, key, leafId) {
+  return getBucket(state, pluginId, leafId)?.[key];
+}
+export {
+  WORKSPACE_LAYOUT_STATE_LAYOUT_KEY,
+  WorkspaceLayoutStateComponent,
+  parseWorkspaceLayoutStateRecord,
+  serializeWorkspaceLayoutStateRecord
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/components/workspace-layout-state-component.ts"],"sourcesContent":["/**\n * @file\n *\n * Keeps a plugin's layout-scoped state in the workspace layout itself, so each saved workspace remembers its own value\n * and switching workspaces restores it, instead of one global value in `data.json`.\n *\n * Read from Obsidian `1.15.1`: `Workspace.getLayout()` builds a fresh object (`main`, `left`, `right`, `left-ribbon`,\n * `floating`, `active`) and `Workspace.setLayout()` ignores every other top-level key. `deserializeLayout` keeps each\n * item's `id`, popout leaves included. The Workspaces core plugin saves through `getLayout()` and loads through\n * `changeLayout()`, which calls `setLayout()`. Startup goes through `loadLayout()`, `readWorkspaceFile()` and\n * `setLayout()`, after the plugins enabled at startup have loaded. So two patches on the `app.workspace` instance carry\n * the whole thing: `getLayout` writes the records under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}, and `setLayout`\n * replaces them from the layout it is handed before any view is restored. Per-leaf state is keyed by leaf id at the\n * layout level, so no `WorkspaceItem.serialize` or `deserializeLayout` patch is needed.\n *\n * A view the plugin owns needs none of this: `View.getState` / `setState` already ride in each leaf's state. This\n * component is for the scope those methods cannot represent: the whole layout, and leaves of views the plugin does not\n * own.\n *\n * Every plugin bundles its own copy of this library, so the records, the subscriptions and ONE installation of the\n * patches live in the shared-state bag under a versioned key, owned by one subscriber. When the owner unloads while\n * others remain, the next subscriber installs again from its own copy. What crosses that boundary is a wire format\n * between copies of different versions: plain objects and plain functions only, fields only ever added, and a change of\n * meaning moves to a new key. The layout record is a wire format too, persisted in `workspace.json` and in every saved\n * workspace.\n */\n\nimport type {\n  App,\n  Workspace,\n  WorkspaceLeaf\n} from 'obsidian';\nimport type {\n  JsonObject,\n  JsonValue\n} from 'type-fest';\n\nimport { snapshot } from '@mnaoumov/typescript-lib/array';\nimport { invokeAsyncSafely } from '@mnaoumov/typescript-lib/async';\n\nimport { isDataStoreJsonValue } from '../data-stores/data-store-replica.ts';\nimport { getObsidianLibState } from '../obsidian-lib-state.ts';\nimport { ComponentEx } from './component-ex.ts';\nimport { around } from './monkey-around-component.ts';\n\n/**\n * The top-level key of a serialized layout that holds the records.\n */\nexport const WORKSPACE_LAYOUT_STATE_LAYOUT_KEY = 'obsidianLibLayoutStateV1';\n\nconst SHARED_STATE_KEY = 'workspaceLayoutStateV1';\n\n/**\n * The fields of a plugin record this version knows: `leaves` and `workspace`.\n */\nconst KNOWN_PLUGIN_RECORD_FIELD_COUNT = 2;\n\n/**\n * A change of one key's value, in one scope.\n *\n * @typeParam T - The value type.\n */\nexport interface WorkspaceLayoutStateChange<T> {\n  /**\n   * The leaf whose value changed, or `null` for the workspace scope or a leaf no longer in the layout.\n   */\n  readonly leaf: null | WorkspaceLeaf;\n\n  /**\n   * The id of the leaf whose value changed, or `null` for the workspace scope.\n   */\n  readonly leafId: null | string;\n\n  /**\n   * The value before the change, as {@link WorkspaceLayoutStateKey.get} read it.\n   */\n  readonly oldValue: T;\n\n  /**\n   * The value after the change, as {@link WorkspaceLayoutStateKey.get} reads it.\n   */\n  readonly value: T;\n}\n\n/**\n * Parameters for {@link WorkspaceLayoutStateComponent}.\n */\nexport interface WorkspaceLayoutStateComponentConstructorParams {\n  /**\n   * The Obsidian app instance.\n   */\n  readonly app: App;\n\n  /**\n   * The id of the plugin the values belong to. Every value is namespaced by it.\n   */\n  readonly pluginId: string;\n}\n\n/**\n * A typed handle to one layout-scoped key.\n *\n * Every method takes an optional leaf. Without one, the value belongs to the whole layout (the workspace scope).\n *\n * @typeParam T - The value type.\n */\nexport interface WorkspaceLayoutStateKey<T> {\n  /**\n   * Reads the value: a clone of the stored one, or of the default when nothing is stored or the stored value fails the\n   * key's guard.\n   *\n   * @param leaf - The leaf, or nothing for the workspace scope.\n   * @returns The value.\n   */\n  readonly get: (leaf?: WorkspaceLeaf) => T;\n\n  /**\n   * Checks whether a value is stored, valid or not.\n   *\n   * @param leaf - The leaf, or nothing for the workspace scope.\n   * @returns Whether a value is stored.\n   */\n  readonly has: (leaf?: WorkspaceLeaf) => boolean;\n\n  /**\n   * The key name, unique within the plugin.\n   */\n  readonly key: string;\n\n  /**\n   * Subscribes to changes of this key made through `set` or `unset`, in any scope and from any copy of the library. A\n   * layout load is reported through {@link WorkspaceLayoutStateComponent.onLayoutLoad} instead.\n   *\n   * @param callback - Called after each change.\n   * @returns A function that unsubscribes. Unloading the component unsubscribes too.\n   */\n  readonly onChange: (callback: (change: WorkspaceLayoutStateChange<T>) => void) => () => void;\n\n  /**\n   * Stores a clone of the value and requests a layout save. Storing a value equal to the stored one does nothing.\n   *\n   * @param value - The value. It must be JSON-safe; `null` is stored as `null`.\n   * @param leaf - The leaf, or nothing for the workspace scope.\n   * @throws A `TypeError` if the value is not JSON-safe.\n   */\n  readonly set: (value: T, leaf?: WorkspaceLeaf) => void;\n\n  /**\n   * Removes the stored value, so `get` reads the default again, and requests a layout save.\n   *\n   * @param leaf - The leaf, or nothing for the workspace scope.\n   */\n  readonly unset: (leaf?: WorkspaceLeaf) => void;\n}\n\n/**\n * Defines a layout-scoped key.\n *\n * @typeParam T - The value type.\n */\nexport interface WorkspaceLayoutStateKeyDefinition<T> {\n  /**\n   * The value read when nothing valid is stored.\n   */\n  readonly defaultValue: T;\n\n  /**\n   * Checks a stored value. A value that fails reads as the default and stays stored until it is replaced or unset.\n   *\n   * @default Accepts every JSON value.\n   */\n  readonly isValid?: (value: unknown) => value is T;\n\n  /**\n   * The key name, unique within the plugin.\n   */\n  readonly key: string;\n}\n\n/**\n * One plugin's records. Fields a newer copy adds are preserved.\n */\nexport interface WorkspaceLayoutStatePluginRecord {\n  /**\n   * The values by leaf id, then by key.\n   */\n  readonly leaves: Record<string, JsonRecord>;\n\n  /**\n   * Fields a newer copy of the library added.\n   */\n  readonly [field: string]: unknown;\n\n  /**\n   * The workspace-scope values by key.\n   */\n  readonly workspace: JsonRecord;\n}\n\n/**\n * The record persisted under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}. Fields a newer copy adds are preserved.\n */\nexport interface WorkspaceLayoutStateRecord {\n  /**\n   * The records by plugin id.\n   */\n  readonly plugins: Record<string, WorkspaceLayoutStatePluginRecord>;\n\n  /**\n   * Fields a newer copy of the library added.\n   */\n  readonly [field: string]: unknown;\n}\n\ntype JsonRecord = Record<string, JsonValue>;\n\ninterface RecordChange {\n  readonly key: string;\n  readonly leafId: null | string;\n  readonly newValue: JsonValue | undefined;\n  readonly oldValue: JsonValue | undefined;\n  readonly pluginId: string;\n}\n\ninterface WorkspaceLayoutStateInstallation {\n  readonly owner: WorkspaceLayoutStateSubscription;\n  readonly uninstall: () => void;\n}\n\ninterface WorkspaceLayoutStateKeyImplParams<T> {\n  readonly app: App;\n  readonly defaultValue: T;\n  readonly isValid: (value: unknown) => value is T;\n  readonly key: string;\n  readonly pluginId: string;\n  readonly subscribe: (listener: (change: RecordChange) => void) => () => void;\n}\n\ninterface WorkspaceLayoutStateSharedState {\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- Subscriber changes replace or clear the shared installation.\n  installation: null | WorkspaceLayoutStateInstallation;\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- Set once a layout or the saved layout file has been read.\n  isHydrated: boolean;\n  // eslint-disable-next-line typescript-dev-toolkit/readonly-interface-members -- A layout load replaces the records.\n  record: WorkspaceLayoutStateRecord;\n  readonly subscriptions: WorkspaceLayoutStateSubscription[];\n}\n\n/**\n * A subscriber in the shared state. The shape is part of the wire format between copies: fields are only ever added.\n */\ninterface WorkspaceLayoutStateSubscription {\n  readonly install: () => () => void;\n  readonly onLayoutLoad: () => void;\n  readonly onRecordChange: (change: RecordChange) => void;\n}\n\nclass WorkspaceLayoutStateKeyImpl<T> implements WorkspaceLayoutStateKey<T> {\n  public readonly key: string;\n\n  private readonly app: App;\n  private readonly defaultValue: T;\n  private readonly isValid: (value: unknown) => value is T;\n  private readonly pluginId: string;\n  private readonly subscribe: (listener: (change: RecordChange) => void) => () => void;\n\n  public constructor(params: WorkspaceLayoutStateKeyImplParams<T>) {\n    this.app = params.app;\n    this.defaultValue = params.defaultValue;\n    this.isValid = params.isValid;\n    this.key = params.key;\n    this.pluginId = params.pluginId;\n    this.subscribe = params.subscribe;\n  }\n\n  public get(leaf?: WorkspaceLeaf): T {\n    return this.resolve(readRawValue(getSharedState(), this.pluginId, this.key, getLeafId(leaf)));\n  }\n\n  public has(leaf?: WorkspaceLeaf): boolean {\n    return readRawValue(getSharedState(), this.pluginId, this.key, getLeafId(leaf)) !== undefined;\n  }\n\n  public onChange(callback: (change: WorkspaceLayoutStateChange<T>) => void): () => void {\n    return this.subscribe((change) => {\n      if (change.key !== this.key) {\n        return;\n      }\n      callback({\n        leaf: change.leafId === null ? null : this.app.workspace.getLeafById(change.leafId),\n        leafId: change.leafId,\n        oldValue: this.resolve(change.oldValue),\n        value: this.resolve(change.newValue)\n      });\n    });\n  }\n\n  public set(value: T, leaf?: WorkspaceLeaf): void {\n    assertJsonValue(value);\n    this.write(cloneJson(value), getLeafId(leaf));\n  }\n\n  public unset(leaf?: WorkspaceLeaf): void {\n    this.write(undefined, getLeafId(leaf));\n  }\n\n  private resolve(rawValue: JsonValue | undefined): T {\n    return cloneJson(rawValue !== undefined && this.isValid(rawValue) ? rawValue : this.defaultValue);\n  }\n\n  private write(newValue: JsonValue | undefined, leafId: null | string): void {\n    const state = getSharedState();\n    const oldValue = readRawValue(state, this.pluginId, this.key, leafId);\n    if (JSON.stringify(oldValue) === JSON.stringify(newValue)) {\n      return;\n    }\n\n    if (newValue === undefined) {\n      // A stored old value means the bucket exists, so this creates nothing.\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- The bucket is a plain record keyed by user-chosen names.\n      delete ensureBucket(state, this.pluginId, leafId)[this.key];\n    } else {\n      ensureBucket(state, this.pluginId, leafId)[this.key] = newValue;\n    }\n\n    this.app.workspace.requestSaveLayout();\n    const change: RecordChange = { key: this.key, leafId, newValue, oldValue, pluginId: this.pluginId };\n    for (const subscription of snapshot(state.subscriptions)) {\n      subscription.onRecordChange(change);\n    }\n  }\n}\n\n/**\n * Keeps a plugin's layout-scoped values in the workspace layout, so saved workspaces each restore their own.\n *\n * Any number of these, in any number of plugins, share one installation per {@link App}. Values are restored when a\n * layout loads, which REPLACES every value: write them after {@link Workspace.onLayoutReady}, and re-read them in\n * {@link onLayoutLoad}.\n */\nexport class WorkspaceLayoutStateComponent extends ComponentEx {\n  /**\n   * The Obsidian app instance.\n   */\n  protected readonly app: App;\n\n  /**\n   * The id of the plugin the values belong to.\n   */\n  protected readonly pluginId: string;\n\n  private readonly layoutLoadListeners = new Set<() => void>();\n  private readonly recordChangeListeners = new Set<(change: RecordChange) => void>();\n\n  /**\n   * Creates a new workspace layout state component.\n   *\n   * @param params - The parameters.\n   * @throws A `TypeError` if the plugin id is empty.\n   */\n  public constructor(params: WorkspaceLayoutStateComponentConstructorParams) {\n    super();\n    if (!params.pluginId) {\n      throw new TypeError('The plugin id must not be empty');\n    }\n    this.app = params.app;\n    this.pluginId = params.pluginId;\n  }\n\n  /**\n   * Defines a typed key.\n   *\n   * @typeParam T - The value type.\n   * @param definition - The key definition.\n   * @returns The key handle.\n   * @throws A `TypeError` if the key is empty or the default value is not JSON-safe.\n   */\n  public defineKey<T>(definition: WorkspaceLayoutStateKeyDefinition<T>): WorkspaceLayoutStateKey<T> {\n    if (!definition.key) {\n      throw new TypeError('The key must not be empty');\n    }\n    assertJsonValue(definition.defaultValue);\n    return new WorkspaceLayoutStateKeyImpl<T>({\n      app: this.app,\n      defaultValue: cloneJson(definition.defaultValue),\n      isValid: definition.isValid ?? ((_value): _value is T => true),\n      key: definition.key,\n      pluginId: this.pluginId,\n      subscribe: (listener) => this.subscribeToRecordChanges(listener)\n    });\n  }\n\n  /**\n   * Subscribes to layout loads: a saved workspace loaded, the layout restored at startup, or the saved layout read when\n   * the component is first loaded after layout-ready. Every value may have changed.\n   *\n   * @param callback - Called after the layout is loaded, once its leaves exist.\n   * @returns A function that unsubscribes. Unloading the component unsubscribes too.\n   */\n  public onLayoutLoad(callback: () => void): () => void {\n    this.layoutLoadListeners.add(callback);\n    return () => {\n      this.layoutLoadListeners.delete(callback);\n    };\n  }\n\n  /**\n   * Subscribes to the shared installation, installing it when nobody has yet.\n   */\n  public override onload(): void {\n    super.onload();\n\n    const state = getSharedState();\n    const subscription: WorkspaceLayoutStateSubscription = {\n      install: () => installLayoutState(this.app, state),\n      onLayoutLoad: () => {\n        for (const listener of snapshot(this.layoutLoadListeners)) {\n          invokeListener(listener);\n        }\n      },\n      onRecordChange: (change) => {\n        if (change.pluginId !== this.pluginId) {\n          return;\n        }\n        for (const listener of snapshot(this.recordChangeListeners)) {\n          invokeListener(() => {\n            listener(change);\n          });\n        }\n      }\n    };\n    state.subscriptions.push(subscription);\n    state.installation ??= { owner: subscription, uninstall: subscription.install() };\n\n    this.register(() => {\n      this.layoutLoadListeners.clear();\n      this.recordChangeListeners.clear();\n      state.subscriptions.splice(state.subscriptions.indexOf(subscription), 1);\n      if (state.installation?.owner !== subscription) {\n        return;\n      }\n\n      state.installation.uninstall();\n      const nextOwner = state.subscriptions[0];\n      state.installation = nextOwner ? { owner: nextOwner, uninstall: nextOwner.install() } : null;\n    });\n  }\n\n  private subscribeToRecordChanges(listener: (change: RecordChange) => void): () => void {\n    this.recordChangeListeners.add(listener);\n    return () => {\n      this.recordChangeListeners.delete(listener);\n    };\n  }\n}\n\n/**\n * Parses a persisted record. A part that is malformed is dropped one level at a time: a malformed record reads as\n * empty, a malformed plugin record drops only that plugin, and a malformed leaf bucket drops only that leaf. Fields this\n * copy does not know are kept.\n *\n * @param value - The value found under {@link WORKSPACE_LAYOUT_STATE_LAYOUT_KEY}.\n * @returns The parsed record, sharing nothing with the input.\n */\nexport function parseWorkspaceLayoutStateRecord(value: unknown): WorkspaceLayoutStateRecord {\n  if (!isJsonObject(value)) {\n    return { plugins: {} };\n  }\n\n  const plugins: Record<string, WorkspaceLayoutStatePluginRecord> = {};\n  const rawPlugins = value['plugins'];\n  if (isJsonObject(rawPlugins)) {\n    for (const [pluginId, rawPluginRecord] of Object.entries(rawPlugins)) {\n      const pluginRecord = parsePluginRecord(rawPluginRecord);\n      if (pluginRecord) {\n        plugins[pluginId] = pluginRecord;\n      }\n    }\n  }\n\n  return { ...cloneJson(value), plugins };\n}\n\n/**\n * Builds the record to persist into a serialized layout: leaf buckets for leaves absent from the layout are left out,\n * and so are plugins with nothing left.\n *\n * @param record - The current record.\n * @param layout - The serialized layout.\n * @returns The record to persist, or `null` when there is nothing to persist.\n */\nexport function serializeWorkspaceLayoutStateRecord(record: WorkspaceLayoutStateRecord, layout: unknown): null | WorkspaceLayoutStateRecord {\n  const leafIds = collectLeafIds(layout);\n  const serialized = cloneJson(record);\n  const plugins = serialized.plugins;\n  for (const [pluginId, pluginRecord] of Object.entries(plugins)) {\n    for (const [leafId, bucket] of Object.entries(pluginRecord.leaves)) {\n      if (!leafIds.has(leafId) || Object.keys(bucket).length === 0) {\n        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- Leaf ids are record keys.\n        delete pluginRecord.leaves[leafId];\n      }\n    }\n    const isEmpty = Object.keys(pluginRecord.workspace).length === 0 && Object.keys(pluginRecord.leaves).length === 0\n      && Object.keys(pluginRecord).length === KNOWN_PLUGIN_RECORD_FIELD_COUNT;\n    if (isEmpty) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- Plugin ids are record keys.\n      delete plugins[pluginId];\n    }\n  }\n\n  return Object.keys(plugins).length === 0 && Object.keys(serialized).length === 1 ? null : serialized;\n}\n\nfunction assertJsonValue(value: unknown): asserts value is JsonValue {\n  if (!isDataStoreJsonValue(value)) {\n    throw new TypeError('A workspace layout state value must be JSON-safe');\n  }\n}\n\nfunction cloneJson<T>(value: T): T {\n  return JSON.parse(JSON.stringify(value) as string) as T;\n}\n\nfunction collectLeafIds(layout: unknown): Set<string> {\n  const leafIds = new Set<string>();\n  function visit(item: unknown): void {\n    if (!isPlainRecord(item)) {\n      return;\n    }\n    const id = item['id'];\n    if (item['type'] === 'leaf' && typeof id === 'string') {\n      leafIds.add(id);\n    }\n    const children = item['children'];\n    if (Array.isArray(children)) {\n      for (const child of children) {\n        visit(child);\n      }\n    }\n  }\n\n  if (isPlainRecord(layout)) {\n    for (const rootKey of ['main', 'left', 'right', 'floating']) {\n      visit(layout[rootKey]);\n    }\n  }\n  return leafIds;\n}\n\nfunction ensureBucket(state: WorkspaceLayoutStateSharedState, pluginId: string, leafId: null | string): JsonRecord {\n  const pluginRecord = state.record.plugins[pluginId] ?? { leaves: {}, workspace: {} };\n  state.record.plugins[pluginId] = pluginRecord;\n  if (leafId === null) {\n    return pluginRecord.workspace;\n  }\n\n  const bucket = pluginRecord.leaves[leafId] ?? {};\n  pluginRecord.leaves[leafId] = bucket;\n  return bucket;\n}\n\nfunction getBucket(state: WorkspaceLayoutStateSharedState, pluginId: string, leafId: null | string): JsonRecord | null {\n  const pluginRecord = state.record.plugins[pluginId];\n  if (!pluginRecord) {\n    return null;\n  }\n  return leafId === null ? pluginRecord.workspace : pluginRecord.leaves[leafId] ?? null;\n}\n\nfunction getLayoutRecordValue(layout: unknown): unknown {\n  return isPlainRecord(layout) ? layout[WORKSPACE_LAYOUT_STATE_LAYOUT_KEY] : undefined;\n}\n\nfunction getLeafId(leaf: undefined | WorkspaceLeaf): null | string {\n  return leaf ? leaf.id : null;\n}\n\nfunction getSharedState(): WorkspaceLayoutStateSharedState {\n  return getObsidianLibState<WorkspaceLayoutStateSharedState>(SHARED_STATE_KEY, {\n    installation: null,\n    isHydrated: false,\n    record: { plugins: {} },\n    subscriptions: []\n  }).value;\n}\n\nfunction installLayoutState(app: App, state: WorkspaceLayoutStateSharedState): () => void {\n  let isUninstalled = false;\n  const uninstallPatch = around(app.workspace, {\n    getLayout: (next) =>\n      function patchedGetLayout(this: Workspace): Record<string, unknown> {\n        const layout = next.call(this);\n        const record = serializeWorkspaceLayoutStateRecord(state.record, layout);\n        if (record) {\n          layout[WORKSPACE_LAYOUT_STATE_LAYOUT_KEY] = record;\n        }\n        return layout;\n      },\n    setLayout: (next) =>\n      async function patchedSetLayout(this: Workspace, layout: Parameters<Workspace['setLayout']>[0]): Promise<void> {\n        state.record = parseWorkspaceLayoutStateRecord(getLayoutRecordValue(layout));\n        state.isHydrated = true;\n        try {\n          await next.call(this, layout);\n        } finally {\n          notifyLayoutLoad(state);\n        }\n      }\n  });\n\n  if (!state.isHydrated && app.workspace.layoutReady) {\n    // Loaded after the layout: read the layout the last installation saved, once, keeping what was set meanwhile.\n    invokeAsyncSafely(async () => {\n      const saved = await app.workspace.readWorkspaceFile();\n      if (isUninstalled || state.isHydrated) {\n        return;\n      }\n      mergeMissing(state.record, parseWorkspaceLayoutStateRecord(getLayoutRecordValue(saved)));\n      state.isHydrated = true;\n      notifyLayoutLoad(state);\n    });\n  }\n\n  return () => {\n    isUninstalled = true;\n    uninstallPatch();\n  };\n}\n\nfunction invokeListener(listener: () => void): void {\n  try {\n    listener();\n  } catch (error) {\n    console.error('A workspace layout state listener failed', error);\n  }\n}\n\nfunction isJsonObject(value: unknown): value is JsonObject {\n  return isPlainRecord(value) && isDataStoreJsonValue(value);\n}\n\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nfunction mergeMissing(target: WorkspaceLayoutStateRecord, source: WorkspaceLayoutStateRecord): void {\n  for (const [pluginId, sourcePlugin] of Object.entries(source.plugins)) {\n    const targetPlugin = target.plugins[pluginId];\n    if (!targetPlugin) {\n      target.plugins[pluginId] = sourcePlugin;\n      continue;\n    }\n    for (const [key, value] of Object.entries(sourcePlugin.workspace)) {\n      targetPlugin.workspace[key] ??= value;\n    }\n    for (const [leafId, bucket] of Object.entries(sourcePlugin.leaves)) {\n      targetPlugin.leaves[leafId] ??= bucket;\n    }\n  }\n}\n\nfunction notifyLayoutLoad(state: WorkspaceLayoutStateSharedState): void {\n  for (const subscription of snapshot(state.subscriptions)) {\n    subscription.onLayoutLoad();\n  }\n}\n\nfunction parsePluginRecord(value: unknown): null | WorkspaceLayoutStatePluginRecord {\n  if (!isJsonObject(value)) {\n    return null;\n  }\n\n  const leaves: Record<string, JsonRecord> = {};\n  const rawLeaves = value['leaves'];\n  if (isJsonObject(rawLeaves)) {\n    for (const [leafId, bucket] of Object.entries(rawLeaves)) {\n      if (isJsonObject(bucket)) {\n        leaves[leafId] = cloneJson<JsonRecord>(bucket);\n      }\n    }\n  }\n\n  const rawWorkspace = value['workspace'];\n  return {\n    ...cloneJson(value),\n    leaves,\n    workspace: isJsonObject(rawWorkspace) ? cloneJson<JsonRecord>(rawWorkspace) : {}\n  };\n}\n\nfunction readRawValue(state: WorkspaceLayoutStateSharedState, pluginId: string, key: string, leafId: null | string): JsonValue | undefined {\n  return getBucket(state, pluginId, leafId)?.[key];\n}\n"],"mappings":"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","names":[]}

package/dist/lib/esm/css-class.d.mts

@@ -12,6 +12,14 @@ export declare enum CssClass {
      * A CSS class for the alert modal.
      */
     AlertModal = "alert-modal",
+    /**
+     * A CSS class for the preview of the bug-report diagnostics review modal.
+     */
+    BugReportPreview = "bug-report-preview",
+    /**
+     * A CSS class for the bug-report diagnostics review modal.
+     */
+    BugReportReviewModal = "bug-report-review-modal",
     /**
      * A CSS class for the cancel button.
      */
@@ -56,6 +64,14 @@ export declare enum CssClass {
      * A CSS class for the confirm modal.
      */
     ConfirmModal = "confirm-modal",
+    /**
+     * A CSS class for the copy-text-manually modal.
+     */
+    CopyTextManuallyModal = "copy-text-manually-modal",
+    /**
+     * A CSS class for the text area of the copy-text-manually modal.
+     */
+    CopyTextManuallyText = "copy-text-manually-text",
     /**
      * A CSS class for the date component.
      */

package/dist/lib/esm/css-class.mjs

@@ -5,6 +5,8 @@ if you want to view the source, please visit the github repository of this plugi
 
 var CssClass = /* @__PURE__ */ ((CssClass2) => {
   CssClass2["AlertModal"] = "alert-modal";
+  CssClass2["BugReportPreview"] = "bug-report-preview";
+  CssClass2["BugReportReviewModal"] = "bug-report-review-modal";
   CssClass2["CancelButton"] = "cancel-button";
   CssClass2["CheckboxComponent"] = "checkbox-component";
   CssClass2["ClickableIcon"] = "clickable-icon";
@@ -16,6 +18,8 @@ var CssClass = /* @__PURE__ */ ((CssClass2) => {
   CssClass2["CodeBlockBuilderPreview"] = "code-block-builder-preview";
   CssClass2["CodeHighlighterComponent"] = "code-highlighter-component";
   CssClass2["ConfirmModal"] = "confirm-modal";
+  CssClass2["CopyTextManuallyModal"] = "copy-text-manually-modal";
+  CssClass2["CopyTextManuallyText"] = "copy-text-manually-text";
   CssClass2["DateComponent"] = "date-component";
   CssClass2["DateTimeComponent"] = "datetime-component";
   CssClass2["EmailComponent"] = "email-component";
@@ -86,4 +90,4 @@ var CssClass = /* @__PURE__ */ ((CssClass2) => {
 export {
   CssClass
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/css-class.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * CSS classes used by the `@mnaoumov/obsidian-lib` library.\n */\n\n/**\n * CSS classes used by the `@mnaoumov/obsidian-lib` library.\n */\nexport enum CssClass {\n  /**\n   * A CSS class for the alert modal.\n   */\n  AlertModal = 'alert-modal',\n\n  /**\n   * A CSS class for the cancel button.\n   */\n  CancelButton = 'cancel-button',\n\n  /**\n   * A CSS class for the checkbox component.\n   */\n  CheckboxComponent = 'checkbox-component',\n\n  /**\n   * Obsidian's class for a clickable icon button, giving it the hover background and icon-color treatment.\n   */\n  ClickableIcon = 'clickable-icon',\n\n  /**\n   * Obsidian's class for an inline code element (used by `appendCodeBlock`).\n   */\n  Code = 'code',\n\n  /**\n   * A CSS class for a collapsible field group of the code block builder modal.\n   */\n  CodeBlockBuilderGroup = 'code-block-builder-group',\n\n  /**\n   * A CSS class for the field container of a collapsible group of the code block builder modal.\n   */\n  CodeBlockBuilderGroupBody = 'code-block-builder-group-body',\n\n  /**\n   * A CSS class for the code block builder modal.\n   */\n  CodeBlockBuilderModal = 'code-block-builder-modal',\n\n  /**\n   * A CSS class for the output row of the code block builder modal.\n   */\n  CodeBlockBuilderOutput = 'code-block-builder-output',\n\n  /**\n   * A CSS class for the live preview container of the code block builder modal.\n   */\n  CodeBlockBuilderPreview = 'code-block-builder-preview',\n\n  /**\n   * A CSS class for the code highlighter component.\n   */\n  CodeHighlighterComponent = 'code-highlighter-component',\n\n  /**\n   * A CSS class for the confirm modal.\n   */\n  ConfirmModal = 'confirm-modal',\n\n  /**\n   * A CSS class for the date component.\n   */\n  DateComponent = 'date-component',\n\n  /**\n   * A CSS class for the date and time component.\n   */\n  DateTimeComponent = 'datetime-component',\n\n  /**\n   * A CSS class for the email component.\n   */\n  EmailComponent = 'email-component',\n\n  /**\n   * A CSS class for the file component.\n   */\n  FileComponent = 'file-component',\n\n  /**\n   * A CSS class for rendered markdown whose headings and lists `registerFoldHandlers` made foldable.\n   */\n  FoldableMarkdown = 'foldable-markdown',\n\n  /**\n   * A CSS class for the folder list component.\n   */\n  FolderListComponent = 'folder-list-component',\n  /**\n   * A CSS class for the hotkey component.\n   */\n  HotkeyComponent = 'hotkey-component',\n\n  /**\n   * A CSS class for the element an inline token renders into, in Reading view and in Live Preview.\n   */\n  InlineToken = 'inline-token',\n\n  /**\n   * Obsidian's class for a control that is currently ON, reused so a pressed command button matches the\n   * app's own toggled controls.\n   */\n  IsActive = 'is-active',\n\n  /**\n   * Obsidian's class for a collapsed element, reused for a collapsed group of the code block builder modal.\n   */\n  IsCollapsed = 'is-collapsed',\n\n  /**\n   * A CSS class for the placeholder.\n   */\n  IsPlaceholder = 'is-placeholder',\n\n  /**\n   * A CSS class for the library name, set on every element the library builds.\n   */\n  LibraryName = 'obsidian-lib',\n\n  /**\n   * A CSS class for the reorderable list component.\n   */\n  ListComponent = 'list-component',\n  /**\n   * Obsidian's class marking rendered-markdown content (used by `appendCodeBlock`).\n   */\n  MarkdownRendered = 'markdown-rendered',\n\n  /**\n   * A CSS class for the minimizable modal.\n   */\n  MinimizableModal = 'minimizable-modal',\n\n  /**\n   * A CSS class for the minimize button of the minimizable modal.\n   */\n  MinimizeButton = 'minimize-button',\n\n  /**\n   * A CSS class for the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBar = 'minimized-modal-bar',\n\n  /**\n   * A CSS class for the one-shot attention flash of the minimized bar, played when the user attempts a\n   * blocked action (a keystroke, right-click, or opening another modal) while the modal is minimized.\n   */\n  MinimizedModalBarAttention = 'minimized-modal-bar-attention',\n\n  /**\n   * A CSS class for the title of the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBarTitle = 'minimized-modal-bar-title',\n\n  /**\n   * A CSS class for one button in a modal's command strip.\n   */\n  ModalCommand = 'modal-command',\n\n  /**\n   * A CSS class for a control injected into an instruction's purpose text \u2014 a checkbox, a dropdown.\n   * Obsidian's own instruction bar never contains one, so nothing upstream separates it from the label\n   * it belongs to.\n   */\n  ModalCommandControl = 'modal-command-control',\n\n  /**\n   * A CSS class for the hotkey hint inside a modal command button.\n   */\n  ModalCommandHotkey = 'modal-command-hotkey',\n\n  /**\n   * A CSS class for the strip of commands a modal renders along its bottom edge.\n   */\n  ModalCommands = 'modal-commands',\n\n  /**\n   * Obsidian's class for a modal header button (e.g. the modal close button), reused to match the\n   * native modal close button's box and hover.\n   */\n  ModalHeaderButton = 'modal-header-button',\n\n  /**\n   * A CSS class for the month component.\n   */\n  MonthComponent = 'month-component',\n\n  /**\n   * A CSS class for the multiple dropdown component.\n   */\n  MultipleDropdownComponent = 'multiple-dropdown-component',\n\n  /**\n   * A CSS class for the multiple email component.\n   */\n  MultipleEmailComponent = 'multiple-email-component',\n\n  /**\n   * A CSS class for the multiple file component.\n   */\n  MultipleFileComponent = 'multiple-file-component',\n\n  /**\n   * A CSS class for the multiple text component.\n   */\n  MultipleTextComponent = 'multiple-text-component',\n\n  /**\n   * A CSS class for the number component.\n   */\n  NumberComponent = 'number-component',\n\n  /**\n   * A CSS class for the ok button.\n   */\n  OkButton = 'ok-button',\n\n  /**\n   * A CSS class for the overlay validator.\n   */\n  OverlayValidator = 'overlay-validator',\n\n  /**\n   * A CSS class for the password component.\n   */\n  PasswordComponent = 'password-component',\n\n  /**\n   * A CSS class for the banner naming a plugin this one refuses, or warns about, running beside.\n   */\n  PluginConflictBanner = 'plugin-conflict-banner',\n\n  /**\n   * A CSS class for the banner a blocked plugin renders in place of its settings, naming the mandatory\n   * dependency it is waiting for.\n   */\n  PluginDependencyBanner = 'plugin-dependency-banner',\n\n  /**\n   * A CSS class for the close button of a notice that requires close confirmation.\n   */\n  PluginNoticeCloseButton = 'plugin-notice-close-button',\n\n  /**\n   * A CSS class for the container wrapping a notice's content, used to keep the notice open when an\n   * interactive element inside it is clicked.\n   */\n  PluginNoticeContent = 'plugin-notice-content',\n\n  /**\n   * A CSS class for the plugin name shown as the prefix of a notice.\n   */\n  PluginNoticeName = 'plugin-notice-name',\n\n  /**\n   * A CSS class applied to the notice element of a notice that requires an explicit close, used to make\n   * its whole area non-dismissible.\n   */\n  PluginNoticeRequiresExplicitClose = 'plugin-notice-requires-explicit-close',\n\n  /**\n   * A CSS class for the plugin settings tab.\n   */\n  PluginSettingsTab = 'plugin-settings-tab',\n\n  /**\n   * A CSS class for the banner a plugin-suggestion renders into a settings tab.\n   */\n  PluginSuggestionBanner = 'plugin-suggestion-banner',\n\n  /**\n   * A CSS class for the row of buttons in a plugin-suggestion notice, which spaces the action button apart from\n   * the decline button.\n   */\n  PluginSuggestionNoticeButtons = 'plugin-suggestion-notice-buttons',\n\n  /**\n   * A CSS class for the popover.\n   */\n  Popover = 'popover',\n\n  /**\n   * Obsidian's class for one row of its modal instruction bar, reused so a self-created bar inherits the\n   * app's own instruction styling.\n   */\n  PromptInstruction = 'prompt-instruction',\n\n  /**\n   * Obsidian's class for the key-hint half of one instruction row. It is the only thing carrying that\n   * hint's bold weight and the `margin-inline-end` that separates it from the purpose text, so a\n   * self-created bar that omits it renders `alt 1Keep the old title` welded together. Reused rather\n   * than re-implemented: the app's rule for it is unscoped, so it reaches a plain `Modal` too, and\n   * sharing the class keeps the self-created bar and `setInstructions` from ever drifting apart.\n   */\n  PromptInstructionCommand = 'prompt-instruction-command',\n\n  /**\n   * Obsidian's class for its modal instruction bar, reused so a self-created bar inherits the app's own\n   * instruction styling.\n   */\n  PromptInstructions = 'prompt-instructions',\n\n  /**\n   * A CSS class for the prompt modal.\n   */\n  PromptModal = 'prompt-modal',\n\n  /**\n   * A CSS class for the restore button of the minimized modal bar.\n   */\n  RestoreButton = 'restore-button',\n\n  /**\n   * A CSS class for the select item modal.\n   */\n  SelectItemModal = 'select-item-modal',\n\n  /**\n   * A CSS class for the select option modal.\n   */\n  SelectOptionModal = 'select-option-modal',\n\n  /**\n   * A CSS class for the setting component wrapper.\n   */\n  SettingComponentWrapper = 'setting-component-wrapper',\n\n  /**\n   * A CSS class for the settings tabs.\n   */\n  SettingsTabs = 'settings-tabs',\n  /**\n   * A CSS class for the tag list component.\n   */\n  TagListComponent = 'tag-list-component',\n  /**\n   * A CSS class for the telephone component.\n   */\n  TelephoneComponent = 'telephone-component',\n\n  /**\n   * A CSS class for the text box.\n   */\n  TextBox = 'text-box',\n\n  /**\n   * A CSS class for the time component.\n   */\n  TimeComponent = 'time-component',\n\n  /**\n   * A CSS class for the tooltip.\n   */\n  Tooltip = 'tooltip',\n\n  /**\n   * A CSS class for the tooltip arrow.\n   */\n  TooltipArrow = 'tooltip-arrow',\n\n  /**\n   * A CSS class for the tooltip validator.\n   */\n  TooltipValidator = 'tooltip-validator',\n\n  /**\n   * A CSS class for the tri-state checkbox component.\n   */\n  TriStateCheckboxComponent = 'tri-state-checkbox-component',\n\n  /**\n   * A CSS class for the typed dropdown component.\n   */\n  TypedDropdownComponent = 'typed-dropdown-component',\n\n  /**\n   * A CSS class for the typed multiple dropdown component.\n   */\n  TypedMultipleDropdownComponent = 'typed-multiple-dropdown-component',\n\n  /**\n   * A CSS class for an input the user has not interacted with yet, used to defer the invalid styling until\n   * the input is touched.\n   */\n  Untouched = 'untouched',\n\n  /**\n   * A CSS class for the url component.\n   */\n  UrlComponent = 'url-component',\n\n  /**\n   * A CSS class for the week component.\n   */\n  WeekComponent = 'week-component'\n}\n"],
  "mappings": ";;;;;AASO,IAAK,WAAL,kBAAKA,cAAL;AAIL,EAAAA,UAAA,gBAAa;AAKb,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,UAAO;AAKP,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,6BAA0B;AAK1B,EAAAA,UAAA,8BAA2B;AAK3B,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,yBAAsB;AAItB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,iBAAc;AAMd,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAIhB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,uBAAoB;AAMpB,EAAAA,UAAA,gCAA6B;AAK7B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,kBAAe;AAOf,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,mBAAgB;AAMhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,0BAAuB;AAMvB,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,6BAA0B;AAM1B,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,sBAAmB;AAMnB,EAAAA,UAAA,uCAAoC;AAKpC,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,4BAAyB;AAMzB,EAAAA,UAAA,mCAAgC;AAKhC,EAAAA,UAAA,aAAU;AAMV,EAAAA,UAAA,uBAAoB;AASpB,EAAAA,UAAA,8BAA2B;AAM3B,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,6BAA0B;AAK1B,EAAAA,UAAA,kBAAe;AAIf,EAAAA,UAAA,sBAAmB;AAInB,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,oCAAiC;AAMjC,EAAAA,UAAA,eAAY;AAKZ,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AA5YN,SAAAA;AAAA,GAAA;",
  "names": ["CssClass"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/css-class.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * CSS classes used by the `@mnaoumov/obsidian-lib` library.\n */\n\n/**\n * CSS classes used by the `@mnaoumov/obsidian-lib` library.\n */\nexport enum CssClass {\n  /**\n   * A CSS class for the alert modal.\n   */\n  AlertModal = 'alert-modal',\n\n  /**\n   * A CSS class for the preview of the bug-report diagnostics review modal.\n   */\n  BugReportPreview = 'bug-report-preview',\n\n  /**\n   * A CSS class for the bug-report diagnostics review modal.\n   */\n  BugReportReviewModal = 'bug-report-review-modal',\n\n  /**\n   * A CSS class for the cancel button.\n   */\n  CancelButton = 'cancel-button',\n\n  /**\n   * A CSS class for the checkbox component.\n   */\n  CheckboxComponent = 'checkbox-component',\n\n  /**\n   * Obsidian's class for a clickable icon button, giving it the hover background and icon-color treatment.\n   */\n  ClickableIcon = 'clickable-icon',\n\n  /**\n   * Obsidian's class for an inline code element (used by `appendCodeBlock`).\n   */\n  Code = 'code',\n\n  /**\n   * A CSS class for a collapsible field group of the code block builder modal.\n   */\n  CodeBlockBuilderGroup = 'code-block-builder-group',\n\n  /**\n   * A CSS class for the field container of a collapsible group of the code block builder modal.\n   */\n  CodeBlockBuilderGroupBody = 'code-block-builder-group-body',\n\n  /**\n   * A CSS class for the code block builder modal.\n   */\n  CodeBlockBuilderModal = 'code-block-builder-modal',\n\n  /**\n   * A CSS class for the output row of the code block builder modal.\n   */\n  CodeBlockBuilderOutput = 'code-block-builder-output',\n\n  /**\n   * A CSS class for the live preview container of the code block builder modal.\n   */\n  CodeBlockBuilderPreview = 'code-block-builder-preview',\n\n  /**\n   * A CSS class for the code highlighter component.\n   */\n  CodeHighlighterComponent = 'code-highlighter-component',\n\n  /**\n   * A CSS class for the confirm modal.\n   */\n  ConfirmModal = 'confirm-modal',\n\n  /**\n   * A CSS class for the copy-text-manually modal.\n   */\n  CopyTextManuallyModal = 'copy-text-manually-modal',\n\n  /**\n   * A CSS class for the text area of the copy-text-manually modal.\n   */\n  CopyTextManuallyText = 'copy-text-manually-text',\n\n  /**\n   * A CSS class for the date component.\n   */\n  DateComponent = 'date-component',\n\n  /**\n   * A CSS class for the date and time component.\n   */\n  DateTimeComponent = 'datetime-component',\n\n  /**\n   * A CSS class for the email component.\n   */\n  EmailComponent = 'email-component',\n\n  /**\n   * A CSS class for the file component.\n   */\n  FileComponent = 'file-component',\n\n  /**\n   * A CSS class for rendered markdown whose headings and lists `registerFoldHandlers` made foldable.\n   */\n  FoldableMarkdown = 'foldable-markdown',\n\n  /**\n   * A CSS class for the folder list component.\n   */\n  FolderListComponent = 'folder-list-component',\n  /**\n   * A CSS class for the hotkey component.\n   */\n  HotkeyComponent = 'hotkey-component',\n\n  /**\n   * A CSS class for the element an inline token renders into, in Reading view and in Live Preview.\n   */\n  InlineToken = 'inline-token',\n\n  /**\n   * Obsidian's class for a control that is currently ON, reused so a pressed command button matches the\n   * app's own toggled controls.\n   */\n  IsActive = 'is-active',\n\n  /**\n   * Obsidian's class for a collapsed element, reused for a collapsed group of the code block builder modal.\n   */\n  IsCollapsed = 'is-collapsed',\n\n  /**\n   * A CSS class for the placeholder.\n   */\n  IsPlaceholder = 'is-placeholder',\n\n  /**\n   * A CSS class for the library name, set on every element the library builds.\n   */\n  LibraryName = 'obsidian-lib',\n\n  /**\n   * A CSS class for the reorderable list component.\n   */\n  ListComponent = 'list-component',\n  /**\n   * Obsidian's class marking rendered-markdown content (used by `appendCodeBlock`).\n   */\n  MarkdownRendered = 'markdown-rendered',\n\n  /**\n   * A CSS class for the minimizable modal.\n   */\n  MinimizableModal = 'minimizable-modal',\n\n  /**\n   * A CSS class for the minimize button of the minimizable modal.\n   */\n  MinimizeButton = 'minimize-button',\n\n  /**\n   * A CSS class for the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBar = 'minimized-modal-bar',\n\n  /**\n   * A CSS class for the one-shot attention flash of the minimized bar, played when the user attempts a\n   * blocked action (a keystroke, right-click, or opening another modal) while the modal is minimized.\n   */\n  MinimizedModalBarAttention = 'minimized-modal-bar-attention',\n\n  /**\n   * A CSS class for the title of the minimized bar of the minimizable modal.\n   */\n  MinimizedModalBarTitle = 'minimized-modal-bar-title',\n\n  /**\n   * A CSS class for one button in a modal's command strip.\n   */\n  ModalCommand = 'modal-command',\n\n  /**\n   * A CSS class for a control injected into an instruction's purpose text \u2014 a checkbox, a dropdown.\n   * Obsidian's own instruction bar never contains one, so nothing upstream separates it from the label\n   * it belongs to.\n   */\n  ModalCommandControl = 'modal-command-control',\n\n  /**\n   * A CSS class for the hotkey hint inside a modal command button.\n   */\n  ModalCommandHotkey = 'modal-command-hotkey',\n\n  /**\n   * A CSS class for the strip of commands a modal renders along its bottom edge.\n   */\n  ModalCommands = 'modal-commands',\n\n  /**\n   * Obsidian's class for a modal header button (e.g. the modal close button), reused to match the\n   * native modal close button's box and hover.\n   */\n  ModalHeaderButton = 'modal-header-button',\n\n  /**\n   * A CSS class for the month component.\n   */\n  MonthComponent = 'month-component',\n\n  /**\n   * A CSS class for the multiple dropdown component.\n   */\n  MultipleDropdownComponent = 'multiple-dropdown-component',\n\n  /**\n   * A CSS class for the multiple email component.\n   */\n  MultipleEmailComponent = 'multiple-email-component',\n\n  /**\n   * A CSS class for the multiple file component.\n   */\n  MultipleFileComponent = 'multiple-file-component',\n\n  /**\n   * A CSS class for the multiple text component.\n   */\n  MultipleTextComponent = 'multiple-text-component',\n\n  /**\n   * A CSS class for the number component.\n   */\n  NumberComponent = 'number-component',\n\n  /**\n   * A CSS class for the ok button.\n   */\n  OkButton = 'ok-button',\n\n  /**\n   * A CSS class for the overlay validator.\n   */\n  OverlayValidator = 'overlay-validator',\n\n  /**\n   * A CSS class for the password component.\n   */\n  PasswordComponent = 'password-component',\n\n  /**\n   * A CSS class for the banner naming a plugin this one refuses, or warns about, running beside.\n   */\n  PluginConflictBanner = 'plugin-conflict-banner',\n\n  /**\n   * A CSS class for the banner a blocked plugin renders in place of its settings, naming the mandatory\n   * dependency it is waiting for.\n   */\n  PluginDependencyBanner = 'plugin-dependency-banner',\n\n  /**\n   * A CSS class for the close button of a notice that requires close confirmation.\n   */\n  PluginNoticeCloseButton = 'plugin-notice-close-button',\n\n  /**\n   * A CSS class for the container wrapping a notice's content, used to keep the notice open when an\n   * interactive element inside it is clicked.\n   */\n  PluginNoticeContent = 'plugin-notice-content',\n\n  /**\n   * A CSS class for the plugin name shown as the prefix of a notice.\n   */\n  PluginNoticeName = 'plugin-notice-name',\n\n  /**\n   * A CSS class applied to the notice element of a notice that requires an explicit close, used to make\n   * its whole area non-dismissible.\n   */\n  PluginNoticeRequiresExplicitClose = 'plugin-notice-requires-explicit-close',\n\n  /**\n   * A CSS class for the plugin settings tab.\n   */\n  PluginSettingsTab = 'plugin-settings-tab',\n\n  /**\n   * A CSS class for the banner a plugin-suggestion renders into a settings tab.\n   */\n  PluginSuggestionBanner = 'plugin-suggestion-banner',\n\n  /**\n   * A CSS class for the row of buttons in a plugin-suggestion notice, which spaces the action button apart from\n   * the decline button.\n   */\n  PluginSuggestionNoticeButtons = 'plugin-suggestion-notice-buttons',\n\n  /**\n   * A CSS class for the popover.\n   */\n  Popover = 'popover',\n\n  /**\n   * Obsidian's class for one row of its modal instruction bar, reused so a self-created bar inherits the\n   * app's own instruction styling.\n   */\n  PromptInstruction = 'prompt-instruction',\n\n  /**\n   * Obsidian's class for the key-hint half of one instruction row. It is the only thing carrying that\n   * hint's bold weight and the `margin-inline-end` that separates it from the purpose text, so a\n   * self-created bar that omits it renders `alt 1Keep the old title` welded together. Reused rather\n   * than re-implemented: the app's rule for it is unscoped, so it reaches a plain `Modal` too, and\n   * sharing the class keeps the self-created bar and `setInstructions` from ever drifting apart.\n   */\n  PromptInstructionCommand = 'prompt-instruction-command',\n\n  /**\n   * Obsidian's class for its modal instruction bar, reused so a self-created bar inherits the app's own\n   * instruction styling.\n   */\n  PromptInstructions = 'prompt-instructions',\n\n  /**\n   * A CSS class for the prompt modal.\n   */\n  PromptModal = 'prompt-modal',\n\n  /**\n   * A CSS class for the restore button of the minimized modal bar.\n   */\n  RestoreButton = 'restore-button',\n\n  /**\n   * A CSS class for the select item modal.\n   */\n  SelectItemModal = 'select-item-modal',\n\n  /**\n   * A CSS class for the select option modal.\n   */\n  SelectOptionModal = 'select-option-modal',\n\n  /**\n   * A CSS class for the setting component wrapper.\n   */\n  SettingComponentWrapper = 'setting-component-wrapper',\n\n  /**\n   * A CSS class for the settings tabs.\n   */\n  SettingsTabs = 'settings-tabs',\n  /**\n   * A CSS class for the tag list component.\n   */\n  TagListComponent = 'tag-list-component',\n  /**\n   * A CSS class for the telephone component.\n   */\n  TelephoneComponent = 'telephone-component',\n\n  /**\n   * A CSS class for the text box.\n   */\n  TextBox = 'text-box',\n\n  /**\n   * A CSS class for the time component.\n   */\n  TimeComponent = 'time-component',\n\n  /**\n   * A CSS class for the tooltip.\n   */\n  Tooltip = 'tooltip',\n\n  /**\n   * A CSS class for the tooltip arrow.\n   */\n  TooltipArrow = 'tooltip-arrow',\n\n  /**\n   * A CSS class for the tooltip validator.\n   */\n  TooltipValidator = 'tooltip-validator',\n\n  /**\n   * A CSS class for the tri-state checkbox component.\n   */\n  TriStateCheckboxComponent = 'tri-state-checkbox-component',\n\n  /**\n   * A CSS class for the typed dropdown component.\n   */\n  TypedDropdownComponent = 'typed-dropdown-component',\n\n  /**\n   * A CSS class for the typed multiple dropdown component.\n   */\n  TypedMultipleDropdownComponent = 'typed-multiple-dropdown-component',\n\n  /**\n   * A CSS class for an input the user has not interacted with yet, used to defer the invalid styling until\n   * the input is touched.\n   */\n  Untouched = 'untouched',\n\n  /**\n   * A CSS class for the url component.\n   */\n  UrlComponent = 'url-component',\n\n  /**\n   * A CSS class for the week component.\n   */\n  WeekComponent = 'week-component'\n}\n"],
  "mappings": ";;;;;AASO,IAAK,WAAL,kBAAKA,cAAL;AAIL,EAAAA,UAAA,gBAAa;AAKb,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,0BAAuB;AAKvB,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,UAAO;AAKP,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,6BAA0B;AAK1B,EAAAA,UAAA,8BAA2B;AAK3B,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,0BAAuB;AAKvB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,yBAAsB;AAItB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,iBAAc;AAMd,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAIhB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,uBAAoB;AAMpB,EAAAA,UAAA,gCAA6B;AAK7B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,kBAAe;AAOf,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,mBAAgB;AAMhB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,oBAAiB;AAKjB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,2BAAwB;AAKxB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,cAAW;AAKX,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,0BAAuB;AAMvB,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,6BAA0B;AAM1B,EAAAA,UAAA,yBAAsB;AAKtB,EAAAA,UAAA,sBAAmB;AAMnB,EAAAA,UAAA,uCAAoC;AAKpC,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,4BAAyB;AAMzB,EAAAA,UAAA,mCAAgC;AAKhC,EAAAA,UAAA,aAAU;AAMV,EAAAA,UAAA,uBAAoB;AASpB,EAAAA,UAAA,8BAA2B;AAM3B,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,iBAAc;AAKd,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,qBAAkB;AAKlB,EAAAA,UAAA,uBAAoB;AAKpB,EAAAA,UAAA,6BAA0B;AAK1B,EAAAA,UAAA,kBAAe;AAIf,EAAAA,UAAA,sBAAmB;AAInB,EAAAA,UAAA,wBAAqB;AAKrB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,mBAAgB;AAKhB,EAAAA,UAAA,aAAU;AAKV,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,sBAAmB;AAKnB,EAAAA,UAAA,+BAA4B;AAK5B,EAAAA,UAAA,4BAAyB;AAKzB,EAAAA,UAAA,oCAAiC;AAMjC,EAAAA,UAAA,eAAY;AAKZ,EAAAA,UAAA,kBAAe;AAKf,EAAAA,UAAA,mBAAgB;AAhaN,SAAAA;AAAA,GAAA;",
  "names": ["CssClass"]
}
