@ameyanagi/reshiki 0.0.0-stage → 0.12.0

package/package.json

@@ -1,6 +1,51 @@
 {
   "name": "@ameyanagi/reshiki",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.12.0",
+  "description": "ReShiki in the browser: the drawing editor and structure conversion in WebAssembly",
+  "homepage": "https://github.com/Ameyanagi/ReShiki/tree/main/packages/editor#readme",
+  "bugs": "https://github.com/Ameyanagi/ReShiki/issues",
+  "license": "MIT OR Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ameyanagi/ReShiki.git",
+    "directory": "packages/editor"
+  },
+  "files": [
+    "src",
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": [
+    "./src/element.js"
+  ],
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "default": "./src/index.js"
+    },
+    "./editor": {
+      "types": "./src/editor.d.ts",
+      "default": "./src/editor.js"
+    },
+    "./element": {
+      "types": "./src/element.d.ts",
+      "default": "./src/element.js"
+    },
+    "./embed": {
+      "types": "./src/embed.d.ts",
+      "default": "./src/embed.js"
+    },
+    "./frame.html": "./src/frame.html",
+    "./reshiki_web_bg.wasm": "./dist/wasm/reshiki_web_bg.wasm",
+    "./reshiki_bg.wasm": "./dist/editor/reshiki_bg.wasm"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "../../scripts/build_wasm.sh",
+    "test": "bun test",
+    "demo": "bun examples/serve.ts"
+  }
+}

package/src/editor.d.ts

@@ -0,0 +1,58 @@
+import type { Input, InputFormat, OutputFormat, BinaryFormat, TextFormat } from "./index.js";
+
+/** Figures as the desktop's Export makes them. */
+export type ImageFormat = "svg" | "png" | "pdf";
+
+export interface MountOptions {
+  /** Where to load the editor's WebAssembly from; next to this package's
+   * `dist/editor/reshiki_bg.wasm` by default. */
+  module?: string | URL | Request | Response | BufferSource | WebAssembly.Module;
+  /** A drawing or structure to open. */
+  data?: Input;
+  /** The format of `data`; `auto` by default. */
+  format?: InputFormat;
+  /** Called after each edit to the drawing in front. */
+  onChange?: () => void;
+  /** TrueType or OpenType fonts (or collections) to draw with, as URLs or
+   * bytes. They load before the editor starts; text whose font lacks a glyph
+   * falls back to them. URLs on another origin need CORS. */
+  fonts?: FontSource[];
+  /** The Japanese (CJK) fallback, loaded the first time a caption needs it
+   * when no other font has its glyphs. The computer's own Japanese font is
+   * used when the page already has Local Font Access permission; otherwise
+   * this URL is downloaded: Noto Sans JP from jsDelivr by default. `false`
+   * loads nothing. */
+  cjkFont?: string | URL | false;
+  /** Called with fonts that could not be loaded; they are logged by default. */
+  onError?: (error: Error) => void;
+}
+
+/** A font's URL, or its bytes. */
+export type FontSource = string | URL | Uint8Array | ArrayBuffer;
+
+export interface Editor {
+  /** Replace the drawing in front. Rejects with the app's message when the
+   * data cannot be read. */
+  load(data: Input, format?: InputFormat): Promise<void>;
+  /** The drawing in front; `rsk` (a native drawing) by default. */
+  save(format: BinaryFormat): Promise<Uint8Array>;
+  save(format?: TextFormat): Promise<string>;
+  save(format: OutputFormat): Promise<string | Uint8Array>;
+  /** The drawing in front as a figure; `svg` by default. */
+  exportImage(format?: "svg"): Promise<string>;
+  exportImage(format: "png" | "pdf"): Promise<Uint8Array>;
+  exportImage(format: ImageFormat): Promise<string | Uint8Array>;
+  /** Call `callback` after each edit; returns a function that stops it. */
+  onChange(callback: () => void): () => void;
+  /** Stop the editor and empty its element. A page cannot mount another
+   * editor afterwards; reload it, or use embed() for several editors. */
+  destroy(): void;
+}
+
+/** Load the editor's WebAssembly; mount() calls it. */
+export function initEditor(module?: MountOptions["module"]): Promise<void>;
+
+/** Start the editor in `element`, which it fills. A page can mount one
+ * editor; a second mount rejects. Data that cannot be read rejects before the
+ * editor starts, so the page can mount again. */
+export function mount(element: HTMLElement, options?: MountOptions): Promise<Editor>;

