@riebeckite/plugin-excalidraw 0.0.1

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright Rerurate_514
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,90 @@
+# @riebeckite/plugin-excalidraw
+
+Excalidraw drawing rendering for Obsidian wikilinks.
+
+[日本語](./README_ja.md)
+
+## Overview
+
+`excalidraw()` provides the `renderAttachment` hook that
+`@riebeckite/plugin-obsidian-markdown` uses when an embedded wikilink
+(`![[drawing.excalidraw]]`) resolves to an Excalidraw file. The plugin emits a
+placeholder figure carrying the drawing payload, and the client entry renders
+it to SVG.
+
+## Usage
+
+```ts
+import { defineConfig } from "@riebeckite/core";
+import { excalidraw } from "@riebeckite/plugin-excalidraw";
+import { obsidianMarkdown } from "@riebeckite/plugin-obsidian-markdown";
+
+export default defineConfig({
+  // ...
+  plugins: [obsidianMarkdown(), excalidraw()],
+});
+```
+
+The plugin registers `style.css` and a client entry (`initExcalidraw`) that
+the app calls on page initialization.
+
+## Supported formats
+
+### `*.excalidraw` — plain JSON scene
+
+A compact Excalidraw export with `elements`, optional `appState`, and
+`files`.
+
+### `*.excalidraw.md` — Obsidian Excalidraw drawing
+
+Obsidian "Excalidraw" plugin stores drawings in Markdown. The `## Drawing`
+fenced code block is extracted and supports both `json` and lz-string
+`compressed-json` variants.
+
+## Behavior
+
+### Build (`renderAttachment`)
+
+- Only handles embedded wikilinks (`![[...]]`) to paths ending in
+  `.excalidraw` or `.excalidraw.md`; everything else returns `null` and falls
+  through to the attachment plugin
+- Reads the file under `config.content.directory` (path-traversal safe)
+- Parses the scene and emits
+
+  ```html
+  <figure class="rr-excalidraw" data-excalidraw="pending" data-excalidraw-lazy="true">
+    <div class="rr-excalidraw__canvas" role="img" aria-label="drawing.excalidraw"></div>
+    <script type="application/json" class="rr-excalidraw__payload">{"elements":[...],"appState":{...},"files":{...}}</script>
+  </figure>
+  ```
+
+- Wikilink aliases can set a size: `![[drawing.excalidraw|800]]` (width) or
+  `![[drawing.excalidraw|800x600]]` (width x height)
+- Missing files, invalid scenes, or out-of-directory paths render an error
+  placeholder and log to the console
+
+### Client (`initExcalidraw`)
+
+- Renders pending figures to SVG with `exportToSvg` from
+  `@excalidraw/excalidraw`
+- Figures marked `data-excalidraw-lazy="false"` render immediately; the rest
+  render when they scroll into view (`IntersectionObserver`, 200px margin)
+- Success → `data-excalidraw="ready"` (the SVG replaces the empty canvas)
+- Failure → `data-excalidraw="error"` plus a placeholder message
+
+## Options
+
+| Option | Type | Default | Description |
+| ------ | ---- | ------- | ----------- |
+| `lazy` | `boolean` | `true` | Render lazily in the browser (as the figure enters the viewport) instead of immediately |
+
+## Exports
+
+- `excalidraw(options?)` / `excalidrawPlugin` — plugin factory
+- Type: `ExcalidrawOptions`
+
+## See also
+
+- [Plugin guide](../../docs/plugins_en.md)
+- [`@riebeckite/plugin-obsidian-markdown`](../plugin-obsidian-markdown/README.md)
+- [`@riebeckite/plugin-attachment`](../plugin-attachment/README.md)

package/README_ja.md

