@riebeckite/plugin-citations 0.0.22 → 0.0.23

package/README.md

@@ -63,6 +63,49 @@ Use `referencesHeading` for localized headings:
 citations({ bibliography: "references.bib", referencesHeading: "参考文献" })
 ```
 
+## Bibliography page
+
+Setting `pagePath` generates a standalone bibliography page. It is opt-in and
+disabled when omitted:
+
+```ts
+citations({ bibliography: "references.bib", pagePath: "/bibliography" })
+```
+
+The page type (`citations-bibliography`) collects references from two sources:
+
+- the plugin's `bibliography` option, resolved from the content root
+- the frontmatter `bibliography` of every discoverable (public) page
+
+Only `manifest.discoverableEntries` contribute frontmatter bibliographies. Pages
+that are draft, unlisted, scheduled, or otherwise non-discoverable are ignored,
+so their bibliographies are never leaked into the page.
+
+Entries from all files are merged in a deterministic order. Identical duplicates
+are dropped silently; when the same key appears with different content, the first
+definition wins and the conflict is reported as `citation-duplicate-key`. Missing
+files and malformed files are reported as `citation-missing-bibliography` and
+`citation-malformed-bibliography`. When no entry is collected, no page is
+generated. If a Markdown page or redirect already owns the path, Markdown wins
+and the page is skipped with a `citations-page-conflict` diagnostic.
+
+The page body provides its own `<main>` and `<h1>`, escapes all entry text, and
+lists entries sorted by key. A `url` or `doi` field becomes a link only when it
+resolves to a safe `http(s)` target. Existing in-page citations and the
+`References` section are unchanged.
+
+Bibliography pages declare a `global` output dependency, so changes to a
+bibliography file, a frontmatter `bibliography`, page visibility, or `pagePath`
+invalidate the affected output.
+
+## Options
+
+| Option | Default | Description |
+| ------ | ------- | ----------- |
+| `bibliography` | unset | Vault-relative BibTeX/BibLaTeX file path or paths |
+| `referencesHeading` | `"References"` | Heading inserted above generated references |
+| `pagePath` | unset | Path of the standalone bibliography page; disabled when omitted |
+
 ## Diagnostics
 
 Reported through Riebeckite diagnostics:

package/README_ja.md

@@ -63,6 +63,35 @@ Riebeckite はこのプラグインより先に `:name` を directive として
 citations({ bibliography: "references.bib", referencesHeading: "参考文献" })
 ```
 
+## 参考文献ページ
+
+`pagePath` を設定すると、参考文献の一覧ページを生成します。既定では無効で、指定しないかぎり生成しません。
+
+```ts
+citations({ bibliography: "references.bib", pagePath: "/bibliography" })
+```
+
+ページタイプ（`citations-bibliography`）は、次の2か所から文献を集めます。
+
+- プラグインの `bibliography` オプション（コンテンツルートからの相対パス）
+- 公開（discoverable）ページの frontmatter `bibliography`
+
+frontmatter の `bibliography` を取り込むのは `manifest.discoverableEntries` だけです。下書き・unlisted・公開予定など、discoverable でないページは無視するため、それらの文献がページへ漏れることはありません。
+
+各ファイルの文献は決定的な順序で統合します。内容まで同じ重複は黙って1件にまとめ、同じキーで内容が異なる場合は先に見つかった定義を採用し、`citation-duplicate-key` として報告します。ファイルが見つからない場合は `citation-missing-bibliography`、解析できない場合は `citation-malformed-bibliography` を報告します。文献が1件も集まらないときはページを生成しません。同じパスを Markdown ページやリダイレクトが既に持っている場合は Markdown を優先し、`citations-page-conflict` を報告してページを生成しません。
+
+ページ本文には専用の `<main>` と `<h1>` を持たせ、文献のテキストはすべてエスケープします。`url` と `doi` は安全な `http(s)` のときだけリンクにします。文献はキー順に並べます。既存の本文中の引用と `References` セクションは変更しません。
+
+参考文献ページは `global` の output dependency を宣言します。文献ファイル、frontmatter の `bibliography`、ページの公開状態、`pagePath` の変更で、影響する出力を無効化します。
+
+## オプション
+
+| 項目 | 既定値 | 説明 |
+| --- | --- | --- |
+| `bibliography` | 未設定 | コンテンツルートからの相対パスで指定する BibTeX / BibLaTeX ファイル |
+| `referencesHeading` | `"References"` | 生成する参考文献の見出し |
+| `pagePath` | 未設定 | 参考文献一覧ページのパス。指定しないときは生成しない |
+
 ## diagnostics
 
 以下を Riebeckite の diagnostics に出力します。