package/src/editor.js

@@ -0,0 +1,57 @@
+// The interactive editor: the desktop app built for the browser, mounted into
+// a page element. The page and the editor share one thread and one WebAssembly
+// instance, so a page holds one editor; embed.js puts more in iframes.
+import load, * as wasm from "../dist/editor/reshiki.js";
+import { loadFonts } from "./fonts.js";
+
+const BINARY = new Set(["png", "pdf", "cdx"]);
+const FIGURES = new Set(["svg", "png", "pdf"]);
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+let loading;
+
+export function initEditor(module) {
+  loading ??= load(module === undefined ? undefined : { module_or_path: module });
+  return loading.then(() => undefined);
+}
+
+const bytes = (data) => (typeof data === "string" ? encoder.encode(data) : data);
+
+export async function mount(element, options = {}) {
+  await initEditor(options.module);
+  // The drawing is read before the editor starts, so data that cannot be read
+  // rejects here and the page can mount again.
+  const data = options.data === undefined ? undefined : bytes(options.data);
+  const onMissingFont = await loadFonts(wasm, options);
+  await wasm.mount(element, data, options.format ?? "auto", onMissingFont);
+  let listeners = [];
+  const editor = {
+    async load(data, format = "auto") {
+      await wasm.load(bytes(data), format);
+    },
+    async save(format = "rsk") {
+      const output = await wasm.save(format);
+      return BINARY.has(format) ? output : decoder.decode(output);
+    },
+    exportImage(format = "svg") {
+      if (!FIGURES.has(format)) {
+        return Promise.reject(new Error(`Unknown image format ${format}`));
+      }
+      return editor.save(format);
+    },
+    onChange(callback) {
+      listeners = [...listeners, callback];
+      return () => {
+        listeners = listeners.filter((listener) => listener !== callback);
+      };
+    },
+    destroy() {
+      wasm.destroy();
+      listeners = [];
+      element.replaceChildren();
+    },
+  };
+  wasm.onChange(() => listeners.forEach((listener) => listener()));
+  if (options.onChange) editor.onChange(options.onChange);
+  return editor;
+}

package/src/element.d.ts

@@ -0,0 +1,19 @@
+import type { Editor } from "./editor.js";
+
+/** `<reshiki-editor src="…" format="…" fonts="…" cjk-font="…">`, defined by
+ * importing `@ameyanagi/reshiki/element`. `fonts` lists font URLs separated by
+ * spaces; `cjk-font` is the Japanese fallback's URL, or `false` for none.
+ * Fires `ready`, `change`, and `error` for a font that could not load. */
+export class ReshikiEditor extends HTMLElement {
+  /** Resolves once the editor runs. */
+  readonly ready: Promise<Editor>;
+  load: Editor["load"];
+  save: Editor["save"];
+  exportImage: Editor["exportImage"];
+}
+
+declare global {
+  interface HTMLElementTagNameMap {
+    "reshiki-editor": ReshikiEditor;
+  }
+}

package/src/element.js