@@ -0,0 +1,48 @@
+# @riebeckite/plugin-excalidraw
+
+Obsidian の Excalidraw 埋め込みを SVG として表示するプラグインです。
+
+[English](./README.md)
+
+## できること
+
+`![[drawing.excalidraw]]` のような埋め込みウィキリンクを検出し、図のデータを含むプレースホルダーを出力します。ブラウザ側の `initExcalidraw` が、そのプレースホルダーを SVG に置き換えます。通常のリンクや対象外のファイルは処理せず、添付ファイル用のレンダラーに任せます。
+
+## 設定
+
+```ts
+import { defineConfig } from "@riebeckite/core";
+import { excalidraw } from "@riebeckite/plugin-excalidraw";
+import { obsidianMarkdown } from "@riebeckite/plugin-obsidian-markdown";
+
+export default defineConfig({
+  // ...
+  plugins: [obsidianMarkdown(), excalidraw()],
+});
+```
+
+## 読み込めるファイル
+
+- `*.excalidraw` — `elements`、任意の `appState` と `files` を持つ JSON シーン
+- `*.excalidraw.md` — Obsidian Excalidraw が保存する Markdown。`## Drawing` 内の `json` と `compressed-json` を読み取ります。
+
+`![[drawing.excalidraw|800]]` なら幅を、`![[drawing.excalidraw|800x600]]` なら幅と高さを指定できます。ファイルがない、内容が不正、またはコンテンツディレクトリ外を指す場合は、エラー用プレースホルダーを表示します。
+
+## 描画のタイミング
+
+既定では、図が表示領域の近くに入ってから描画します。`IntersectionObserver` が使えない環境を含め、描画に失敗した要素は `data-excalidraw="error"` になり、エラー表示へ切り替わります。
+
+| オプション | 型 | 既定値 | 内容 |
+| --- | --- | --- | --- |
+| `lazy` | `boolean` | `true` | 表示領域に近づいてから SVG を描画するか |
+
+## 公開 API
+
+- `excalidraw(options?)` / `excalidrawPlugin` — プラグインファクトリ
+- `ExcalidrawOptions` — オプションの型
+
+## 関連資料
+
+- [プラグインシステム](../../../docs/ja/plugin-system.md)
+- [`@riebeckite/plugin-obsidian-markdown`](../obsidian-markdown/README_ja.md)
+- [`@riebeckite/plugin-attachment`](../attachment/README_ja.md)

package/dist/client.d.ts

@@ -0,0 +1 @@
+export { initExcalidraw } from "./src/client_init.js";

package/dist/client.js

