@lapismd/mira 0.0.1

package/dist/preview/editable-markdown-preview/editable-markdown-surface.svelte

@@ -0,0 +1,386 @@
+<script lang="ts">
+  import { onDestroy, tick, untrack, type Snippet } from "svelte";
+  import type {
+    MiraAssetResolver,
+    MiraExtension,
+    MiraFileAdapter,
+    MiraImageConfig,
+    MiraLinkResolver,
+    MiraMarkdownAuthoringConfig,
+  } from "@lapismd/mira/extensions";
+  import {
+    getEditableMarkdownPreviewOffset,
+    shouldActivateEditableMarkdownPreview,
+    shouldReturnEditableMarkdownPreviewOnBlur,
+  } from "./behavior";
+  import EditorSurface from "./editor-surface.svelte";
+  import {
+    SerializedMarkdownWriter,
+    type SerializedMarkdownWriterState,
+  } from "./serialized-writer";
+
+  type MarkdownRangeChange = (
+    replacement: string,
+    from: number,
+    to: number,
+  ) => void;
+
+  type Props = {
+    value: string;
+    preview: Snippet<[string]>;
+    previewOnChange?: MarkdownRangeChange;
+    writeMarkdown?: (value: string) => void | Promise<void>;
+    editing?: boolean;
+    extensions?: MiraExtension[];
+    sourcePath?: string;
+    linkResolver?: MiraLinkResolver;
+    assetResolver?: MiraAssetResolver;
+    fileAdapter?: MiraFileAdapter;
+    imageConfig?: MiraImageConfig;
+    authoring?: MiraMarkdownAuthoringConfig;
+    frontmatterOpen?: boolean;
+    frontmatterConfig?: unknown;
+    activateOnPreviewInteraction?: boolean;
+    returnToPreviewOnBlur?: boolean;
+    focusEditorOnEdit?: boolean;
+    class?: string;
+    label?: string;
+    onPersisted?: (value: string) => void;
+    onEditingChange?: (editing: boolean) => void;
+    onEscape?: () => void;
+    onFrontmatterChange?: (nextYaml: string, nextValue: string) => void;
+  };
+
+  let {
+    value,
+    preview,
+    previewOnChange = $bindable(undefined),
+    writeMarkdown,
+    editing = $bindable(false),
+    extensions = [],
+    sourcePath,
+    linkResolver,
+    assetResolver,
+    fileAdapter,
+    imageConfig,
+    authoring,
+    frontmatterOpen = false,
+    frontmatterConfig,
+    activateOnPreviewInteraction = true,
+    returnToPreviewOnBlur = true,
+    focusEditorOnEdit = true,
+    class: className = "",
+    label = "Edit Markdown preview",
+    onPersisted,
+    onEditingChange,
+    onEscape,
+    onFrontmatterChange,
+  }: Props = $props();
+
+  let previewSurface: HTMLDivElement | null = $state(null);
+  let editorSurface: HTMLDivElement | null = $state(null);
+  let writer: SerializedMarkdownWriter | null = null;
+  let buffer = $state("");
+  let pendingOffset = $state<number | null>(null);
+  let writerState = $state<SerializedMarkdownWriterState>({
+    dirty: false,
+    saving: false,
+    error: null,
+    value: "",
+    persistedValue: "",
+  });
+  let lastExternalValue = "";
+  let lastPersistedNotification = "";
+  let previewScrollRatio = 0;
+  let editorScrollRatio = 0;
+
+  const writable = $derived(Boolean(writeMarkdown));
+
+  $effect(() => {
+    previewOnChange = writable ? updatePreviewRange : undefined;
+    return () => {
+      previewOnChange = undefined;
+    };
+  });
+
+  $effect(() => {
+    const write = writeMarkdown;
+    const key = sourcePath;
+    const initialValue = untrack(() => value);
+    key;
+
+    writer?.destroy();
+    writer = null;
+    buffer = initialValue;
+    lastExternalValue = initialValue;
+    lastPersistedNotification = initialValue;
+    writerState = {
+      dirty: false,
+      saving: false,
+      error: null,
+      value: initialValue,
+      persistedValue: initialValue,
+    };
+
+    if (!write) {
+      editing = false;
+      return;
+    }
+
+    const activeWriter = new SerializedMarkdownWriter({
+      value: initialValue,
+      write,
+      onStateChange(state) {
+        writerState = state;
+        buffer = state.value;
+        if (state.persistedValue !== lastPersistedNotification) {
+          lastPersistedNotification = state.persistedValue;
+          onPersisted?.(state.persistedValue);
+        }
+      },
+    });
+    writer = activeWriter;
+
+    return () => {
+      activeWriter.destroy();
+      if (writer === activeWriter) {
+        writer = null;
+      }
+    };
+  });
+
+  $effect(() => {
+    const externalValue = value;
+    if (externalValue === lastExternalValue) {
+      return;
+    }
+    lastExternalValue = externalValue;
+
+    if (!writer) {
+      buffer = externalValue;
+      writerState = {
+        ...writerState,
+        value: externalValue,
+        persistedValue: externalValue,
+      };
+      return;
+    }
+
+    if (writer.replaceExternal(externalValue)) {
+      buffer = externalValue;
+      lastPersistedNotification = externalValue;
+    }
+  });
+
+  $effect(() => {
+    onEditingChange?.(editing);
+    if (!editing) {
+      void tick().then(restorePreviewScroll);
+    }
+  });
+
+  function scrollRatio(element: HTMLElement | null): number {
+    if (!element) {
+      return 0;
+    }
+    const max = element.scrollHeight - element.clientHeight;
+    return max > 0 ? element.scrollTop / max : 0;
+  }
+
+  function setScrollRatio(element: HTMLElement | null, ratio: number): void {
+    if (!element) {
+      return;
+    }
+    const max = element.scrollHeight - element.clientHeight;
+    element.scrollTop = Math.max(0, max * ratio);
+  }
+
+  function getPreviewScroller(): HTMLElement | null {
+    return (
+      previewSurface?.querySelector<HTMLElement>(".mira-markdown-preview") ??
+      previewSurface
+    );
+  }
+
+  function getEditorScroller(): HTMLElement | null {
+    return editorSurface?.querySelector<HTMLElement>(".cm-scroller") ?? null;
+  }
+
+  function restorePreviewScroll(): void {
+    setScrollRatio(getPreviewScroller(), editorScrollRatio);
+  }
+
+  function enterEditing(offset: number | null): void {
+    if (!writable || editing) {
+      return;
+    }
+    previewScrollRatio = scrollRatio(getPreviewScroller());
+    pendingOffset = offset;
+    editing = true;
+    void tick().then(() => {
+      setScrollRatio(getEditorScroller(), previewScrollRatio);
+    });
+  }
+
+  function handlePreviewClick(event: MouseEvent): void {
+    if (
+      !activateOnPreviewInteraction ||
+      !shouldActivateEditableMarkdownPreview(
+        event,
+        event.currentTarget as Element,
+      )
+    ) {
+      return;
+    }
+
+    event.preventDefault();
+    enterEditing(getEditableMarkdownPreviewOffset(event));
+  }
+
+  function handlePreviewKeydown(event: KeyboardEvent): void {
+    if (
+      !activateOnPreviewInteraction ||
+      event.target !== event.currentTarget ||
+      (event.key !== "Enter" && event.key !== " ")
+    ) {
+      return;
+    }
+
+    event.preventDefault();
+    enterEditing(null);
+  }
+
+  function updateBuffer(nextValue: string): void {
+    buffer = nextValue;
+    writer?.update(nextValue);
+  }
+
+  function updatePreviewRange(
+    replacement: string,
+    from: number,
+    to: number,
+  ): void {
+    if (
+      !writable ||
+      !Number.isInteger(from) ||
+      !Number.isInteger(to) ||
+      from < 0 ||
+      to < from ||
+      to > buffer.length
+    ) {
+      return;
+    }
+
+    updateBuffer(`${buffer.slice(0, from)}${replacement}${buffer.slice(to)}`);
+  }
+
+  async function leaveEditing(reason: "blur" | "escape"): Promise<void> {
+    if (!editing) {
+      return;
+    }
+    editorScrollRatio = scrollRatio(getEditorScroller());
+    const saved = (await writer?.flush()) ?? true;
+    if (!saved) {
+      return;
+    }
+
+    editing = false;
+    if (reason === "escape") {
+      onEscape?.();
+    }
+  }
+
+  function handleEditorFocusout(event: FocusEvent): void {
+    if (
+      !returnToPreviewOnBlur ||
+      !editorSurface ||
+      !shouldReturnEditableMarkdownPreviewOnBlur(
+        editorSurface,
+        event.relatedTarget,
+        editorSurface.ownerDocument.activeElement,
+      )
+    ) {
+      return;
+    }
+    void leaveEditing("blur");
+  }
+
+  export async function flush(): Promise<boolean> {
+    return (await writer?.flush()) ?? true;
+  }
+
+  export async function exit(): Promise<boolean> {
+    if (!editing) {
+      return true;
+    }
+    await leaveEditing("blur");
+    return !editing;
+  }
+
+  onDestroy(() => {
+    writer?.destroy();
+  });
+</script>
+
+<div
+  class={`mira-editable-markdown-preview ${className}`.trim()}
+  data-editable-markdown-preview
+  data-editing={editing ? "true" : "false"}
+  data-save-state={writerState.error
+    ? "error"
+    : writerState.saving
+      ? "saving"
+      : writerState.dirty
+        ? "dirty"
+        : "saved"}
+>
+  {#if editing}
+    <div
+      bind:this={editorSurface}
+      class="mira-editable-markdown-preview__editor-shell"
+      onfocusout={handleEditorFocusout}
+    >
+      <EditorSurface
+        value={buffer}
+        {extensions}
+        {sourcePath}
+        {linkResolver}
+        {assetResolver}
+        {fileAdapter}
+        {imageConfig}
+        {authoring}
+        {frontmatterOpen}
+        {frontmatterConfig}
+        selectionOffset={pendingOffset}
+        focusOnMount={focusEditorOnEdit}
+        onChange={updateBuffer}
+        onEscape={() => void leaveEditing("escape")}
+        {onFrontmatterChange}
+      />
+      {#if writerState.error}
+        <p class="mira-editable-markdown-preview__error" role="alert">
+          Could not save this note. {writerState.error.message}
+        </p>
+      {/if}
+    </div>
+  {:else if writable}
+    <div
+      bind:this={previewSurface}
+      class="mira-editable-markdown-preview__preview"
+      role="button"
+      tabindex="0"
+      aria-label={label}
+      onclick={handlePreviewClick}
+      onkeydown={handlePreviewKeydown}
+    >
+      {@render preview(buffer)}
+    </div>
+  {:else}
+    <div
+      bind:this={previewSurface}
+      class="mira-editable-markdown-preview__preview"
+    >
+      {@render preview(buffer)}
+    </div>
+  {/if}
+</div>

package/dist/preview/editable-markdown-preview/editable-markdown-surface.svelte.d.ts

@@ -0,0 +1,35 @@
+import { type Snippet } from "svelte";
+import type { MiraAssetResolver, MiraExtension, MiraFileAdapter, MiraImageConfig, MiraLinkResolver, MiraMarkdownAuthoringConfig } from "@lapismd/mira/extensions";
+type MarkdownRangeChange = (replacement: string, from: number, to: number) => void;
+type Props = {
+    value: string;
+    preview: Snippet<[string]>;
+    previewOnChange?: MarkdownRangeChange;
+    writeMarkdown?: (value: string) => void | Promise<void>;
+    editing?: boolean;
+    extensions?: MiraExtension[];
+    sourcePath?: string;
+    linkResolver?: MiraLinkResolver;
+    assetResolver?: MiraAssetResolver;
+    fileAdapter?: MiraFileAdapter;
+    imageConfig?: MiraImageConfig;
+    authoring?: MiraMarkdownAuthoringConfig;
+    frontmatterOpen?: boolean;
+    frontmatterConfig?: unknown;
+    activateOnPreviewInteraction?: boolean;
+    returnToPreviewOnBlur?: boolean;
+    focusEditorOnEdit?: boolean;
+    class?: string;
+    label?: string;
+    onPersisted?: (value: string) => void;
+    onEditingChange?: (editing: boolean) => void;
+    onEscape?: () => void;
+    onFrontmatterChange?: (nextYaml: string, nextValue: string) => void;
+};
+declare const EditableMarkdownSurface: import("svelte").Component<Props, {
+    flush: () => Promise<boolean>;
+    exit: () => Promise<boolean>;
+}, "previewOnChange" | "editing">;
+type EditableMarkdownSurface = ReturnType<typeof EditableMarkdownSurface>;
+export default EditableMarkdownSurface;
+//# sourceMappingURL=editable-markdown-surface.svelte.d.ts.map

package/dist/preview/editable-markdown-preview/editable-markdown-surface.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editable-markdown-surface.svelte.d.ts","sourceRoot":"","sources":["../../../src/preview/editable-markdown-preview/editable-markdown-surface.svelte.ts"],"names":[],"mappings":"AAGA,OAAO,EAA4B,KAAK,OAAO,EAAE,MAAM,QAAQ,CAAC;AAChE,OAAO,KAAK,EACR,iBAAiB,EACjB,aAAa,EACb,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,2BAA2B,EAC5B,MAAM,0BAA0B,CAAC;AAalC,KAAK,mBAAmB,GAAG,CACzB,WAAW,EAAE,MAAM,EACnB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,KACP,IAAI,CAAC;AAEV,KAAK,KAAK,GAAG;IACX,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,OAAO,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC3B,eAAe,CAAC,EAAE,mBAAmB,CAAC;IACtC,aAAa,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,SAAS,CAAC,EAAE,2BAA2B,CAAC;IACxC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,4BAA4B,CAAC,EAAE,OAAO,CAAC;IACvC,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACtC,eAAe,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAC7C,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;IACtB,mBAAmB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;CACrE,CAAC;AAsTJ,QAAA,MAAM,uBAAuB;iBA9CF,OAAO,CAAC,OAAO,CAAC;gBAIjB,OAAO,CAAC,OAAO,CAAC;iCA0C2B,CAAC;AACtE,KAAK,uBAAuB,GAAG,UAAU,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC1E,eAAe,uBAAuB,CAAC"}

package/dist/preview/editable-markdown-preview/editor-surface.svelte

@@ -0,0 +1,228 @@
+<script lang="ts">
+  import { tick } from "svelte";
+  import type { Extension } from "@codemirror/state";
+  import { EditorView } from "@codemirror/view";
+  import {
+    createMiraCodeMirrorExtensions,
+    fromOffset,
+  } from "@lapismd/mira/core";
+  import {
+    mountMiraExtensionStyles,
+    resolveMiraExtensions,
+    type MiraAssetResolver,
+    type MiraExtension,
+    type MiraExtensionRuntimeContext,
+    type MiraFileAdapter,
+    type MiraImageConfig,
+    type MiraLinkResolver,
+    type MiraMarkdownAuthoringConfig,
+  } from "@lapismd/mira/extensions";
+  import MiraCodeEditor from "../../mira-code-editor.svelte";
+  import type { MiraCodeEditorHandle } from "../../mira-code-editor";
+
+  type Props = {
+    value: string;
+    extensions?: MiraExtension[];
+    sourcePath?: string;
+    linkResolver?: MiraLinkResolver;
+    assetResolver?: MiraAssetResolver;
+    fileAdapter?: MiraFileAdapter;
+    imageConfig?: MiraImageConfig;
+    authoring?: MiraMarkdownAuthoringConfig;
+    frontmatterOpen?: boolean;
+    frontmatterConfig?: unknown;
+    selectionOffset?: number | null;
+    focusOnMount?: boolean;
+    onChange?: (value: string) => void;
+    onFrontmatterChange?: (nextYaml: string, nextValue: string) => void;
+    onEscape?: () => void;
+  };
+
+  let {
+    value,
+    extensions = [],
+    sourcePath,
+    linkResolver,
+    assetResolver,
+    fileAdapter,
+    imageConfig,
+    authoring,
+    frontmatterOpen = false,
+    frontmatterConfig,
+    selectionOffset = null,
+    focusOnMount = true,
+    onChange,
+    onFrontmatterChange,
+    onEscape,
+  }: Props = $props();
+
+  let codeEditor: MiraCodeEditorHandle | null = $state(null);
+  let cleanupExtensionMounts: Array<() => void> = [];
+  let placedInitialSelection = false;
+
+  const resolvedExtensions = $derived(
+    resolveMiraExtensions(extensions, {
+      mode: "live-preview",
+      readonly: false,
+      sourcePath,
+    }),
+  );
+  const extensionSignature = $derived(
+    [
+      sourcePath,
+      frontmatterOpen,
+      JSON.stringify({ authoring, frontmatterConfig, imageConfig }),
+      extensions.map((extension) => extension.name).join(","),
+      resolvedExtensions.codeMirror.length,
+      resolvedExtensions.commands.map((command) => command.id).join(","),
+    ].join("|"),
+  );
+
+  function runtimeContext(
+    activeEditor: MiraCodeEditorHandle | null,
+    view: unknown = activeEditor?.getView(),
+  ): MiraExtensionRuntimeContext {
+    return {
+      view,
+      mode: "live-preview",
+      readonly: false,
+      sourcePath,
+      getValue: () => activeEditor?.getValue() ?? value,
+      setValue(nextValue) {
+        activeEditor?.setValue(nextValue);
+        onChange?.(nextValue);
+      },
+      focus: () => activeEditor?.focus(),
+      insertMarkdown(markdown, selection) {
+        activeEditor?.replaceSelection(markdown, selection);
+        activeEditor?.focus();
+      },
+    };
+  }
+
+  function buildExtensions(): Extension[] {
+    return createMiraCodeMirrorExtensions({
+      includeBaseExtensions: false,
+      mode: "live-preview",
+      readonly: false,
+      lineWrapping: true,
+      spellcheck: true,
+      blockControls: false,
+      indentGuides: true,
+      indentWithTabs: true,
+      indentWidth: 4,
+      extensions,
+      sourcePath,
+      linkResolver,
+      assetResolver,
+      fileAdapter,
+      imageConfig,
+      authoring,
+      frontmatterOpen,
+      frontmatterConfig,
+      runtimeContext: (view) => runtimeContext(codeEditor, view),
+      onChange(replacement, from, to) {
+        codeEditor?.getView()?.dispatch({
+          changes: { from, to, insert: replacement },
+        });
+      },
+      onFrontmatterChange,
+    }).concat(
+      EditorView.domEventHandlers({
+        keydown: (event) => {
+          handleKeydown(event);
+          return event.defaultPrevented;
+        },
+      }),
+    );
+  }
+
+  const codeMirrorExtensions = $derived.by(() => {
+    extensionSignature;
+    linkResolver;
+    assetResolver;
+    fileAdapter;
+    return buildExtensions();
+  });
+
+  function runExtensionMounts(activeEditor: MiraCodeEditorHandle): void {
+    cleanupExtensionMounts.forEach((cleanup) => cleanup());
+    cleanupExtensionMounts = [];
+
+    const view = activeEditor.getView();
+    if (!view) return;
+
+    for (const mountExtension of resolvedExtensions.onMount) {
+      const cleanup = mountExtension(runtimeContext(activeEditor, view));
+      if (typeof cleanup === "function") {
+        cleanupExtensionMounts.push(cleanup);
+      }
+    }
+  }
+
+  function placeInitialSelection(activeEditor: MiraCodeEditorHandle): void {
+    const view = activeEditor.getView();
+    if (!view) return;
+    if (selectionOffset !== null) {
+      const position = fromOffset(view.state.doc, selectionOffset);
+      activeEditor.setSelection({ anchor: position, head: position });
+    }
+    if (focusOnMount) {
+      activeEditor.focus();
+    }
+  }
+
+  function handleKeydown(event: KeyboardEvent): void {
+    if (event.key !== "Escape") {
+      return;
+    }
+    event.preventDefault();
+    event.stopPropagation();
+    onEscape?.();
+  }
+
+  $effect(() => mountMiraExtensionStyles(resolvedExtensions.styles));
+
+  $effect(() => {
+    resolvedExtensions;
+    extensionSignature;
+    codeMirrorExtensions;
+    const activeEditor = codeEditor;
+    if (activeEditor) runExtensionMounts(activeEditor);
+    return () => {
+      cleanupExtensionMounts.forEach((cleanup) => cleanup());
+      cleanupExtensionMounts = [];
+    };
+  });
+
+  $effect(() => {
+    const activeEditor = codeEditor;
+    if (!activeEditor || placedInitialSelection) return;
+    placedInitialSelection = true;
+    void tick().then(() => placeInitialSelection(activeEditor));
+  });
+</script>
+
+<div
+  class="mira-editable-markdown-preview__editor markdown-editor-surface markdown-live-preview-mode"
+  data-editable-markdown-editor
+  role="application"
+  aria-label="Markdown editor"
+>
+  <MiraCodeEditor
+    bind:this={codeEditor}
+    {value}
+    extensions={codeMirrorExtensions}
+    lineWrapping={true}
+    spellcheck={true}
+    indentWithTabs={true}
+    indentWidth={4}
+    ariaLabel="Markdown editor"
+    variant="document"
+    surface="frameless"
+    height="fill"
+    minHeight="100%"
+    class="mira-editable-markdown-preview__editor-host"
+    onChange={(nextValue) => onChange?.(nextValue)}
+  />
+</div>

package/dist/preview/editable-markdown-preview/editor-surface.svelte.d.ts

@@ -0,0 +1,22 @@
+import { type MiraAssetResolver, type MiraExtension, type MiraFileAdapter, type MiraImageConfig, type MiraLinkResolver, type MiraMarkdownAuthoringConfig } from "@lapismd/mira/extensions";
+type Props = {
+    value: string;
+    extensions?: MiraExtension[];
+    sourcePath?: string;
+    linkResolver?: MiraLinkResolver;
+    assetResolver?: MiraAssetResolver;
+    fileAdapter?: MiraFileAdapter;
+    imageConfig?: MiraImageConfig;
+    authoring?: MiraMarkdownAuthoringConfig;
+    frontmatterOpen?: boolean;
+    frontmatterConfig?: unknown;
+    selectionOffset?: number | null;
+    focusOnMount?: boolean;
+    onChange?: (value: string) => void;
+    onFrontmatterChange?: (nextYaml: string, nextValue: string) => void;
+    onEscape?: () => void;
+};
+declare const EditorSurface: import("svelte").Component<Props, {}, "">;
+type EditorSurface = ReturnType<typeof EditorSurface>;
+export default EditorSurface;
+//# sourceMappingURL=editor-surface.svelte.d.ts.map

package/dist/preview/editable-markdown-preview/editor-surface.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"editor-surface.svelte.d.ts","sourceRoot":"","sources":["../../../src/preview/editable-markdown-preview/editor-surface.svelte.ts"],"names":[],"mappings":"AAUA,OAAO,EAGH,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAElB,KAAK,eAAe,EACpB,KAAK,eAAe,EACpB,KAAK,gBAAgB,EACrB,KAAK,2BAA2B,EACjC,MAAM,0BAA0B,CAAC;AAKlC,KAAK,KAAK,GAAG;IACX,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,CAAC,EAAE,aAAa,EAAE,CAAC;IAC7B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,YAAY,CAAC,EAAE,gBAAgB,CAAC;IAChC,aAAa,CAAC,EAAE,iBAAiB,CAAC;IAClC,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,SAAS,CAAC,EAAE,2BAA2B,CAAC;IACxC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAChC,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC;IACnC,mBAAmB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,IAAI,CAAC;IACpE,QAAQ,CAAC,EAAE,MAAM,IAAI,CAAC;CACvB,CAAC;AAsLJ,QAAA,MAAM,aAAa,2CAAwC,CAAC;AAC5D,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,aAAa,CAAC,CAAC;AACtD,eAAe,aAAa,CAAC"}