@@ -0,0 +1,68 @@
+// <reshiki-editor>: the editor as a custom element. Importing this module
+// defines it. The element fills its own box, so give it a size.
+//
+//   <reshiki-editor src="caffeine.mol" format="mol" style="height: 600px">
+//
+// `fonts` lists font URLs separated by spaces, and `cjk-font` is the Japanese
+// fallback's URL, or "false" for none. It fires `ready` once the editor runs,
+// `change` after each edit and `error` for a font that could not load, and has
+// the editor's load, save and exportImage methods.
+import { mount } from "./editor.js";
+
+export class ReshikiEditor extends HTMLElement {
+  #editor;
+
+  connectedCallback() {
+    if (this.#editor) return;
+    if (!this.style.display) this.style.display = "block";
+    this.#editor = this.#start();
+  }
+
+  // A move disconnects and reconnects the element at once; only stop the
+  // editor if it is still out of the page afterwards.
+  disconnectedCallback() {
+    this.#editor
+      ?.then((editor) => {
+        if (!this.isConnected) editor.destroy();
+      })
+      .catch(() => {});
+  }
+
+  async #start() {
+    const src = this.getAttribute("src");
+    const cjkFont = this.getAttribute("cjk-font");
+    const data = src ? new Uint8Array(await (await fetch(src)).arrayBuffer()) : undefined;
+    const editor = await mount(this, {
+      data,
+      format: this.getAttribute("format") ?? "auto",
+      fonts: this.getAttribute("fonts")?.split(/\s+/).filter(Boolean),
+      cjkFont: cjkFont === "false" ? false : (cjkFont ?? undefined),
+      onChange: () => this.dispatchEvent(new Event("change")),
+      onError: (error) =>
+        this.dispatchEvent(new ErrorEvent("error", { error, message: error.message })),
+    });
+    this.dispatchEvent(new Event("ready"));
+    return editor;
+  }
+
+  /** Resolves once the editor runs; rejects if it could not start. */
+  get ready() {
+    return this.#editor ?? Promise.reject(new Error("The element is not in a page"));
+  }
+
+  async load(data, format) {
+    return (await this.ready).load(data, format);
+  }
+
+  async save(format) {
+    return (await this.ready).save(format);
+  }
+
+  async exportImage(format) {
+    return (await this.ready).exportImage(format);
+  }
+}
+
+if (!customElements.get("reshiki-editor")) {
+  customElements.define("reshiki-editor", ReshikiEditor);
+}

package/src/embed.d.ts

@@ -0,0 +1,29 @@
+import type { Editor } from "./editor.js";
+
+export interface EmbedOptions {
+  /** The frame page; this package's `src/frame.html` by default. It must be
+   * served with the package's `src` and `dist` folders beside it. */
+  frameUrl?: string | URL;
+  /** The iframe's accessible title. */
+  title?: string;
+  /** Called after each edit. */
+  onChange?: () => void;
+  /** Font URLs, as for mount(); relative URLs resolve against this page. */
+  fonts?: (string | URL)[];
+  /** The Japanese fallback's URL, or `false` for none, as for mount(). */
+  cjkFont?: string | URL | false;
+  /** Called with fonts that could not be loaded; they are logged by default. */
+  onError?: (error: Error) => void;
+  /** Milliseconds to wait for the frame to start before `ready` and waiting
+   * calls reject; 60000 by default. */
+  timeout?: number;
+}
+
+export interface EmbeddedEditor extends Editor {
+  /** Resolves once the editor in the frame runs. */
+  readonly ready: Promise<void>;
+}
+
+/** Put the editor in an iframe inside `element`, which it fills. Each frame
+ * has its own editor, so a page can embed several. */
+export function embed(element: HTMLElement, options?: EmbedOptions): EmbeddedEditor;

package/src/embed.js