package/dist/index.js

@@ -1,11 +1,14 @@
 // index.ts
 import {
+  createStyleAsset,
   definePlugin,
-  readContentSourceEntry
+  readContentSourceEntry as readContentSourceEntry2
 } from "@riebeckite/core";
 
-// src/remark.ts
-import { visit } from "unist-util-visit";
+// src/page.ts
+import {
+  readContentSourceEntry
+} from "@riebeckite/core";
 
 // src/bibliography.ts
 var SUPPORTED_TYPES = /* @__PURE__ */ new Set(["article", "book", "inproceedings", "misc"]);
@@ -284,7 +287,245 @@ function cleanValue(value) {
   return value.replace(/[{}]/g, "").replace(/\\([&%$#_{}])/g, "$1").trim();
 }
 
+// src/paths.ts
+function pathList(value) {
+  if (typeof value === "string") return [value];
+  if (Array.isArray(value)) {
+    return value.filter((item) => typeof item === "string");
+  }
+  return [];
+}
+function pageRelativeCandidates(path, sourceSlug) {
+  const normalized = normalizeLogicalPath(path);
+  if (!sourceSlug || isAbsoluteLikePath(normalized)) return [normalized];
+  const directory = normalizeLogicalPath(sourceSlug).split("/").slice(0, -1).join("/");
+  if (!directory) return [normalized];
+  const relative = normalizeLogicalPath(`${directory}/${normalized}`);
+  return relative === normalized ? [normalized] : [relative, normalized];
+}
+function isAbsoluteLikePath(path) {
+  return path.startsWith("/") || /^[A-Za-z]:\//.test(path);
+}
+function normalizeLogicalPath(path) {
+  const parts = [];
+  for (const segment of path.replace(/\\/g, "/").split("/")) {
+    if (!segment || segment === ".") continue;
+    if (segment === "..") {
+      if (parts.length > 0 && parts.at(-1) !== "..") parts.pop();
+      else parts.push(segment);
+      continue;
+    }
+    parts.push(segment);
+  }
+  const prefix = path.startsWith("/") ? "/" : "";
+  return `${prefix}${parts.join("/")}`;
+}
+function pushUniqueDiagnostics(target, diagnostics, slug) {
+  for (const diagnostic of diagnostics) {
+    const next = diagnostic.slug ? diagnostic : { ...diagnostic, slug };
+    const signature = diagnosticSignature(next);
+    if (target.some((item) => diagnosticSignature(item) === signature))
+      continue;
+    target.push(next);
+  }
+}
+function diagnosticSignature(diagnostic) {
+  return `${diagnostic.code}:${diagnostic.slug ?? ""}:${diagnostic.filePath ?? ""}:${diagnostic.target ?? ""}:${diagnostic.message}`;
+}
+
+// src/render.ts
+import { escapeHtml, escapeHtmlAttribute } from "@riebeckite/core";
+function renderBibliographyPage(input) {
+  const items = input.entries.map(([key, entry]) => renderItem(key, entry)).join("");
+  return `<main class="rb-citations-page"><h1 class="rb-citations-page__title">${escapeHtml(
+    input.title
+  )}</h1><ol class="rb-citations-page__list">${items}</ol></main>`;
+}
+function renderItem(key, entry) {
+  const fields = entry.fields;
+  const author = fields.author ?? fields.editor;
+  const year = fields.year ?? fields.date;
+  const container = fields.journal ?? fields.booktitle ?? fields.publisher;
+  const parts = [];
+  if (author)
+    parts.push(
+      `<span class="rb-citations-page__author">${escapeHtml(author)}</span>`
+    );
+  if (year)
+    parts.push(
+      `<span class="rb-citations-page__year">${escapeHtml(year)}</span>`
+    );
+  if (fields.title)
+    parts.push(
+      `<span class="rb-citations-page__work">${escapeHtml(fields.title)}</span>`
+    );
+  if (container)
+    parts.push(
+      `<span class="rb-citations-page__container">${escapeHtml(container)}</span>`
+    );
+  if (parts.length === 0)
+    parts.push(
+      `<span class="rb-citations-page__key">${escapeHtml(key)}</span>`
+    );
+  const id = escapeHtmlAttribute(referenceId(key));
+  return `<li class="rb-citations-page__item" id="${id}">${parts.join(
+    " "
+  )}${renderLink(fields)}</li>`;
+}
+function renderLink(fields) {
+  const href = safeExternalUrl(fields.url) ?? safeDoiUrl(fields.doi);
+  if (!href) return "";
+  return ` <a class="rb-citations-page__link" href="${escapeHtmlAttribute(
+    href
+  )}" rel="noopener noreferrer">${escapeHtml(href)}</a>`;
+}
+function safeExternalUrl(value) {
+  if (!value) return null;
+  try {
+    const parsed = new URL(value);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:")
+      return null;
+    return parsed.toString();
+  } catch {
+    return null;
+  }
+}
+function safeDoiUrl(value) {
+  if (!value) return null;
+  const doi = value.trim().replace(/^https?:\/\/(?:dx\.)?doi\.org\//i, "").replace(/^doi:\s*/i, "");
+  if (!/^10\.\d{4,9}\//.test(doi)) return null;
+  return `https://doi.org/${encodeURI(doi)}`;
+}
+function referenceId(key) {
+  const sanitized = key.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
+  return `ref-${sanitized || "key"}`;
+}
+
+// src/page.ts
+var PLUGIN_NAME = "citations";
+var PAGE_TITLE = "Bibliography";
+var EXTENSION = /\.[a-zA-Z0-9]+$/;
+async function listBibliographyPagePaths(source, options) {
+  const pagePath = bibliographyPagePath(options.pagePath);
+  if (!pagePath) return [];
+  if (isContentRoute(source.manifest, pagePath)) {
+    source.diagnostics.push({
+      code: "citations-page-conflict",
+      severity: "warning",
+      pluginName: PLUGIN_NAME,
+      message: `Skipping bibliography page ${pagePath}: a content route already owns it.`,
+      target: pagePath
+    });
+    return [];
+  }
+  const entries = await collectBibliographyEntries(source, options);
+  return entries.size > 0 ? [pagePath] : [];
+}
+async function resolveBibliographyPage(context, options) {
+  const pagePath = bibliographyPagePath(options.pagePath);
+  if (!pagePath || pagePath !== context.pathname) return null;
+  if (isContentRoute(context.manifest, context.pathname)) return null;
+  const entries = await collectBibliographyEntries(context, options);
+  if (entries.size === 0) return null;
+  const sorted = [...entries.entries()].toSorted(
+    (a, b) => a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0
+  );
+  return {
+    type: "citations-bibliography",
+    pathname: context.pathname,
+    title: PAGE_TITLE,
+    body: renderBibliographyPage({ title: PAGE_TITLE, entries: sorted })
+  };
+}
+function bibliographyPagePath(value) {
+  if (typeof value !== "string") return null;
+  const segments = normalizeLogicalPath(value).replace(/^\/+/, "").split("/").filter(Boolean);
+  if (segments.length === 0) return null;
+  if (EXTENSION.test(segments[segments.length - 1] ?? "")) return null;
+  return `/${segments.join("/")}`;
+}
+function isContentRoute(manifest, pathname) {
+  return manifest.byRoutablePermalink.has(pathname) || manifest.publicRedirects.has(pathname);
+}
+function collectBibliographyGroups(manifest, options) {
+  const groups = [];
+  for (const path of pathList(options.bibliography)) {
+    groups.push([path]);
+  }
+  const frontmatterEntries = manifest.discoverableEntries.filter((entry) => entry.frontmatter.bibliography !== void 0).toSorted((a, b) => a.slug < b.slug ? -1 : a.slug > b.slug ? 1 : 0);
+  for (const entry of frontmatterEntries) {
+    for (const path of pathList(entry.frontmatter.bibliography)) {
+      groups.push([...pageRelativeCandidates(path, entry.slug)]);
+    }
+  }
+  return groups;
+}
+async function collectBibliographyEntries(source, options) {
+  const groups = collectBibliographyGroups(source.manifest, options);
+  const entries = /* @__PURE__ */ new Map();
+  const loaded = /* @__PURE__ */ new Set();
+  const collected = [];
+  for (const candidates of groups) {
+    const resolved = await loadFirstAvailable(source.contentSource, candidates);
+    if (!resolved) {
+      collected.push({
+        code: "citation-missing-bibliography",
+        severity: "error",
+        message: `Bibliography file was not found: ${candidates[0] ?? ""}`,
+        filePath: candidates[0]
+      });
+      continue;
+    }
+    if (loaded.has(resolved.path)) continue;
+    loaded.add(resolved.path);
+    collected.push(...resolved.parsed.diagnostics);
+    mergeEntries(entries, resolved.parsed.entries, resolved.path, collected);
+  }
+  pushUniqueDiagnostics(source.diagnostics, collected, void 0);
+  return entries;
+}
+async function loadFirstAvailable(source, candidates) {
+  if (!source) return null;
+  for (const path of candidates) {
+    const raw = await readContentSourceEntry(source, path);
+    if (raw === null) continue;
+    const text = typeof raw === "string" ? raw : new TextDecoder().decode(raw);
+    return { path, parsed: parseBibliography(text, path) };
+  }
+  return null;
+}
+function mergeEntries(target, incoming, filePath, diagnostics) {
+  for (const [key, entry] of incoming) {
+    const existing = target.get(key);
+    if (!existing) {
+      target.set(key, entry);
+      continue;
+    }
+    if (sameEntry(existing, entry)) continue;
+    diagnostics.push({
+      code: "citation-duplicate-key",
+      severity: "warning",
+      message: `Duplicate bibliography key: ${key}`,
+      filePath,
+      target: key
+    });
+  }
+}
+function sameEntry(a, b) {
+  if (a.type !== b.type) return false;
+  const aKeys = Object.keys(a.fields).toSorted();
+  const bKeys = Object.keys(b.fields).toSorted();
+  if (aKeys.length !== bKeys.length) return false;
+  for (let index = 0; index < aKeys.length; index += 1) {
+    const key = aKeys[index] ?? "";
+    if (key !== bKeys[index]) return false;
+    if (a.fields[key] !== b.fields[key]) return false;
+  }
+  return true;
+}
+
 // src/remark.ts
+import { visit } from "unist-util-visit";
 var BLOCKING_ANCESTORS = /* @__PURE__ */ new Set([
   "link",
   "linkReference",
@@ -376,43 +617,11 @@ function bibliographyPathGroups(options, frontmatter) {
   }
   return pathList(options.bibliography).map((path) => [path]);
 }
-function pathList(value) {
-  if (typeof value === "string") return [value];
-  if (Array.isArray(value)) {
-    return value.filter((item) => typeof item === "string");
-  }
-  return [];
-}
-function pageRelativeCandidates(path, sourceSlug) {
-  const normalized = normalizeLogicalPath(path);
-  if (!sourceSlug || isAbsoluteLikePath(normalized)) return [normalized];
-  const directory = normalizeLogicalPath(sourceSlug).split("/").slice(0, -1).join("/");
-  if (!directory) return [normalized];
-  const relative = normalizeLogicalPath(`${directory}/${normalized}`);
-  return relative === normalized ? [normalized] : [relative, normalized];
-}
-function isAbsoluteLikePath(path) {
-  return path.startsWith("/") || /^[A-Za-z]:\//.test(path);
-}
-function normalizeLogicalPath(path) {
-  const parts = [];
-  for (const segment of path.replace(/\\/g, "/").split("/")) {
-    if (!segment || segment === ".") continue;
-    if (segment === "..") {
-      if (parts.length > 0 && parts.at(-1) !== "..") parts.pop();
-      else parts.push(segment);
-      continue;
-    }
-    parts.push(segment);
-  }
-  const prefix = path.startsWith("/") ? "/" : "";
-  return `${prefix}${parts.join("/")}`;
-}
 async function loadBibliographies(pathGroups, options) {
   const entries = /* @__PURE__ */ new Map();
   const diagnostics = [];
   for (const candidates of pathGroups) {
-    const resolved = await loadFirstAvailable(candidates, options);
+    const resolved = await loadFirstAvailable2(candidates, options);
     if (!resolved) {
       diagnostics.push({
         code: "citation-missing-bibliography",
@@ -440,7 +649,7 @@ async function loadBibliographies(pathGroups, options) {
   pushUniqueDiagnostics(options.diagnostics, diagnostics, options.sourceSlug);
   return { entries, diagnostics };
 }
-async function loadFirstAvailable(candidates, options) {
+async function loadFirstAvailable2(candidates, options) {
   for (const path of candidates) {
     const resolved = await cachedBibliography(path, options);
     if (resolved.found) return { path, parsed: resolved.parsed };
@@ -574,7 +783,7 @@ function renderCitation(references, bracketed, context) {
   });
   return {
     type: "link",
-    url: `#${referenceId(references[0]?.key ?? "unknown", context)}`,
+    url: `#${referenceId2(references[0]?.key ?? "unknown", context)}`,
     title: null,
     children: [{ type: "text", value: label }]
   };
@@ -597,7 +806,7 @@ function numberForReference(reference, context) {
   const number = context.orderedKeys.length + 1;
   context.numbers.set(reference.key, number);
   context.orderedKeys.push(reference.key);
-  referenceId(reference.key, context);
+  referenceId2(reference.key, context);
   if (!context.entries.has(reference.key)) {
     pushUniqueDiagnostics(
       context.options.diagnostics,
@@ -615,7 +824,7 @@ function numberForReference(reference, context) {
   }
   return number;
 }
-function referenceId(key, context) {
+function referenceId2(key, context) {
   const existing = context.referenceIds.get(key);
   if (existing) return existing;
   const sanitized = key.replace(/[^A-Za-z0-9_-]+/g, "-").replace(/^-+|-+$/g, "");
@@ -647,7 +856,7 @@ function createReferencesList(context) {
       (key) => ({
         type: "listItem",
         spread: false,
-        data: { hProperties: { id: referenceId(key, context) } },
+        data: { hProperties: { id: referenceId2(key, context) } },
         children: [
           {
             type: "paragraph",
@@ -671,18 +880,6 @@ function renderBibliographyEntry(entry, key) {
   const container = entry.fields.journal ?? entry.fields.booktitle ?? entry.fields.publisher;
   return [author, year ? `(${year})` : void 0, title, container].filter(Boolean).join(". ");
 }
-function pushUniqueDiagnostics(target, diagnostics, slug) {
-  for (const diagnostic of diagnostics) {
-    const next = diagnostic.slug ? diagnostic : { ...diagnostic, slug };
-    const signature = diagnosticSignature(next);
-    if (target.some((item) => diagnosticSignature(item) === signature))
-      continue;
-    target.push(next);
-  }
-}
-function diagnosticSignature(diagnostic) {
-  return `${diagnostic.code}:${diagnostic.slug ?? ""}:${diagnostic.filePath ?? ""}:${diagnostic.target ?? ""}:${diagnostic.message}`;
-}
 
 // src/state.ts
 function createCitationState() {
@@ -690,11 +887,11 @@ function createCitationState() {
 }
 
 // index.ts
-var PLUGIN_NAME = "citations";
+var PLUGIN_NAME2 = "citations";
 function citations(options = {}) {
   const state = createCitationState();
   return definePlugin({
-    name: PLUGIN_NAME,
+    name: PLUGIN_NAME2,
     processedContentCache: {
       version: "citations-v1",
       dependencyMode: "tracked"
@@ -713,7 +910,7 @@ function citations(options = {}) {
         diagnostics: state.diagnostics,
         loadBibliography: async (path) => {
           if (!context.contentSource) return null;
-          const content = await readContentSourceEntry(
+          const content = await readContentSourceEntry2(
             context.contentSource,
             path
           );
@@ -723,6 +920,32 @@ function citations(options = {}) {
         cache: state.bibliographies
       });
     },
+    pageTypes: [
+      {
+        id: "citations-bibliography",
+        paths: (context) => options.pagePath === void 0 ? [] : listBibliographyPagePaths(
+          {
+            manifest: context.manifest,
+            contentSource: context.contentSource,
+            diagnostics: context.diagnostics
+          },
+          options
+        ),
+        outputDependencies: [{ type: "global" }],
+        resolve: (context) => options.pagePath === void 0 ? null : resolveBibliographyPage(
+          {
+            manifest: context.manifest,
+            contentSource: context.contentSource,
+            diagnostics: context.diagnostics,
+            pathname: context.pathname
+          },
+          options
+        )
+      }
+    ],
+    assets: [
+      createStyleAsset(PLUGIN_NAME2, "@riebeckite/plugin-citations/style.css")
+    ],
     addDiagnostics: () => state.diagnostics
   });
 }
@@ -743,6 +966,9 @@ function validateCitationsOptions(options) {
   if (options.referencesHeading !== void 0 && typeof options.referencesHeading !== "string") {
     issues.push({ path: "referencesHeading", message: "Expected a string." });
   }
+  if (options.pagePath !== void 0 && typeof options.pagePath !== "string") {
+    issues.push({ path: "pagePath", message: "Expected a string." });
+  }
   return issues;
 }
 export {

package/dist/src/page.d.ts

@@ -0,0 +1,11 @@
+import { type ContentManifest, type ContentSource, type Diagnostic, type PluginPage } from "@riebeckite/core";
+import type { CitationsOptions } from "./types.js";
+export type BibliographyPageSource = {
+    readonly manifest: ContentManifest;
+    readonly contentSource?: ContentSource;
+    readonly diagnostics: Diagnostic[];
+};
+export declare function listBibliographyPagePaths(source: BibliographyPageSource, options: CitationsOptions): Promise<string[]>;
+export declare function resolveBibliographyPage(context: BibliographyPageSource & {
+    readonly pathname: string;
+}, options: CitationsOptions): Promise<PluginPage | null>;

package/dist/src/paths.d.ts

@@ -0,0 +1,12 @@
+import type { Diagnostic } from "@riebeckite/core";
+export declare function pathList(value: unknown): readonly string[];
+/**
+ * Frontmatter paths are document-relative first, then content-root relative.
+ * Every candidate still goes through `ContentSource.scan()`, so no candidate can
+ * escape the configured content root.
+ */
+export declare function pageRelativeCandidates(path: string, sourceSlug: string | undefined): readonly string[];
+export declare function isAbsoluteLikePath(path: string): boolean;
+export declare function normalizeLogicalPath(path: string): string;
+export declare function pushUniqueDiagnostics(target: Diagnostic[], diagnostics: readonly Diagnostic[], slug: string | undefined): void;
+export declare function diagnosticSignature(diagnostic: Diagnostic): string;

package/dist/src/render.d.ts

@@ -0,0 +1,6 @@
+import type { BibliographyEntry } from "./types.js";
+export type RenderBibliographyInput = {
+    readonly title: string;
+    readonly entries: readonly (readonly [string, BibliographyEntry])[];
+};
+export declare function renderBibliographyPage(input: RenderBibliographyInput): string;

package/dist/src/types.d.ts

@@ -4,6 +4,7 @@ export type CitationsOptions = {
     bibliography?: string | readonly string[];
     /** Heading inserted above generated references. Defaults to "References". */
     referencesHeading?: string;
+    pagePath?: string;
 };
 export type BibliographyEntry = {
     readonly key: string;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@riebeckite/plugin-citations",
-  "version": "0.0.22",
+  "version": "0.0.23",
   "license": "Apache-2.0",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "dependencies": {
     "@types/mdast": "^4.0.4",
     "unist-util-visit": "^5.1.0",
-    "@riebeckite/core": "0.0.22"
+    "@riebeckite/core": "0.0.23"
   },
   "publishConfig": {
     "access": "public"
@@ -16,7 +16,8 @@
     "LICENSE",
     "README.md",
     "README_ja.md",
-    "dist"
+    "dist",
+    "style.css"
   ],
   "exports": {
     ".": {
@@ -24,7 +25,8 @@
       "import": "./dist/index.js",
       "source": "./index.ts",
       "default": "./dist/index.js"
-    }
+    },
+    "./style.css": "./style.css"
   },
   "repository": {
     "type": "git",
@@ -46,7 +48,9 @@
   "engines": {
     "node": "^20.19.0 || >=22.12.0"
   },
-  "sideEffects": false,
+  "sideEffects": [
+    "./style.css"
+  ],
   "scripts": {
     "build": "node ../../../scripts/build_package.mjs",
     "test": "node --import tsx --test \"test/*.test.ts\""

package/style.css

@@ -0,0 +1,28 @@
+.rb-citations-page {
+  width: min(100%, 48rem);
+  margin-inline: auto;
+  padding-inline: var(--rb-space-2, 1rem);
+}
+
+.rb-citations-page__title {
+  margin-block-end: var(--rb-space-2, 1rem);
+}
+
+.rb-citations-page__list {
+  display: grid;
+  gap: var(--rb-space-1, 0.5rem);
+  padding-inline-start: var(--rb-space-2, 1rem);
+}
+
+.rb-citations-page__item {
+  line-height: 1.6;
+}
+
+.rb-citations-page__year,
+.rb-citations-page__container {
+  opacity: 0.75;
+}
+
+.rb-citations-page__link {
+  overflow-wrap: anywhere;
+}