@@ -0,0 +1,64 @@
+// src/client_init.ts
+function initExcalidraw() {
+  const figures = Array.from(
+    document.querySelectorAll(
+      '.rr-excalidraw[data-excalidraw="pending"]'
+    )
+  );
+  if (figures.length === 0) return;
+  const immediate = figures.filter(
+    (figure) => figure.dataset.excalidrawLazy === "false"
+  );
+  for (const figure of immediate) void renderFigure(figure);
+  const lazy = figures.filter(
+    (figure) => figure.dataset.excalidrawLazy !== "false"
+  );
+  if (lazy.length === 0) return;
+  if (!("IntersectionObserver" in window)) {
+    for (const figure of lazy) void renderFigure(figure);
+    return;
+  }
+  const observer = new IntersectionObserver(
+    (entries) => {
+      for (const entry of entries) {
+        if (!entry.isIntersecting) continue;
+        const figure = entry.target;
+        observer.unobserve(figure);
+        void renderFigure(figure);
+      }
+    },
+    { rootMargin: "200px" }
+  );
+  for (const figure of lazy) observer.observe(figure);
+}
+async function renderFigure(figure) {
+  const canvas = figure.querySelector(".rr-excalidraw__canvas");
+  const payloadScript = figure.querySelector(
+    ".rr-excalidraw__payload"
+  );
+  if (!canvas || !payloadScript?.textContent) return;
+  try {
+    const payload = JSON.parse(payloadScript.textContent);
+    const { exportToSvg } = await import("@excalidraw/excalidraw");
+    const svg = await exportToSvg({
+      elements: payload.elements,
+      appState: {
+        ...payload.appState,
+        exportBackground: payload.appState.exportBackground ?? false
+      },
+      files: payload.files
+    });
+    svg.removeAttribute("width");
+    svg.removeAttribute("height");
+    svg.setAttribute("role", "img");
+    canvas.replaceChildren(svg);
+    figure.dataset.excalidraw = "ready";
+  } catch (error) {
+    console.error("[plugin-excalidraw] SVG export failed", error);
+    figure.dataset.excalidraw = "error";
+    canvas.textContent = "Drawing could not be rendered.";
+  }
+}
+export {
+  initExcalidraw
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { ExcalidrawOptions } from "./src/types.js";
+export type { ExcalidrawOptions } from "./src/types.js";
+export declare function excalidraw(options?: ExcalidrawOptions): import("@riebeckite/core").RiebeckitePlugin<ExcalidrawOptions>;
+export declare const excalidrawPlugin: typeof excalidraw;

package/dist/index.js

@@ -0,0 +1,360 @@
+// index.ts
+import {
+  createClientEntry,
+  createStyleAsset,
+  definePlugin,
+  IMAGE_EXTENSIONS,
+  readContentSourceEntry
+} from "@riebeckite/core";
+import { visit } from "unist-util-visit";
+
+// src/parse.ts
+import { createRequire } from "node:module";
+var require2 = createRequire(import.meta.url);
+var lzString = loadLzString();
+var EXCALIDRAW_FRONTMATTER_RE = /^---\s*\r?\n[\s\S]*?^excalidraw-plugin:\s*parsed\s*$[\s\S]*?^---\s*$/im;
+function parseExcalidrawScene(raw, _filePath) {
+  const isObsidianMarkdown = isObsidianExcalidrawMarkdown(raw);
+  const source = isObsidianMarkdown ? extractObsidianDrawing(raw) : raw;
+  const scene = JSON.parse(source);
+  if (!Array.isArray(scene.elements)) {
+    throw new Error("Invalid Excalidraw scene: elements is missing.");
+  }
+  return {
+    scene: {
+      ...scene,
+      elements: scene.elements,
+      appState: scene.appState ?? {},
+      files: scene.files ?? {}
+    },
+    embeddedFiles: isObsidianMarkdown ? extractEmbeddedFiles(raw) : []
+  };
+}
+function isObsidianExcalidrawMarkdown(raw) {
+  return EXCALIDRAW_FRONTMATTER_RE.test(raw);
+}
+function extractObsidianDrawing(markdown) {
+  const fence = markdown.match(
+    /## Drawing\s*\r?\n```(json|compressed-json)\s*\r?\n([\s\S]*?)\r?\n```/i
+  );
+  if (!fence?.[1] || !fence[2]) {
+    throw new Error("Obsidian Excalidraw drawing block was not found.");
+  }
+  const kind = fence[1].toLowerCase();
+  const body = fence[2].trim();
+  if (kind === "json") return body;
+  const decompressed = decompressCompressedJson(body);
+  if (!decompressed) {
+    throw new Error(
+      "Obsidian Excalidraw compressed-json could not be decompressed."
+    );
+  }
+  return decompressed;
+}
+function decompressCompressedJson(value) {
+  const normalized = value.replace(/\s+/g, "");
+  return decompressFromBase64(normalized) ?? decompressFromEncodedURIComponent(normalized) ?? null;
+}
+function decompressFromBase64(value) {
+  return lzString.decompressFromBase64(value);
+}
+function decompressFromEncodedURIComponent(value) {
+  return lzString.decompressFromEncodedURIComponent(value);
+}
+function loadLzString() {
+  const loaded = require2(getLzStringPackageName());
+  const candidate = selectLzStringExports(loaded);
+  if (!candidate) {
+    throw new Error("Invalid lz-string module shape.");
+  }
+  return candidate;
+}
+function selectLzStringExports(value) {
+  if (isLzStringExports(value)) return value;
+  if (!value || typeof value !== "object") return null;
+  const module = value;
+  return isLzStringExports(module.default) ? module.default : null;
+}
+function isLzStringExports(value) {
+  if (!value || typeof value !== "object") return false;
+  const candidate = value;
+  return typeof candidate.decompressFromBase64 === "function" && typeof candidate.decompressFromEncodedURIComponent === "function";
+}
+function getLzStringPackageName() {
+  return "lz-string";
+}
+function extractEmbeddedFiles(markdown) {
+  const section = markdown.match(
+    /## Embedded Files\s*\r?\n([\s\S]*?)(?:\r?\n## |\r?\n%%|$)/i
+  )?.[1];
+  if (!section) return [];
+  return Array.from(
+    section.matchAll(
+      /^([a-f0-9]{40}):\s*\[\[([^\]|#]+)(?:#[^\]|]+)?(?:\|[^\]]+)?\]\]\s*$/gim
+    ),
+    (match) => ({
+      fileId: match[1] ?? "",
+      target: (match[2] ?? "").trim()
+    })
+  ).filter((file) => file.fileId && file.target);
+}
+
+// src/render.ts
+import { escapeHtml, escapeHtmlAttribute } from "@riebeckite/core";
+function renderExcalidrawPlaceholder(input) {
+  const style = renderSizeStyle(input.size);
+  const error = input.error ? `<p class="rr-excalidraw__error">${escapeHtml(input.error)}</p>` : "";
+  const payload = input.scene ? renderPayloadScript(input.scene) : "";
+  const state = input.error ? "error" : "pending";
+  const lazy = input.lazy === false ? "false" : "true";
+  return `<figure class="rr-excalidraw" data-excalidraw="${state}" data-excalidraw-lazy="${lazy}"${style}>
+  <div class="rr-excalidraw__canvas" role="img" aria-label="${escapeHtmlAttribute(input.title)}"></div>
+  ${error}
+  ${payload}
+</figure>`;
+}
+function renderPayloadScript(scene) {
+  const payload = {
+    elements: scene.elements,
+    appState: scene.appState ?? {},
+    files: scene.files ?? {}
+  };
+  return `<script type="application/json" class="rr-excalidraw__payload">${escapeScriptJson(JSON.stringify(payload))}</script>`;
+}
+function renderSizeStyle(size) {
+  if (!size?.width && !size?.height) return "";
+  const declarations = [
+    size.width ? `--rr-excalidraw-width:${size.width}px` : null,
+    size.height ? `--rr-excalidraw-height:${size.height}px` : null
+  ].filter(Boolean);
+  return ` style="${declarations.join(";")}"`;
+}
+function escapeScriptJson(value) {
+  return value.replace(/</g, "\\u003c").replace(/>/g, "\\u003e").replace(/&/g, "\\u0026");
+}
+
+// index.ts
+var PLUGIN_NAME = "excalidraw";
+function excalidraw(options = {}) {
+  return definePlugin({
+    name: PLUGIN_NAME,
+    order: -21,
+    options,
+    extendMarkdownPipeline: (pipeline, context) => {
+      pipeline.use(remarkExcalidrawMarkdownEmbed, {
+        contentIndex: context.contentIndex,
+        contentSource: context.contentSource,
+        options
+      });
+    },
+    renderers: [
+      {
+        name: "excalidraw-embed",
+        render: async (context) => renderAttachment(context, options)
+      }
+    ],
+    assets: [createStyleAsset(PLUGIN_NAME)],
+    clientEntries: [createClientEntry(PLUGIN_NAME, "initExcalidraw")]
+  });
+}
+var excalidrawPlugin = excalidraw;
+async function renderAttachment(context, options) {
+  if (context.kind !== "attachment") return null;
+  if (!isExcalidrawPath(context.path)) return null;
+  if (!context.embed) return null;
+  if (!context.contentSource) {
+    return renderExcalidrawPlaceholder({
+      title: getFileName(context.path),
+      error: "Content source is not available."
+    });
+  }
+  try {
+    const raw = await readText(context.contentSource, context.path);
+    if (raw === null) return null;
+    if (!isExcalidrawDocument(context.path, raw)) return null;
+    const parsed = parseExcalidrawScene(raw, context.path);
+    const scene = await mergeEmbeddedFiles({
+      scene: parsed.scene,
+      embeddedFiles: parsed.embeddedFiles,
+      contentSource: context.contentSource,
+      contentIndex: context.contentIndex
+    });
+    return renderExcalidrawPlaceholder({
+      title: getFileName(context.path),
+      scene,
+      size: parseSize(context.label),
+      lazy: options.lazy !== false
+    });
+  } catch (error) {
+    console.error("[plugin-excalidraw] Failed to render Excalidraw", {
+      path: context.path,
+      error
+    });
+    return renderExcalidrawPlaceholder({
+      title: getFileName(context.path),
+      error: "Excalidraw could not be rendered."
+    });
+  }
+}
+function isExcalidrawPath(filePath) {
+  const lowerPath = filePath.toLowerCase();
+  return lowerPath.endsWith(".excalidraw") || lowerPath.endsWith(".excalidraw.md") || lowerPath.endsWith(".md");
+}
+function isExcalidrawDocument(filePath, raw) {
+  const lowerPath = filePath.toLowerCase();
+  if (lowerPath.endsWith(".excalidraw")) return true;
+  if (lowerPath.endsWith(".excalidraw.md")) return true;
+  return lowerPath.endsWith(".md") && isObsidianExcalidrawMarkdown(raw);
+}
+function parseSize(label) {
+  const value = label.trim();
+  if (/^\d{1,5}$/.test(value)) return { width: Number(value) };
+  const match = value.match(/^(\d{1,5})x(\d{1,5})$/i);
+  if (!match?.[1] || !match[2]) return void 0;
+  return { width: Number(match[1]), height: Number(match[2]) };
+}
+function resolveMarkdownTarget(rawTarget, contentIndex) {
+  const target = rawTarget.toLowerCase();
+  const targetExtension = getPathExtension(target);
+  if (targetExtension && targetExtension !== "md") return null;
+  const indexKey = target.endsWith(".md") ? target.slice(0, -3) : target;
+  const resolved = contentIndex.get(indexKey);
+  if (!resolved) return null;
+  const resolvedExtension = getPathExtension(resolved);
+  if (resolvedExtension && resolvedExtension !== "md") return null;
+  return resolved.toLowerCase().endsWith(".md") ? resolved : `${resolved}.md`;
+}
+function remarkExcalidrawMarkdownEmbed(input) {
+  return async (tree) => {
+    const replacements = [];
+    visit(tree, "text", (node, index, parent) => {
+      if (!parent || index === void 0) return;
+      if (!node.value.includes("![[")) return;
+      replacements.push({ node, index, parent });
+    });
+    for (const replacement of replacements.reverse()) {
+      await replaceExcalidrawMarkdownEmbeds(replacement, input);
+    }
+  };
+}
+async function replaceExcalidrawMarkdownEmbeds(replacement, input) {
+  const nodes = [];
+  const wikilinkRe = /!\[\[([^\]|#]+)(?:#[^\]|]+)?(?:\|([^\]]+))?\]\]/g;
+  let lastIndex = 0;
+  for (let match = wikilinkRe.exec(replacement.node.value); match !== null; match = wikilinkRe.exec(replacement.node.value)) {
+    const full = match[0];
+    const rawTarget = match[1]?.trim() ?? "";
+    const label = match[2]?.trim() ?? rawTarget;
+    const start = match.index;
+    const resolved = resolveMarkdownTarget(rawTarget, input.contentIndex);
+    const html = resolved ? await renderExcalidrawMarkdownEmbed({
+      path: resolved,
+      label,
+      contentIndex: input.contentIndex,
+      contentSource: input.contentSource,
+      options: input.options
+    }) : null;
+    if (!html) continue;
+    if (start > lastIndex) {
+      nodes.push({
+        type: "text",
+        value: replacement.node.value.slice(lastIndex, start)
+      });
+    }
+    nodes.push({ type: "html", value: html });
+    lastIndex = start + full.length;
+  }
+  if (lastIndex === 0) return;
+  if (lastIndex < replacement.node.value.length) {
+    nodes.push({
+      type: "text",
+      value: replacement.node.value.slice(lastIndex)
+    });
+  }
+  replacement.parent.children.splice(replacement.index, 1, ...nodes);
+}
+async function renderExcalidrawMarkdownEmbed(input) {
+  if (!input.contentSource) return null;
+  const raw = await readText(input.contentSource, input.path);
+  if (raw === null) return null;
+  if (!isObsidianExcalidrawMarkdown(raw)) return null;
+  const parsed = parseExcalidrawScene(raw, input.path);
+  const scene = await mergeEmbeddedFiles({
+    scene: parsed.scene,
+    embeddedFiles: parsed.embeddedFiles,
+    contentSource: input.contentSource,
+    contentIndex: input.contentIndex
+  });
+  return renderExcalidrawPlaceholder({
+    title: getFileName(input.path),
+    scene,
+    size: parseSize(input.label),
+    lazy: input.options.lazy !== false
+  });
+}
+async function mergeEmbeddedFiles(input) {
+  const resolvedFiles = await resolveEmbeddedFiles(input);
+  return {
+    ...input.scene,
+    files: {
+      ...input.scene.files ?? {},
+      ...resolvedFiles
+    }
+  };
+}
+async function resolveEmbeddedFiles(input) {
+  const files = {};
+  for (const embeddedFile of input.embeddedFiles) {
+    const assetPath = input.contentIndex.get(embeddedFile.target.toLowerCase());
+    if (!assetPath || !isSupportedImagePath(assetPath)) continue;
+    try {
+      const data = await readContentSourceEntry(input.contentSource, assetPath);
+      if (data === null) continue;
+      const mimeType = getImageMimeType(assetPath);
+      files[embeddedFile.fileId] = {
+        id: embeddedFile.fileId,
+        dataURL: `data:${mimeType};base64,${toBase64(data)}`,
+        mimeType,
+        created: Date.now(),
+        lastRetrieved: Date.now()
+      };
+    } catch (error) {
+      console.error("[plugin-excalidraw] Failed to resolve embedded file", {
+        target: embeddedFile.target,
+        error
+      });
+    }
+  }
+  return files;
+}
+function isSupportedImagePath(filePath) {
+  const extension = getPathExtension(filePath);
+  return IMAGE_EXTENSIONS.includes(extension);
+}
+function getImageMimeType(filePath) {
+  const extension = getPathExtension(filePath);
+  if (extension === "jpg") return "image/jpeg";
+  if (extension === "svg") return "image/svg+xml";
+  return `image/${extension}`;
+}
+function getPathExtension(filePath) {
+  const fileName = getFileName(filePath.toLowerCase());
+  const extensionStart = fileName.lastIndexOf(".");
+  return extensionStart > 0 ? fileName.slice(extensionStart + 1) : "";
+}
+async function readText(source, logicalPath) {
+  const content = await readContentSourceEntry(source, logicalPath);
+  if (content === null) return null;
+  return typeof content === "string" ? content : new TextDecoder().decode(content);
+}
+function toBase64(content) {
+  const bytes = typeof content === "string" ? new TextEncoder().encode(content) : content;
+  return Buffer.from(bytes).toString("base64");
+}
+function getFileName(contentPath) {
+  return contentPath.split("/").at(-1) ?? contentPath;
+}
+export {
+  excalidraw,
+  excalidrawPlugin
+};

package/dist/src/client_init.d.ts

@@ -0,0 +1 @@
+export declare function initExcalidraw(): void;

package/dist/src/parse.d.ts

@@ -0,0 +1,3 @@
+import type { ParsedExcalidrawDocument } from "./types.js";
+export declare function parseExcalidrawScene(raw: string, _filePath: string): ParsedExcalidrawDocument;
+export declare function isObsidianExcalidrawMarkdown(raw: string): boolean;

package/dist/src/render.d.ts

@@ -0,0 +1,11 @@
+import type { ExcalidrawScene } from "./types.js";
+export declare function renderExcalidrawPlaceholder(input: {
+    title: string;
+    scene?: ExcalidrawScene;
+    size?: {
+        width?: number;
+        height?: number;
+    };
+    lazy?: boolean;
+    error?: string;
+}): string;

package/dist/src/types.d.ts

@@ -0,0 +1,24 @@
+export type ExcalidrawOptions = {
+    lazy?: boolean;
+};
+export type ExcalidrawScene = {
+    type?: string;
+    version?: number;
+    source?: string;
+    elements: readonly Record<string, unknown>[];
+    appState?: Record<string, unknown>;
+    files?: Record<string, Record<string, unknown>>;
+};
+export type ObsidianEmbeddedFile = {
+    fileId: string;
+    target: string;
+};
+export type ParsedExcalidrawDocument = {
+    scene: ExcalidrawScene;
+    embeddedFiles: readonly ObsidianEmbeddedFile[];
+};
+export type ExcalidrawPayload = {
+    elements: readonly Record<string, unknown>[];
+    appState: Record<string, unknown>;
+    files: Record<string, Record<string, unknown>>;
+};

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@riebeckite/plugin-excalidraw",
+  "version": "0.0.1",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "source": "./index.ts",
+      "default": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js",
+      "source": "./client.ts",
+      "default": "./dist/client.js"
+    },
+    "./style.css": "./style.css"
+  },
+  "dependencies": {
+    "@excalidraw/excalidraw": "^0.18.0",
+    "lz-string": "^1.5.0",
+    "unist-util-visit": "^5.0.0",
+    "@riebeckite/core": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/mdast": "^4.0.4"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "README_ja.md",
+    "dist",
+    "style.css"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rerurate514/riebeckite.git",
+    "directory": "packages/plugins/excalidraw"
+  },
+  "homepage": "https://github.com/Rerurate514/riebeckite#readme",
+  "bugs": {
+    "url": "https://github.com/Rerurate514/riebeckite/issues"
+  },
+  "description": "Excalidraw attachment rendering for Obsidian wikilinks.",
+  "keywords": [
+    "riebeckite",
+    "plugin",
+    "excalidraw",
+    "obsidian"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "sideEffects": [
+    "./style.css"
+  ],
+  "scripts": {
+    "build": "node ../../../scripts/build_package.mjs"
+  }
+}

package/style.css

@@ -0,0 +1,50 @@
+.rr-excalidraw {
+  --rr-excalidraw-paper: var(--rb-color-paper, #ffffff);
+  --rr-excalidraw-ink: var(--rb-color-ink, #000000);
+  --rr-excalidraw-muted: var(--rb-color-muted, #69645c);
+  --rr-excalidraw-rule: var(
+    --rb-color-border,
+    color-mix(in srgb, var(--rr-excalidraw-ink) 18%, transparent)
+  );
+  box-sizing: border-box;
+  width: min(100%, var(--rr-excalidraw-width, 100%));
+  max-width: 100%;
+  margin: 2rem 0;
+  border: 1px solid var(--rr-excalidraw-rule);
+  background: var(--rr-excalidraw-paper);
+  color: var(--rr-excalidraw-ink);
+}
+
+.rr-excalidraw__canvas {
+  display: grid;
+  min-height: min(var(--rr-excalidraw-height, 18rem), 70vh);
+  overflow: auto;
+  place-items: center;
+  padding: 1rem;
+}
+
+.rr-excalidraw__canvas > svg {
+  display: block;
+  width: 100%;
+  max-width: 100%;
+  height: var(--rr-excalidraw-height, auto);
+}
+
+.rr-excalidraw__error {
+  margin: 0;
+  padding: 0 1rem 1rem;
+  color: var(--rr-excalidraw-muted);
+  font-size: 0.875rem;
+}
+
+.rr-excalidraw[data-excalidraw="pending"] .rr-excalidraw__canvas:empty::before,
+.rr-excalidraw[data-excalidraw="error"] .rr-excalidraw__canvas:empty::before {
+  content: "Drawing could not be rendered.";
+  color: var(--rr-excalidraw-muted);
+}
+
+html[data-theme="dark"] .rr-excalidraw,
+html.dark .rr-excalidraw {
+  --rr-excalidraw-paper: var(--rb-color-ink, #000000);
+  --rr-excalidraw-ink: var(--rb-color-paper, #ffffff);
+}