@@ -0,0 +1,83 @@
+// The editor in an iframe, for style isolation or several editors on a page.
+// The frame page (frame.html) runs the editor; this side forwards calls to it
+// with postMessage and returns the same editor handle as mount().
+const FRAME = new URL("./frame.html", import.meta.url);
+
+export function embed(element, options = {}) {
+  const frameUrl = new URL(options.frameUrl ?? FRAME, location.href);
+  // The frame fetches fonts itself, so it gets their full URLs.
+  const fonts = (options.fonts ?? []).map((font) => new URL(font, location.href).href);
+  const cjkFont = options.cjkFont ? new URL(options.cjkFont, location.href).href : options.cjkFont;
+  if (fonts.length || cjkFont !== undefined) {
+    frameUrl.searchParams.set("fonts", JSON.stringify({ fonts, cjkFont }));
+  }
+  const frame = document.createElement("iframe");
+  // A frame on another origin needs these to copy and paste.
+  frame.allow = "clipboard-read; clipboard-write";
+  frame.src = frameUrl.href;
+  frame.title = options.title ?? "ReShiki editor";
+  frame.style.cssText = "display: block; width: 100%; height: 100%; border: 0";
+  const pending = new Map();
+  let next = 0;
+  let listeners = options.onChange ? [options.onChange] : [];
+  let started;
+  let removed = false;
+  const ready = new Promise((resolve, reject) => (started = { resolve, reject }));
+  // Calls see a failed start; it is not unhandled when nothing else waits.
+  ready.catch(() => {});
+  // A frame whose page or scripts fail to load never reports, so stop waiting.
+  const timer = setTimeout(
+    () => started.reject(new Error("The editor frame did not start")),
+    options.timeout ?? 60_000,
+  );
+  ready.finally(() => clearTimeout(timer)).catch(() => {});
+
+  const receive = ({ source, origin, data }) => {
+    if (source !== frame.contentWindow || origin !== frameUrl.origin) return;
+    if (data?.event === "ready") started.resolve();
+    else if (data?.event === "error") started.reject(new Error(data.error));
+    else if (data?.event === "change") listeners.forEach((listener) => listener());
+    else if (data?.event === "fonterror") {
+      (options.onError ?? console.error)(new Error(data.error));
+    } else if (pending.has(data?.id)) {
+      const { resolve, reject } = pending.get(data.id);
+      pending.delete(data.id);
+      if ("error" in data) reject(new Error(data.error));
+      else resolve(data.result);
+    }
+  };
+  addEventListener("message", receive);
+  element.append(frame);
+
+  const call = async (method, ...args) => {
+    await ready;
+    if (removed) throw new Error("The editor was removed");
+    const id = ++next;
+    return new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject });
+      frame.contentWindow.postMessage({ id, method, args }, frameUrl.origin);
+    });
+  };
+
+  return {
+    ready,
+    load: (data, format = "auto") => call("load", data, format),
+    save: (format = "rsk") => call("save", format),
+    exportImage: (format = "svg") => call("exportImage", format),
+    onChange(callback) {
+      listeners = [...listeners, callback];
+      return () => {
+        listeners = listeners.filter((listener) => listener !== callback);
+      };
+    },
+    destroy() {
+      removed = true;
+      started.reject(new Error("The editor was removed"));
+      removeEventListener("message", receive);
+      pending.forEach(({ reject }) => reject(new Error("The editor was removed")));
+      pending.clear();
+      listeners = [];
+      frame.remove();
+    },
+  };
+}

package/src/fonts.d.ts

@@ -0,0 +1,30 @@
+import type { FontSource, MountOptions } from "./editor.js";
+
+/** The default Japanese fallback: Noto Sans JP Regular on jsDelivr. */
+export const NOTO_SANS_JP: string;
+
+/** The page's globals these functions use; tests pass their own. */
+export interface FontPage {
+  navigator?: { permissions?: { query(descriptor: { name: string }): Promise<{ state: string }> } };
+  queryLocalFonts?: () => Promise<{ family: string; style: string; blob(): Promise<Blob> }[]>;
+  fetch?: typeof fetch;
+}
+
+/** The bytes of a font URL, or the bytes given. */
+export function fontBytes(font: FontSource, fetchFont?: typeof fetch): Promise<Uint8Array>;
+
+/** The best Japanese system font's regular and bold faces when the page
+ * already has Local Font Access permission; none otherwise. */
+export function systemCjkFonts(page?: FontPage): Promise<Uint8Array[]>;
+
+/** The Japanese fallback: system fonts when allowed, else `cjkFont` (Noto Sans
+ * JP by default) downloaded; nothing when it is false. */
+export function cjkFonts(cjkFont?: MountOptions["cjkFont"], page?: FontPage): Promise<Uint8Array[]>;
+
+/** Add `options.fonts` to the editor, and return the callback that loads the
+ * Japanese fallback when the editor first needs one (undefined for none). */
+export function loadFonts(
+  wasm: { addFont(bytes: Uint8Array): number },
+  options?: Pick<MountOptions, "fonts" | "cjkFont" | "onError">,
+  page?: FontPage,
+): Promise<(() => Promise<void>) | undefined>;

package/src/fonts.js

