@quillmark/wasm 0.100.0 → 0.102.0

package/backends/pdfform/wasm.d.ts

@@ -46,7 +46,7 @@ export interface Card {
      * The card body as canonical `Content`: the source-of-truth content model.
      * Always this content shape on read, never a markdown string. For the markdown
      * projection call the codec `exportMarkdown(card.body)`. Write a body back
-     * with `doc.install(addr, rt)` / `doc.revise(addr, md)`, or via `CardInput.body`.
+     * with `doc.overwrite(addr, rt)` / `doc.revise(addr, md)`, or via `CardInput.body`.
      */
     body: Content;
 }
@@ -227,11 +227,12 @@ export type MarkOp =
 | { op: "removeAnchor"; id: string };
 
 /**
- * A line/block edit. `split`/`join` splice `\n`; `setKind`/`setContainers`/
- * `setContinues` touch metadata. `setContinues` sets/clears a line's within-block
- * hard-break flag (`ContentLine.continues`): the op-grained way to lower a
- * Shift+Enter hard break or a new code-fence interior line; `continues: true` on
- * line 0 is rejected (nothing precedes it to continue).
+ * A line/block edit. `split`/`join` splice `\n` in post-`delta`, post-`islandOps`
+ * coordinates; `setKind`/`setContainers`/`setContinues` touch metadata.
+ * `setContinues` sets/clears a line's within-block hard-break flag
+ * (`ContentLine.continues`): the op-grained way to lower a Shift+Enter hard
+ * break or a new code-fence interior line; `continues: true` on line 0 is
+ * rejected (nothing precedes it to continue).
  */
 export type LineOp =
 | { op: "split"; at: number }
@@ -240,13 +241,60 @@ export type LineOp =
 | { op: "setContainers"; line: number; containers: ContentContainer[] }
 | { op: "setContinues"; line: number; continues: boolean };
 
+/**
+ * An island edit: the only channel that reaches an island's payload, a table's
+ * cells or an image's url.
+ *
+ * Both ops move one island entry and leave the field's text and marks alone, so
+ * an island edit keeps every identity anchor in the field. That is why a table
+ * edit lowers to `applyChange` rather than `overwrite`, which drops them all.
+ *
+ * `set` addresses an existing island by `id`; an `id` no island carries throws
+ * rather than passing silently. `insert` places a new island's slot at `at`
+ * together with its entry, so a slot never exists without an island behind it;
+ * its `id` must be non-empty and unused. `at` is a position in the text the
+ * `delta` and this bundle's earlier island ops left: each insert splices its
+ * slot before the next op reads the text, so slots after `a` and `b` of `abc`
+ * go in at 1 and 3. A stale frame misplaces slots and never throws.
+ *
+ * A `delta` insert string may not carry a slot, which would orphan. A producer
+ * that computes one splice over the whole field text carries slots in it on any
+ * paste of an island or undo of a deletion; that splice splits into the
+ * slot-free `delta` plus one `insert` per slot.
+ *
+ * Deleting an island needs no op, and the drop is whole: a `delta` that removes
+ * its slot drops the island from the store. Re-landing it is an `insert` of the
+ * full island under its original id, and only the producer that deleted it
+ * still holds that value. A pasted copy of a live island is new and mints fresh
+ * (DOCUMENT_STORAGE § Island-id determinism). A block island's line demotes to
+ * `para` when its slot goes, so re-landing one re-tags the line too.
+ *
+ * A `set` stores the `loss` it is given: nothing re-derives the class from the
+ * new `props`, so a write that changes what markdown can carry must say so.
+ *
+ * An island is *inline* (a slot inside a paragraph) unless its line says
+ * otherwise. A **block** island is one bundle of all three channels, in the
+ * order they apply: `delta` inserts the `\n` that opens the line, `islandOps`
+ * inserts the slot, `lineOps` tags the line `{ op: "setKind", kind: "island" }`.
+ * `{ op: "split" }` cannot open that line, since line ops run after island ops.
+ */
+export type IslandOp =
+| ({ op: "set" } & ContentIsland)
+| ({ op: "insert"; at: number } & ContentIsland);
+
 /**
  * A committed content edit bundle for `applyChange`: a text `delta` (default no
- * text change), then `lineOps`, then `markOps` (mark ranges are in post-delta
- * coordinates). Every field is optional.
+ * text change), then `islandOps`, then `lineOps`, then `markOps` (mark ranges
+ * are in final-text coordinates: every earlier channel applied). Every field is
+ * optional.
+ *
+ * Within each channel ops apply in sequence, each against the state the earlier
+ * ones left: an island `insert`'s `at` counts earlier ops' slots, and `lineOps`
+ * positions and indices renumber through earlier `split`/`join`.
  */
 export interface ChangeBundle {
     delta?: Delta;
+    islandOps?: IslandOp[];
     lineOps?: LineOp[];
     markOps?: MarkOp[];
 }
