@silverbulletmd/silverbullet 2.10.0 → 2.11.0

package/client/plugos/plug_compile.ts

@@ -24,7 +24,6 @@ const workerRuntimePlugin: esbuild.Plugin = {
   name: "worker-runtime",
   setup(build) {
     if (typeof __EMBEDDED_WORKER_RUNTIME_JS__ !== "undefined") {
-      // Bundled CLI: serve pre-bundled JS from the embedded constant
       build.onResolve({ filter: /^worker-runtime$/ }, () => ({
         path: "worker-runtime",
         namespace: "worker-runtime",
@@ -34,7 +33,6 @@ const workerRuntimePlugin: esbuild.Plugin = {
         loader: "js",
       }));
     } else {
-      // From source: point directly at the .ts file, esbuild handles it
       build.onResolve({ filter: /^worker-runtime$/ }, () => ({
         path: path.join(import.meta.dirname, "worker_runtime.ts"),
       }));
@@ -70,14 +68,12 @@ export async function compileManifest(
     delete manifest.build;
   }
 
-  // Assets
   const assetsBundle = await bundleAssets(
     path.resolve(rootPath),
     (manifest.assets as string[]) || [],
   );
   manifest.assets = assetsBundle.toJSON();
 
-  // Normalize the edge case of a plug with no functions
   if (!manifest.functions) {
     manifest.functions = {};
   }
@@ -92,13 +88,11 @@ ${Object.entries(manifest.functions)
       return "";
     }
     let [filePath, jsFunctionName] = def.path.split(":");
-    // Resolve path
     filePath = path.join(rootPath, filePath);
 
-    return `import {${jsFunctionName} as ${funcName}} from "${
-      // Replacing \ with / for Windows
-      path.resolve(filePath).replaceAll("\\", "\\\\")
-    }";\n`;
+    return `import {${jsFunctionName} as ${funcName}} from "${path
+      .resolve(filePath)
+      .replaceAll("\\", "\\\\")}";\n`;
   })
   .join("")}
 
@@ -122,8 +116,6 @@ export const plug = {manifest, functionMapping};
 setupMessageListener(functionMapping, manifest, self.postMessage);
 `;
 
-  // console.log("Code:", jsFile);
-
   const tempDir = await mkdtemp(path.join(tmpdir(), "plug-compile-"));
   const inFile = path.join(tempDir, "input.js");
   const outFile = `${destPath}/${manifest.name}.plug.js`;
@@ -152,7 +144,6 @@ setupMessageListener(functionMapping, manifest, self.postMessage);
   jsCode = patchBundledJS(jsCode);
   await writeFile(outFile, jsCode, "utf-8");
 
-  // Clean up temp directory
   await rm(tempDir, { recursive: true, force: true });
 
   console.log(`Plug ${manifest.name} written to ${outFile}.`);
@@ -175,7 +166,6 @@ export async function compileManifests(
     building = true;
     await mkdir(dist, { recursive: true });
     const startTime = Date.now();
-    // Build all plugs in parallel
     await Promise.all(
       manifestFiles.map(async (plugManifestPath) => {
         const manifestPath = plugManifestPath as string;

package/client/plugos/sandboxes/worker_sandbox.ts

@@ -7,7 +7,6 @@ import { race, timeout } from "@silverbulletmd/silverbullet/lib/async";
 import { fsEndpoint } from "../../spaces/constants.ts";
 
 /**
- * Represents a "safe" execution environment for plug code
  * Effectively this wraps a web worker, the reason to have this split from Plugs is to allow plugs to manage multiple sandboxes, e.g. for performance in the future
  */
 export class WorkerSandbox<HookT> implements Sandbox<HookT> {
@@ -25,7 +24,6 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
     private workerOptions = {},
   ) {}
 
-  /** Factory producing a WorkerSandbox for a plug file at a local space path. */
   static forPath<HookT>(path: string): SandboxFactory<HookT> {
     return (plug) =>
       new WorkerSandbox(
@@ -40,7 +38,6 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
   init(): Promise<void> {
     console.log("Booting up worker from", this.workerUrl.pathname);
     if (this.worker) {
-      // Race condition
       console.warn("Double init of sandbox, ignoring");
       return Promise.resolve();
     }
@@ -54,14 +51,12 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
       timeout(5000).catch((_) =>
         Promise.reject(new Error("Plug timed out during creation")),
       ),
-      new Promise((resolve) => {
+      new Promise<void>((resolve) => {
         this.worker!.onmessage = (ev) => {
           if (ev.data.type === "manifest") {
             this.manifest = ev.data.manifest;
-            // Set manifest in the plug
             this.plug.manifest = this.manifest!;
 
-            // Set assets in the plug
             this.plug.assets = new AssetBundle(
               this.manifest?.assets ? (this.manifest.assets as AssetJson) : {},
             );
@@ -72,7 +67,15 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
           void this.onMessage(ev.data);
         };
       }),
-    ]);
+    ]).catch((e) => {
+      // A worker that failed to come up must not linger: its script fetch may
+      // still be in flight (e.g. on a slow link), and a late boot would
+      // resolve into a sandbox the system already gave up on. Terminating it
+      // also lets a retry start from a clean slate.
+      this.worker?.terminate();
+      this.worker = undefined;
+      throw e;
+    });
   }
 
   async onMessage(data: ControllerMessage) {
@@ -92,7 +95,6 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
               result: result,
             } as WorkerMessage);
         } catch (e: any) {
-          // console.error("Syscall fail", e);
           this.worker &&
             this.worker!.postMessage({
               type: "sysr",
@@ -118,7 +120,6 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
 
   async invoke(name: string, args: any[]): Promise<any> {
     if (!this.worker) {
-      // Lazy initialization
       await this.init();
     }
     this.reqId++;
@@ -138,5 +139,14 @@ export class WorkerSandbox<HookT> implements Sandbox<HookT> {
       this.worker.terminate();
       this.worker = undefined;
     }
+    // A terminated worker will never post the `invr` that would otherwise
+    // settle these.
+    if (this.outstandingInvocations.size > 0) {
+      const error = new Error("Plug sandbox stopped");
+      for (const { reject } of this.outstandingInvocations.values()) {
+        reject(error);
+      }
+      this.outstandingInvocations.clear();
+    }
   }
 }

package/client/plugos/syscalls/editor.ts

@@ -1,3 +1,4 @@
+import { copyToClipboard } from "../../clipboard.ts";
 import {
   acceptCompletion,
   closeCompletion,
@@ -72,6 +73,7 @@ import type {
   FilterOption,
   NotificationAction,
   NotificationType,
+  PanelMode,
   UploadFile,
 } from "@silverbulletmd/silverbullet/type/client";
 import type { VimConfig } from "@silverbulletmd/silverbullet/type/config";
@@ -79,6 +81,9 @@ import type { PageMeta } from "@silverbulletmd/silverbullet/type/index";
 import { updateBakedSections } from "../../baked_sections/bake.ts";
 import type { Client } from "../../client.ts";
 import { refreshLintEffect } from "../../codemirror/lint.ts";
+import { isMobileDevice, isNarrowScreen } from "../../lib/mobile.ts";
+import { hide as hideNavigatorSlot } from "../../navigator/navigator.ts";
+import type { PanelSlot } from "../../types/ui.ts";
 import { getVimModule } from "../../vim_loader.ts";
 import type { SysCallMapping } from "../system.ts";
 
@@ -137,6 +142,40 @@ export function editorSyscalls(client: Client): SysCallMapping {
         "Returns page metadata ordered from most to least recently opened.",
       returns: [{ type: "PageMeta[]", description: "Recently opened pages." }],
     },
+    "editor.getLastOpenedMap": {
+      callback: (): Record<string, number> => {
+        const out: Record<string, number> = {};
+        for (const pageMeta of client.ui.viewState.allPages) {
+          if (pageMeta.lastOpened) out[pageMeta.name] = pageMeta.lastOpened;
+        }
+        return out;
+      },
+      description: `Returns a map of page name to the time it was last opened (epoch milliseconds), for the pages that have ever been opened on this client. This lives outside the object index.`,
+      returns: [
+        {
+          type: "Record<string, number>",
+          description: "Page name to last-opened timestamp.",
+        },
+      ],
+    },
+    "editor.getViewableExtensions": {
+      callback: (): string[] => {
+        return [
+          ...new Set(
+            Array.from(
+              client.clientSystem.documentEditorHook.documentEditors.values(),
+            ).flatMap(({ extensions }) => extensions),
+          ),
+        ];
+      },
+      description: `Returns the file extensions that have a document editor registered, i.e. the documents this client can actually open. Extensions carry no leading dot. Which editors are loaded depends on the plugs installed, so this is a property of the client rather than of the space.`,
+      returns: [
+        {
+          type: "string[]",
+          description: "Extensions with a registered document editor.",
+        },
+      ],
+    },
     "editor.getText": {
       callback: () => {
         return client.editorView.state.sliceDoc();
@@ -353,9 +392,6 @@ export function editorSyscalls(client: Client): SysCallMapping {
         },
       ],
     },
-    // Re-evaluate every baked section on the current page and rewrite each body
-    // with its latest output (same as the "Baked Sections: Update" command),
-    // exposed for programmatic use.
     "editor.updateBakedSections": {
       callback: (): Promise<void> => {
         return updateBakedSections(client);
@@ -594,13 +630,20 @@ export function editorSyscalls(client: Client): SysCallMapping {
       ],
     },
     "editor.showPanel": {
-      callback: (
+      callback: async (
         _ctx,
         id: string,
-        mode: number,
+        mode: PanelMode,
         html: HTMLElement | HTMLElement[] | string,
         script: string,
       ) => {
+        // The other half of the shared-slot arbitration in editor_ui.tsx: a
+        // plug opening one of these slots closes the navigator's occupant.
+        if (id === "modal" || id === "bhs") {
+          await hideNavigatorSlot(id, undefined, {
+            restoreDisplaced: false,
+          });
+        }
         client.ui.viewDispatch({
           type: "show-panel",
           id: id as any,
@@ -620,7 +663,7 @@ export function editorSyscalls(client: Client): SysCallMapping {
         },
         {
           name: "mode",
-          type: "number",
+          type: "number | string",
           description: "The panel display mode or size.",
         },
         {
@@ -641,8 +684,33 @@ export function editorSyscalls(client: Client): SysCallMapping {
       },
       description: "Returns focus to the main editor.",
     },
+    "editor.getFocusedPanelSlot": {
+      callback: (): PanelSlot | undefined => {
+        const active = document.activeElement;
+        if (!(active instanceof HTMLIFrameElement)) return undefined;
+        const slot = active.dataset.slot;
+        return slot === "lhs" ||
+          slot === "rhs" ||
+          slot === "bhs" ||
+          slot === "modal"
+          ? slot
+          : undefined;
+      },
+      description:
+        "Returns the slot of the panel (keyed or legacy) whose iframe currently holds focus, or undefined if none does.",
+      returns: [
+        {
+          type: '"lhs" | "rhs" | "bhs" | "modal" | undefined',
+          description:
+            "The focused panel's slot, or undefined if no panel iframe has focus.",
+        },
+      ],
+    },
     "editor.hidePanel": {
-      callback: (_ctx, id: string) => {
+      callback: async (_ctx, id: string) => {
+        // The navigator owns this slot whenever it is the thing showing
+        // there, so "hide the panel at this location" has to reach it too.
+        await hideNavigatorSlot(id);
         client.ui.viewDispatch({
           type: "hide-panel",
           id: id as any,
@@ -664,14 +732,19 @@ export function editorSyscalls(client: Client): SysCallMapping {
     "editor.showProgress": {
       callback: (
         _ctx,
+        progressType: "sync" | "index",
         progressPercentage?: number,
-        progressType?: "sync" | "index",
       ) => {
-        client.ui.showProgress(progressPercentage, progressType);
+        client.ui.showProgress(progressType, progressPercentage);
       },
       description:
         "Shows, updates, or hides a sync or indexing progress indicator.",
       parameters: [
+        {
+          name: "progressType",
+          type: "sync | index",
+          description: "The operation represented by the indicator.",
+        },
         {
           name: "progressPercentage",
           type: "number",
@@ -679,12 +752,6 @@ export function editorSyscalls(client: Client): SysCallMapping {
             "Completion percentage, or undefined to hide the indicator.",
           optional: true,
         },
-        {
-          name: "progressType",
-          type: "sync | index",
-          description: "The operation represented by the indicator.",
-          optional: true,
-        },
       ],
     },
     "editor.insertAtPos": {
@@ -828,11 +895,8 @@ export function editorSyscalls(client: Client): SysCallMapping {
     },
     "editor.moveCursorToLine": {
       callback: (_ctx, line: number, column = 1, center = false) => {
-        // CodeMirror already keeps information about lines
         const cmLine = client.editorView.state.doc.line(line);
-        // How much to move inside the line, column number starts from 1
         const offset = Math.max(0, Math.min(cmLine.length, column - 1));
-        // Just reuse the implementation above
         const moveCursor = syscalls["editor.moveCursor"];
         const moveCursorCallback =
           typeof moveCursor === "function" ? moveCursor : moveCursor.callback;
@@ -1068,44 +1132,30 @@ export function editorSyscalls(client: Client): SysCallMapping {
           throw new Error("Vim module not loaded.");
         }
         const { Vim } = vimMod;
-        // Override the default "o" binding to be more intelligent and follow the markdown editor's behavior
         Vim.mapCommand("o", "action", "newline-continue-markup", {}, {});
         Vim.mapCommand("O", "action", "back-newline-continue-markup", {}, {});
         Vim.unmap("<C-q>", undefined as any);
         Vim.defineAction("newline-continue-markup", (cm) => {
-          // Append at end of line
           Vim.handleKey(cm, "A", "+input");
-          // Insert newline continuing markup where appropriate
           insertNewlineContinueMarkup(client.editorView) ||
             insertNewlineAndIndent(client.editorView);
         });
         Vim.defineAction("back-newline-continue-markup", (cm) => {
-          // Determine current line
           const pos = client.editorView.state.selection.main.from;
           const line = client.editorView.state.doc.lineAt(pos).number;
           if (line === 1) {
-            // We're on the top line
-            // Go to 0:0
             Vim.handleKey(cm, "0", "+input");
-            // Insert a newline
             insertNewline(client.editorView);
-            // Go up to the new line
             Vim.handleKey(cm, "k", "+input");
-            // Into insert mode
             Vim.handleKey(cm, "i", "+input");
           } else {
-            // We're elsewhere in the document
-            // Go up
             Vim.handleKey(cm, "k", "+input");
-            // Append mode at the end of the line
             Vim.handleKey(cm, "A", "+input");
-            // Insert a newline using the continue markup thing
             insertNewlineContinueMarkup(client.editorView) ||
               insertNewlineAndIndent(client.editorView);
           }
         });
 
-        // Load the config if any
         const config = client.config.get<VimConfig>("vim", {});
         if (config) {
           config.unmap?.forEach((binding) => {
@@ -1143,9 +1193,9 @@ export function editorSyscalls(client: Client): SysCallMapping {
     },
     "editor.openPageNavigator": {
       callback: (_ctx, mode: "page" | "meta" | "document" | "all" = "page") => {
-        client.startPageNavigate(mode);
+        void client.startPageNavigate(mode);
       },
-      description: "Opens the page navigator in the requested browsing mode.",
+      description: `Opens the page picker in the requested browsing mode. Each mode maps to a segment of the \`std.pages\` navigator view.`,
       parameters: [
         {
           name: "mode",
@@ -1161,6 +1211,30 @@ export function editorSyscalls(client: Client): SysCallMapping {
       },
       description: "Opens the command palette.",
     },
+    "editor.openNavigator": {
+      callback: (
+        _ctx,
+        name: string,
+        opts?: {
+          segment?: string;
+          phrase?: string;
+          dropdown?: unknown;
+          focus?: boolean;
+        },
+      ) => client.openNavigatorView(name, opts),
+      description: `Opens a navigator view, returning whether it opened. False means the view isn't there to open -- typically because it's defined in Space Lua that hasn't been indexed yet -- so a caller can fall back to something else.`,
+      parameters: [
+        { name: "name", type: "string", description: "The view's name." },
+        {
+          name: "opts",
+          type: "table",
+          description:
+            "Optional `segment` (segment label), `phrase`, `dropdown` (dropdown value to select), and `focus` (`false` opens without taking focus).",
+          optional: true,
+        },
+      ],
+      returns: [{ type: "boolean", description: "Whether a view opened." }],
+    },
     "editor.deleteLine": {
       callback: () => {
         deleteLine(client.editorView);
@@ -1222,7 +1296,6 @@ export function editorSyscalls(client: Client): SysCallMapping {
       },
       description: "Moves the current line or selected lines downward.",
     },
-    // Folding
     "editor.fold": {
       callback: () => {
         foldCode(client.editorView);
@@ -1265,7 +1338,6 @@ export function editorSyscalls(client: Client): SysCallMapping {
       },
       description: "Redoes the most recently undone editor change.",
     },
-    // Cursor motion syscalls
     "editor.cursorCharLeft": {
       callback: () => cursorCharLeft(client.editorView),
       description:
@@ -1310,7 +1382,6 @@ export function editorSyscalls(client: Client): SysCallMapping {
       callback: () => cursorDocEnd(client.editorView),
       description: "Moves the cursor to the end of the document.",
     },
-    // Cursor motions that also navigate the completion popup if it's open
     "editor.cursorLineUp": {
       callback: () => {
         const view = client.editorView;
@@ -1347,7 +1418,6 @@ export function editorSyscalls(client: Client): SysCallMapping {
       description:
         "Moves completion selection down one page when open, otherwise moves the cursor down one viewport page.",
     },
-    // Selection-extending motions
     "editor.selectCharLeft": {
       callback: () => selectCharLeft(client.editorView),
       description:
@@ -1411,7 +1481,6 @@ export function editorSyscalls(client: Client): SysCallMapping {
       callback: () => selectPageDown(client.editorView),
       description: "Extends the selection downward by one viewport page.",
     },
-    // Delete
     "editor.deleteCharBackward": {
       callback: () => deleteCharBackward(client.editorView),
       description: "Deletes the selection or the character before the cursor.",
@@ -1444,7 +1513,6 @@ export function editorSyscalls(client: Client): SysCallMapping {
       callback: () => transposeChars(client.editorView),
       description: "Transposes the characters around the cursor.",
     },
-    // Enter: accept completion if popup is open, else newline-and-indent
     "editor.insertNewline": {
       callback: () => {
         const view = client.editorView;
@@ -1454,7 +1522,6 @@ export function editorSyscalls(client: Client): SysCallMapping {
       description:
         "Accepts the active completion, or inserts a newline with appropriate indentation.",
     },
-    // Completion popup control
     "editor.acceptCompletion": {
       callback: () => acceptCompletion(client.editorView),
       description:
@@ -1483,20 +1550,14 @@ export function editorSyscalls(client: Client): SysCallMapping {
     "editor.copyToClipboard": {
       callback: async (_ctx, data: string | Blob) => {
         try {
-          if (typeof data === "string") {
-            await navigator.clipboard.writeText(data);
-          } else {
-            await navigator.clipboard.write([
-              new ClipboardItem({ [data.type]: data }),
-            ]);
-          }
+          await copyToClipboard(data);
         } catch (e) {
           console.error(e);
           client.ui.flashNotification(`Could not copy to clipboard: ${e}`);
         }
       },
       description:
-        "Copies text or binary Blob data to the system clipboard. Clipboard access requires a secure HTTPS context.",
+        "Copies text or binary Blob data to the system clipboard. Binary clipboard access requires HTTPS or localhost; text copying also works over HTTP when supported by the browser.",
       parameters: [
         {
           name: "data",
@@ -1529,10 +1590,7 @@ export function editorSyscalls(client: Client): SysCallMapping {
     },
 
     "editor.isMobile": {
-      callback: () => {
-        const mouseDetected = globalThis.matchMedia("(pointer:fine)").matches;
-        return !mouseDetected;
-      },
+      callback: () => isMobileDevice(),
       description:
         "Checks whether the current device lacks a fine pointer and should be treated as mobile.",
       returns: [
@@ -1543,6 +1601,23 @@ export function editorSyscalls(client: Client): SysCallMapping {
         },
       ],
     },
+
+    // Deliberately separate from `editor.isMobile`: that one answers "what
+    // kind of pointer is this", which is the right question for touch
+    // affordances and the wrong one for layout. A narrow window on a desktop
+    // gets the narrow layout with a mouse attached; a tablet in landscape gets
+    // the wide one without.
+    "editor.isNarrowScreen": {
+      callback: () => isNarrowScreen(),
+      description:
+        "Checks whether the client is currently laid out for a narrow screen, i.e. below the breakpoint where sidebar panels become full-width drawers.",
+      returns: [
+        {
+          type: "boolean",
+          description: "Whether the narrow-screen layout is in effect.",
+        },
+      ],
+    },
   };
 
   return syscalls;

package/client/plugos/syscalls/event.ts

@@ -38,11 +38,9 @@ export function eventSyscalls(
      */
     "event.listen": {
       callback: (_ctx, def: EventSubscription) => {
-        // console.log("Registering Lua event listener: ", def.name);
         client.config.insert(
           ["eventListeners", def.name],
           async (...args: any[]) => {
-            // Convert return value to JS
             const val = await def.run(...args);
             return luaValueToJS(val, LuaStackFrame.lostFrame);
           },

package/client/plugos/syscalls/fetch.ts

@@ -22,7 +22,6 @@ export function sandboxFetchSyscalls(client: Client): SysCallMapping {
         options: ProxyFetchRequest = {},
       ): Promise<ProxyFetchResponse> => {
         console.warn("Deprecated: use net.proxyFetch() instead");
-        // JSONify any non-serializable body
         if (
           options?.body &&
           typeof options.body !== "string" &&
@@ -44,7 +43,6 @@ export function sandboxFetchSyscalls(client: Client): SysCallMapping {
           buildProxyUrl(client, url),
           fetchOptions,
         );
-        // Do sensible things with the body based on the content type
         // Read as ArrayBuffer first to safely handle empty responses (e.g.
         // PUT/DELETE returning 204 with Content-Type: application/json).
         // resp.arrayBuffer() never throws on an empty body, whereas
@@ -100,7 +98,6 @@ export function sandboxFetchSyscalls(client: Client): SysCallMapping {
         url: string,
         options?: ProxyFetchRequest64,
       ): Promise<ProxyFetchResponse64> => {
-        // console.log("Got sandbox fetch ", url, op);
         const fetchOptions = options
           ? {
               method: options.method,
@@ -147,7 +144,6 @@ export function sandboxFetchSyscalls(client: Client): SysCallMapping {
 
 function buildProxyUrl(client: Client, url: string) {
   url = url.replace(/^https?:\/\//, "");
-  // Strip off the /.fs and replace with /.proxy
   return (
     client.httpSpacePrimitives.url.slice(0, -fsEndpoint.length) +
     "/.proxy/" +

package/client/plugos/syscalls/icon.ts

@@ -0,0 +1,46 @@
+import { resolveFeatherIcons } from "../../lib/feather_icons.ts";
+import type { SysCallMapping } from "../system.ts";
+
+export function iconSyscalls(): SysCallMapping {
+  return {
+    "icon.feather": {
+      callback: (_ctx, name: string): string | null => {
+        if (!name) return null;
+        return resolveFeatherIcons([name])[name] ?? null;
+      },
+      description:
+        "Renders a Feather icon to SVG markup by name, or nil when the name isn't a Feather icon. The markup carries no color of its own (`currentColor`) and a default 24x24 size, both of which CSS at the injection site can override.",
+      parameters: [
+        {
+          name: "name",
+          type: "string",
+          description: "A Feather icon name, e.g. `trash-2`.",
+        },
+      ],
+      returns: [
+        {
+          type: "string",
+          description: "The icon's SVG markup, or nil when unknown.",
+        },
+      ],
+      examples: [{ code: 'local lock = icon.feather("lock")' }],
+    },
+    "icon.resolveFeather": {
+      callback: (_ctx, names: string[]): Record<string, string> => {
+        return resolveFeatherIcons(names ?? []);
+      },
+      description:
+        "Renders a batch of Feather icons to SVG markup in one round trip, so panels can show icons without bundling the icon set themselves. Unknown names are omitted from the result. The markup carries no color of its own (`currentColor`) and a default 24x24 size, both of which CSS at the injection site can override.",
+      parameters: [
+        {
+          name: "names",
+          type: "table",
+          description: "Feather icon names, e.g. `trash-2`.",
+        },
+      ],
+      returns: [
+        { type: "table", description: "Map of icon name to SVG markup." },
+      ],
+    },
+  };
+}