@@ -0,0 +1,95 @@
+// Fonts for the editor, which can only draw with fonts loaded into it as
+// bytes. The page's own fonts load before the editor starts. For Japanese
+// (CJK) text the editor asks once for a fallback: the computer's own font when
+// the page may already read local fonts, so no prompt appears, or else
+// Noto Sans JP, downloaded once.
+
+/** Noto Sans JP Regular (SIL Open Font License), pinned to release Sans2.004. */
+export const NOTO_SANS_JP =
+  "https://cdn.jsdelivr.net/gh/notofonts/noto-cjk@Sans2.004/Sans/SubsetOTF/JP/NotoSansJP-Regular.otf";
+
+// Japanese system fonts, best first: macOS, Windows, then Linux.
+const SYSTEM_CJK = [
+  "Hiragino Sans",
+  "Hiragino Kaku Gothic ProN",
+  "Yu Gothic",
+  "Meiryo",
+  "Noto Sans CJK JP",
+  "Noto Sans JP",
+];
+const REGULAR_OR_BOLD = /^(regular|normal|w3|bold|w6)$/i;
+
+/** The bytes of `font`: a URL to fetch, or the bytes themselves. */
+export async function fontBytes(font, fetchFont = fetch) {
+  if (typeof font !== "string" && !(font instanceof URL)) {
+    return font instanceof ArrayBuffer ? new Uint8Array(font) : font;
+  }
+  let response;
+  try {
+    response = await fetchFont(font);
+  } catch (error) {
+    throw new Error(`Could not load the font ${font}: ${error?.message ?? error}`);
+  }
+  if (!response.ok) throw new Error(`Could not load the font ${font}: HTTP ${response.status}`);
+  return new Uint8Array(await response.arrayBuffer());
+}
+
+/** The regular and bold faces of the best Japanese system font, when the
+ * page already has Local Font Access; none otherwise, without a prompt. */
+export async function systemCjkFonts(page = globalThis) {
+  try {
+    const status = await page.navigator?.permissions?.query({ name: "local-fonts" });
+    if (status?.state !== "granted" || typeof page.queryLocalFonts !== "function") return [];
+    const fonts = await page.queryLocalFonts();
+    for (const family of SYSTEM_CJK) {
+      const faces = fonts.filter((font) => font.family === family);
+      const chosen = faces.filter((font) => REGULAR_OR_BOLD.test(font.style));
+      const use = chosen.length ? chosen : faces.slice(0, 1);
+      if (use.length) {
+        return await Promise.all(
+          use.map(async (font) => new Uint8Array(await (await font.blob()).arrayBuffer())),
+        );
+      }
+    }
+  } catch {
+    // Browsers without the API or the permission name throw; download instead.
+  }
+  return [];
+}
+
+/** The Japanese fallback's bytes: system fonts when allowed, else `cjkFont`
+ * (Noto Sans JP by default) downloaded; nothing when `cjkFont` is false. */
+export async function cjkFonts(cjkFont, page = globalThis) {
+  if (cjkFont === false) return [];
+  const system = await systemCjkFonts(page);
+  if (system.length) return system;
+  return [await fontBytes(cjkFont ?? NOTO_SANS_JP, page.fetch?.bind(page) ?? fetch)];
+}
+
+/** Add the page's `fonts` to the editor (`wasm.addFont`) now, and return the
+ * callback the editor calls when it first needs the Japanese fallback, or
+ * undefined for none. Failures go to `onError`. */
+export async function loadFonts(wasm, options = {}, page = globalThis) {
+  const onError = options.onError ?? ((error) => console.error(error));
+  const add = (bytes) => {
+    try {
+      wasm.addFont(bytes);
+    } catch (error) {
+      onError(new Error(`Could not add a font: ${error?.message ?? error}`));
+    }
+  };
+  const fetchFont = page.fetch?.bind(page) ?? fetch;
+  const loaded = await Promise.allSettled(
+    (options.fonts ?? []).map((font) => fontBytes(font, fetchFont)),
+  );
+  for (const result of loaded) {
+    if (result.status === "fulfilled") add(result.value);
+    else onError(result.reason);
+  }
+  if (options.cjkFont === false) return undefined;
+  return () =>
+    cjkFonts(options.cjkFont, page).then(
+      (fonts) => fonts.forEach(add),
+      (error) => onError(error),
+    );
+}

package/src/frame.html