@@ -722,11 +770,16 @@ export class Document {
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * **Apply** a committed content edit `bundle` (`{ delta?, lineOps?, markOps? }`)
-     * at `addr`, the editor splice: text delta first, then line ops, then mark
-     * ops (mark ranges in final-text coordinates), each all-or-nothing. An absent
+     * **Apply** a committed content edit `bundle`
+     * (`{ delta?, islandOps?, lineOps?, markOps? }`) at `addr`, the editor
+     * splice: text delta first, then island ops, then line ops, then mark ops
+     * (mark ranges in final-text coordinates), each all-or-nothing. An absent
      * `addr.field` targets the body, an absent `addr.card` the main card.
      *
+     * The island channel keeps a table or image edit on the op path: it moves
+     * the island alone, so the anchors elsewhere in the field survive an edit
+     * `overwrite` would clear.
+     *
      * Throws on an out-of-range card, a field that is not richtext, a malformed
      * bundle, or an op that applies out of bounds (the value is unchanged on a
      * failed apply).
@@ -739,6 +792,18 @@ export class Document {
      * uniform.
      */
     static blueprintInstruction(quill_name: string): string;
+    /**
+     * The **body** markdown projection (the main body, or a composable card's
+     * body (`{ card }`)) the on-demand, lossy export (content-only marks do not
+     * survive markdown). A body's type is a format fact, not a schema fact, so
+     * this read stays quill-free; a body is never absent.
+     *
+     * `addr` is an optional **card address** (`{ card }`, absent = main). A
+     * present `field` throws: a field's markdown is read through the
+     * schema-plane `quill.reader(doc).get(field)`, which interprets by declared
+     * type. An out-of-range `addr.card` throws.
+     */
+    bodyMarkdown(addr?: CardAddr): string;
     /**
      * A single composable card by index: the whole `Card`, the card-indexed
      * twin of the [`main`](Self::main) getter, so reading one card need not
@@ -749,11 +814,11 @@ export class Document {
     card(index: number): Card;
     clone(): Document;
     /**
-     * Schema version this build writes via [`toJson`](Document::to_json).
+     * Storage version this build writes via [`toJson`](Document::to_json).
      * Tracks the `Document` model version (not the running crate version):
      * the tag advances only when the wire format changes, not on every release.
      */
-    static currentSchemaVersion(): string;
+    static currentStorageVersion(): string;
     /**
      * Structural equality (parse-time `warnings` excluded). Use to debounce
      * upstream prop updates instead of re-parsing on every keystroke.
@@ -800,18 +865,6 @@ export class Document {
      * `removeExtNamespace`). Throws on a present `field` or an out-of-range card.
      */
     getExtNamespace(addr: CardAddr, ns: string): unknown;
-    /**
-     * The **body** markdown projection (the main body, or a composable card's
-     * body (`{ card }`)) the on-demand, lossy export (content-only marks do not
-     * survive markdown). A body's type is a format fact, not a schema fact, so
-     * this read stays quill-free; a body is never absent.
-     *
-     * `addr` is an optional **card address** (`{ card }`, absent = main). A
-     * present `field` throws: a field's markdown is read through the
-     * schema-plane `quill.reader(doc).get(field)`, which interprets by declared
-     * type. An out-of-range `addr.card` throws.
-     */
-    getMarkdown(addr?: CardAddr): string;
     /**
      * Read the **verbatim stored value** at `addr`: the raw payload value of a
      * field, or the **body content** when `addr.field` is absent. A bare
@@ -820,7 +873,7 @@ export class Document {
      * throws `edit::index_out_of_range`. Needs no schema, so it lives on
      * `Document`: the read echo of the verbatim `store*` write, distinct from
      * the interpreted schema-plane [`reader.get`](Self::reader_get). For the
-     * markdown projection use [`getMarkdown`](Self::get_markdown) (body) or
+     * markdown projection use [`bodyMarkdown`](Self::get_markdown) (body) or
      * `reader.get` (a field's declared type).
      *
      * **A content field at rest has one stored form per codec**: a `richtext`
@@ -829,7 +882,7 @@ export class Document {
      * `quill.conform`) is at rest, so this read no longer depends on which lane
      * built it. A document that came through the transport door
      * (`Document.fromMarkdown`, a legacy stored row) may rest as authored until
-     * it is conformed, and this read reports what is there. For the corpus
+     * it is conformed, and this read reports what is there. For the `Content`
      * either way, use the schema-plane `reader.getContent`, which decodes
      * through the codec the field's declared type names.
      */
@@ -843,19 +896,6 @@ export class Document {
      * not a valid kind name, or if `at` is out of range.
      */
     insertCard(card: CardInput, at?: number): void;
-    /**
-     * **Install** a richtext value at `addr`: **value semantics**, content only.
-     * Stores exactly `rt` (a canonical `Content` content object); the identity
-     * anchors of any previous value are gone. An absent `addr.field` targets the
-     * body, an absent `addr.card` the main card. For "here's new markdown," use
-     * [`revise`](Document::revise); the cold-import path is spelled at the call
-     * site as `install(addr, importMarkdown(md))`, so anchor loss is visible in
-     * source.
-     *
-     * Throws on an out-of-range card, a malformed field name, or an `rt` that is
-     * not a canonical content object.
-     */
-    install(addr: Addr | string, rt: Content): void;
     /**
      * Whether the field at `addr` is marked `!must_fill`. A bare string is `Addr`
      * shorthand for `{ field }`. `false` for an absent field (truthful: it isn't
@@ -904,6 +944,21 @@ export class Document {
      * Throws on an invalid quill reference. Mirrors Python `Document(quill_ref)`.
      */
     constructor(quill_ref: string);
+    /**
+     * **Overwrite** the content value at `addr`: **value semantics**, content
+     * only. Stores exactly `rt` (a canonical `Content` content object); the
+     * identity anchors of any previous value are gone. The bottom rung of the
+     * content lane's ladder by anchor fate: `overwrite` destroys,
+     * [`revise`](Document::revise) rebases,
+     * [`applyChange`](Document::apply_change) preserves. An absent `addr.field`
+     * targets the body, an absent `addr.card` the main card. Cold-importing
+     * markdown is spelled `overwrite(addr, importMarkdown(md))` at the call
+     * site, where the anchor loss is visible.
+     *
+     * Throws on an out-of-range card, a malformed field name, or an `rt` that is
+     * not a canonical content object.
+     */
+    overwrite(addr: Addr | string, rt: Content): void;
     /**
      * The canonical `$quill` reference grammar as author-facing text. Core is
      * the single source of truth: drive schema `describe` and validation
@@ -939,7 +994,7 @@ export class Document {
      * overlay or `undefined`; drops `$seed` entirely once empty. Sibling kinds
      * survive. `$seed` is main-only, so this takes no address.
      */
-    removeSeedNamespace(card_kind: string): any;
+    removeSeedOverlay(card_kind: string): any;
     /**
      * **Revise** the richtext value at `addr` from a markdown string: **edit
      * semantics**, the default write path, returning the text `Delta`. Imports
@@ -952,13 +1007,6 @@ export class Document {
      * non-content field value, or an over-nested markdown input.
      */
     revise(addr: Addr | string, markdown: string): Delta;
-    /**
-     * Read the `schema` version tag from a raw storage DTO string without a
-     * full parse, or `undefined`. Returns unknown future versions as-is:
-     * useful to distinguish "build too old" from "payload corrupt" when
-     * `fromJson` throws.
-     */
-    static schemaVersionOf(json: string): string | undefined;
     /**
      * The main card's `$seed` overlay object for `kind` (the `$seed[kind]`
      * entry), or `undefined` when absent. The cheap read that feeds
@@ -977,6 +1025,18 @@ export class Document {
      * Replace the QUILL reference string. Throws if `ref_str` is invalid.
      */
     setQuillRef(ref_str: string): void;
+    /**
+     * Read the storage version tag from a raw storage DTO string without a
+     * full parse, or `undefined`. Returns unknown future versions as-is:
+     * useful to distinguish "build too old" from "payload corrupt" when
+     * `fromJson` throws.
+     *
+     * The storage version, not a field schema ([`schema`](Quill::schema) is the
+     * quill's field declarations). The JSON key is spelled `"schema"`: it is
+     * the DTO's serde tag, and retagging it would break the version dispatch
+     * it drives.
+     */
+    static storageVersionOf(json: string): string | undefined;
     /**
      * Replace the opaque `$ext` map on the card `addr` targets (a card address,
      * absent `card` = main). `value` must be a plain object. `$ext` carries
@@ -999,7 +1059,7 @@ export class Document {
      * shorthand for `{ field }`, so `doc.storeField("qty", 3)` reads as written;
      * `{ card: 2, field: "qty" }` targets a composable card. Clears any
      * `!must_fill` marker. A body address (no `field`) throws: a body is never
-     * opaque; write it with `revise` / `install` / `writer.setBody`. Throws on
+     * opaque; write it with `revise` / `overwrite` / `writer.reviseBody`. Throws on
      * an out-of-range card or a malformed name.
      */
     storeField(addr: Addr | string, value: any): void;
@@ -1028,7 +1088,7 @@ export class Document {
      * cards of that kind spawn with. Quill-free and verbatim: an opaque `store`
      * verb. Throws if `overlay` cannot be serialized or nests too deep.
      */
-    storeSeedNamespace(card_kind: string, overlay: any): void;
+    storeSeedOverlay(card_kind: string, overlay: any): void;
     /**
      * Serialize this document to a versioned storage DTO string.
      *
@@ -1090,15 +1150,6 @@ export class LiveSession {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
-    /**
-     * Recompile the session against `doc`: the edit verb of a live preview.
-     * The document is compiled through the same schema pipeline as `open`
-     * (same quill), then applied transactionally: on throw every read
-     * (`render`, `paint`, `pageSize`, `regions`, `fieldAt`) keeps serving the last-good
-     * compile, and the session recovers on the next successful `apply`. On
-     * success reads serve the new compile; repaint `dirtyPages ∩ visible`.
-     */
-    apply(doc: Document): ChangeSet;
     /**
      * The schema field whose content is under a point on `page`, the
      * forward (click → field) direction: hit-test a click against the
@@ -1177,6 +1228,19 @@ export class LiveSession {
      */
     regions(): FieldRegion[];
     render(opts?: RenderOptions | null): RenderResult;
+    /**
+     * Recompile the session against `doc`: the edit verb of a live preview.
+     * The document is compiled through the same schema pipeline as `open`
+     * (same quill), then swapped in transactionally: on throw every read
+     * (`render`, `paint`, `pageSize`, `regions`, `fieldAt`) keeps serving the last-good
+     * compile, and the session recovers on the next successful `update`. On
+     * success reads serve the new compile; repaint `dirtyPages ∩ visible`.
+     *
+     * Distinct from the content lane's [`applyChange`](Document::apply_change),
+     * which splices ops into a document: this one recompiles a whole document
+     * the caller already mutated.
+     */
+    update(doc: Document): ChangeSet;
     /**
      * The backend that produced this session (e.g. `"typst"`).
      */
@@ -1233,8 +1297,8 @@ export class Quill {
      * ingestion path**, and the bound twin of the schema-free
      * `Document.fromMarkdown`. The returned document rests at its canonical
      * form (a `richtext` field as a content object, a `plaintext` field as its
-     * literal string), so `getStored` no longer answers "corpus or string?"
-     * with "depends how this document was built".
+     * literal string), so `getStored` answers "content object or string?" by the
+     * field's declared codec rather than by how the document was built.
      *
      * Parse warnings and the `conform::*` diagnostics both land on
      * `doc.warnings`. Throws on a parse failure, or when `markdown` declares a
@@ -1385,17 +1449,12 @@ export function formatDocPath(segs: DocPathSeg[]): string;
 
 /**
  * Import a markdown string to a canonical `Content` content: the pure,
- * document-free codec. Pair with `install(addr, importMarkdown(md))` to spell
+ * document-free codec. Pair with `overwrite(addr, importMarkdown(md))` to spell
  * the cold (anchor-losing) write at the call site; prefer `revise` for edit
  * semantics. Throws on an over-nested input.
  */
 export function importMarkdown(markdown: string): Content;
 
-/**
- * Initialize the WASM module with panic hooks for better error messages
- */
-export function init(): void;
-
 /**
  * Map a base content position (a USV index into `Content.text`, not a UTF-16
  * offset) through a `delta` to its new USV position: the pure position-mapping
@@ -1423,3 +1482,142 @@ export function parseDocPath(path: string): DocPathSeg[];
  * markdown input or a non-content `base`.
  */
 export function rebase(base: Content, markdown: string): { content: Content; delta: Delta };
+
+/**
+ * Runs at instantiation (the wasm-bindgen start section): installs the panic
+ * hook, so a Rust panic reaches the console as a stack trace rather than
+ * `unreachable`.
+ *
+ * Not the package's `init`. That name belongs to the hand-written runtime,
+ * which owns instantiation itself (`runtime/runtime.js`); this runs as part of
+ * the instantiation it awaits.
+ */
+export function start(): void;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_document_free: (a: number, b: number) => void;
+    readonly __wbg_livesession_free: (a: number, b: number) => void;
+    readonly __wbg_quill_free: (a: number, b: number) => void;
+    readonly __wbg_quillmark_free: (a: number, b: number) => void;
+    readonly document__addCard: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly document__commitField: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly document__commitFields: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly document__readerGet: (a: number, b: number, c: number, d: number) => void;
+    readonly document__readerGetContent: (a: number, b: number, c: number, d: number) => void;
+    readonly document__reviseField: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly document_applyChange: (a: number, b: number, c: number, d: number) => void;
+    readonly document_blueprintInstruction: (a: number, b: number, c: number) => void;
+    readonly document_bodyMarkdown: (a: number, b: number, c: number) => void;
+    readonly document_card: (a: number, b: number, c: number) => void;
+    readonly document_cardCount: (a: number) => number;
+    readonly document_cards: (a: number, b: number) => void;
+    readonly document_clone: (a: number) => number;
+    readonly document_currentStorageVersion: (a: number) => void;
+    readonly document_equals: (a: number, b: number) => number;
+    readonly document_formatDiagnostic: (a: number, b: number) => void;
+    readonly document_formatRules: (a: number) => void;
+    readonly document_fromJson: (a: number, b: number, c: number) => void;
+    readonly document_fromMarkdown: (a: number, b: number, c: number) => void;
+    readonly document_getExt: (a: number, b: number, c: number) => void;
+    readonly document_getExtNamespace: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly document_getStored: (a: number, b: number, c: number) => void;
+    readonly document_insertCard: (a: number, b: number, c: number, d: number) => void;
+    readonly document_isFill: (a: number, b: number, c: number) => void;
+    readonly document_loadJson: (a: number, b: number, c: number, d: number) => void;
+    readonly document_main: (a: number, b: number) => void;
+    readonly document_makeCard: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly document_moveCard: (a: number, b: number, c: number, d: number) => void;
+    readonly document_new: (a: number, b: number, c: number) => void;
+    readonly document_overwrite: (a: number, b: number, c: number, d: number) => void;
+    readonly document_quillRef: (a: number, b: number) => void;
+    readonly document_quillRefHint: (a: number) => void;
+    readonly document_removeCard: (a: number, b: number, c: number) => void;
+    readonly document_removeExt: (a: number, b: number, c: number) => void;
+    readonly document_removeExtNamespace: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly document_removeField: (a: number, b: number, c: number) => void;
+    readonly document_removeSeedOverlay: (a: number, b: number, c: number, d: number) => void;
+    readonly document_revise: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly document_seedOverlay: (a: number, b: number, c: number, d: number) => void;
+    readonly document_setCardKind: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly document_setQuillRef: (a: number, b: number, c: number, d: number) => void;
+    readonly document_storageVersionOf: (a: number, b: number, c: number) => void;
+    readonly document_storeExt: (a: number, b: number, c: number, d: number) => void;
+    readonly document_storeExtNamespace: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
+    readonly document_storeField: (a: number, b: number, c: number, d: number) => void;
+    readonly document_storeFields: (a: number, b: number, c: number, d: number) => void;
+    readonly document_storeFill: (a: number, b: number, c: number, d: number) => void;
+    readonly document_storeSeedOverlay: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly document_toJson: (a: number, b: number) => void;
+    readonly document_toMarkdown: (a: number, b: number) => void;
+    readonly document_tryFromJson: (a: number, b: number) => number;
+    readonly document_warnings: (a: number, b: number) => void;
+    readonly exportMarkdown: (a: number, b: number) => void;
+    readonly formatDocPath: (a: number, b: number) => void;
+    readonly importMarkdown: (a: number, b: number, c: number) => void;
+    readonly livesession_backendId: (a: number, b: number) => void;
+    readonly livesession_fieldAt: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly livesession_fieldBoxes: (a: number, b: number, c: number, d: number) => void;
+    readonly livesession_locate: (a: number, b: number, c: number, d: number) => number;
+    readonly livesession_pageCount: (a: number) => number;
+    readonly livesession_pageSize: (a: number, b: number, c: number) => void;
+    readonly livesession_paint: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly livesession_positionAt: (a: number, b: number, c: number, d: number) => number;
+    readonly livesession_regions: (a: number, b: number) => void;
+    readonly livesession_render: (a: number, b: number, c: number) => void;
+    readonly livesession_supportsCanvas: (a: number) => number;
+    readonly livesession_update: (a: number, b: number, c: number) => void;
+    readonly livesession_warnings: (a: number, b: number) => void;
+    readonly mapPos: (a: number, b: number, c: number, d: number) => void;
+    readonly parseDocPath: (a: number, b: number, c: number) => void;
+    readonly quill_backendId: (a: number, b: number) => void;
+    readonly quill_blueprint: (a: number, b: number) => void;
+    readonly quill_conform: (a: number, b: number, c: number) => void;
+    readonly quill_fromTree: (a: number, b: number) => void;
+    readonly quill_metadata: (a: number, b: number) => void;
+    readonly quill_parse: (a: number, b: number, c: number, d: number) => void;
+    readonly quill_resolve: (a: number, b: number, c: number) => void;
+    readonly quill_schema: (a: number, b: number) => void;
+    readonly quill_seedCard: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly quill_seedDocument: (a: number) => number;
+    readonly quill_seedMain: (a: number, b: number) => void;
+    readonly quill_toTree: (a: number) => number;
+    readonly quill_validate: (a: number, b: number, c: number) => void;
+    readonly quillmark_new: () => number;
+    readonly quillmark_open: (a: number, b: number, c: number, d: number) => void;
+    readonly quillmark_render: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly quillmark_supportedFormats: (a: number, b: number, c: number) => void;
+    readonly quillmark_supportsCanvas: (a: number, b: number) => number;
+    readonly rebase: (a: number, b: number, c: number, d: number) => void;
+    readonly start: () => void;
+    readonly __wbindgen_export: (a: number, b: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export3: (a: number) => void;
+    readonly __wbindgen_export4: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;