@@ -0,0 +1,53 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>ReShiki editor</title>
+    <style>
+      html,
+      body,
+      #editor {
+        margin: 0;
+        width: 100%;
+        height: 100%;
+        overflow: hidden;
+      }
+    </style>
+  </head>
+  <body>
+    <div id="editor"></div>
+    <script type="module">
+      // The page embed.js loads into an iframe. It answers its parent's
+      // { id, method, args } messages with { id, result } or { id, error },
+      // and posts { event: "ready" | "change" } and { event: "fonterror", error }.
+      // embed() passes its fonts as JSON in the `fonts` query parameter.
+      import { mount } from "./editor.js";
+
+      const METHODS = new Set(["load", "save", "exportImage"]);
+      const post = (message, origin = "*") => parent.postMessage(message, origin);
+      const fonts = JSON.parse(new URLSearchParams(location.search).get("fonts") ?? "{}");
+      const ready = mount(document.getElementById("editor"), {
+        fonts: fonts.fonts,
+        cjkFont: fonts.cjkFont,
+        onChange: () => post({ event: "change" }),
+        onError: (error) => post({ event: "fonterror", error: String(error?.message ?? error) }),
+      });
+      ready.then(
+        () => post({ event: "ready" }),
+        (error) => post({ event: "error", error: String(error) }),
+      );
+
+      addEventListener("message", async ({ source, origin, data }) => {
+        if (source !== parent || !METHODS.has(data?.method)) return;
+        try {
+          const editor = await ready;
+          const result = await editor[data.method](...(data.args ?? []));
+          post({ id: data.id, result }, origin);
+        } catch (error) {
+          post({ id: data.id, error: String(error?.message ?? error) }, origin);
+        }
+      });
+    </script>
+  </body>
+</html>

package/src/index.d.ts

@@ -0,0 +1,70 @@
+/** Formats a structure or drawing can be read from. `rsk` is a native
+ * ReShiki drawing, `cdx` the binary ChemDraw file, `rsmi` reaction SMILES;
+ * `auto` tells the text formats apart. */
+export type InputFormat =
+  | "rsk"
+  | "mol"
+  | "smiles"
+  | "inchi"
+  | "cdxml"
+  | "cdx"
+  | "rxn"
+  | "rsmi"
+  | "auto";
+
+/** Outputs returned as bytes. */
+export type BinaryFormat = "png" | "pdf" | "cdx";
+/** Outputs returned as text. */
+export type TextFormat = "rsk" | "svg" | "mol" | "smiles" | "inchi" | "cdxml" | "rxn" | "rsmi";
+export type OutputFormat = BinaryFormat | TextFormat;
+
+/** Text is read as UTF-8; `cdx` input must be bytes. */
+export type Input = string | Uint8Array;
+
+export interface PngOptions {
+  /** Default 1600; 1 to 8192. */
+  maxWidth?: number;
+  /** Default 1000; 1 to 8192. */
+  maxHeight?: number;
+}
+
+/** Load the WebAssembly module. Every function calls it, so calling it first
+ * is needed only to load from somewhere other than next to this package's
+ * `reshiki_web_bg.wasm`, or from bytes or a compiled module. */
+export function init(
+  module?: string | URL | Request | Response | BufferSource | WebAssembly.Module,
+): Promise<void>;
+
+/** Convert between formats. svg, png and pdf are figures as the desktop's
+ * Export makes them. Rejects with an Error carrying the app's message. */
+export function convert(data: Input, from: InputFormat, to: BinaryFormat): Promise<Uint8Array>;
+export function convert(data: Input, from: InputFormat, to: TextFormat): Promise<string>;
+export function convert(
+  data: Input,
+  from: InputFormat,
+  to: OutputFormat,
+): Promise<string | Uint8Array>;
+
+/** The editor's SVG preview, with a transparent surround. */
+export function renderSvg(data: Input, format: InputFormat): Promise<string>;
+
+/** The editor's PNG preview on white, scaled up to 3x and down to fit. */
+export function renderPng(
+  data: Input,
+  format: InputFormat,
+  options?: PngOptions,
+): Promise<Uint8Array>;
+
+/** The canonical SMILES. */
+export function smiles(data: Input, format: InputFormat): Promise<string>;
+
+/** The standard InChI. */
+export function inchi(data: Input, format: InputFormat): Promise<string>;
+
+/** Add a TrueType or OpenType font (or collection), from a URL or bytes, for
+ * figures and previews; text whose font lacks a glyph, such as Japanese,
+ * falls back to it. Resolves to the number of faces added. */
+export function addFont(font: string | URL | Uint8Array | ArrayBuffer): Promise<number>;
+
+/** The library version. */
+export function version(): Promise<string>;