@markup-carve/carve-wasm 0.1.4 → 0.1.6

package/carve_wasm.d.ts

@@ -1,6 +1,87 @@
 /* tslint:disable */
 /* eslint-disable */
 
+
+export function toHtmlWithOptions(source: string, options?: RenderOptions | null): string;
+export function toHtmlWithRenderers(source: string, options?: StaticRenderOptions | null): StaticRenderResult;
+
+export interface IncludeContext {
+    sourcePath: string | null;
+    stack: string[];
+    depth: number;
+}
+export type IncludeDenial = "outside-root" | "not-found" | "no-root" | "include-denied" | "include-unresolved";
+export interface IncludeOptions {
+    resolve: (path: string, context: IncludeContext) => string | { source: string; id?: string } | { denial: IncludeDenial } | null;
+    sourcePath?: string;
+    extensions?: string[];
+    maxDepth?: number;
+    maxBytes?: number;
+    maxResolverCalls?: number;
+    maxWarnings?: number;
+}
+export interface IncludeExpansion {
+    json: string;
+    warnings: { rule: string; message: string; file: string | null }[];
+    suppressedWarnings: number;
+    dependencies: { id: string; resolved: boolean; denial: IncludeDenial | null }[];
+    chargedBytes: number;
+    resolverErrors: { path: string; message: string }[];
+}
+export interface SourcePosition {
+    startLine: number;
+    endLine: number;
+    startColumn: number;
+    endColumn: number;
+    /** Unicode codepoint offsets, not UTF-8 bytes or UTF-16 units. */
+    startOffset: number;
+    endOffset: number;
+}
+export interface RenderLoss {
+    code: string;
+    format: string;
+    target: string;
+    nodeType: string;
+    message: string;
+    pos?: SourcePosition;
+}
+export interface RenderResult {
+    value: string;
+    losses: RenderLoss[];
+    totalLosses: number;
+    /**
+     * How many losses each code accounts for, across the WHOLE render.
+     * `losses` is bounded, so counting codes off that array under-reports as
+     * soon as `truncated` is true; these totals do not.
+     */
+    totalsByCode: Record<string, number>;
+    truncated: boolean;
+}
+export interface RenderOptions {
+    full?: boolean;
+    extensions?: string[];
+    symbols?: Record<string, string> | Map<string, string>;
+    rawHtml?: boolean;
+    sections?: boolean;
+    sourceLine?: boolean;
+    positions?: boolean;
+    lowercaseHeadingIds?: boolean;
+    asciiHeadingIds?: "off" | "fold" | "strict";
+    smartTypography?: "glyph" | "source";
+    mode?: "interactive" | "static";
+    profile?: "full" | "article" | "comment" | "minimal";
+    profileBaseHost?: string;
+    mentionUrl?: string;
+    tagUrl?: string;
+    labels?: Record<string, string>;
+}
+export interface StaticRenderOptions extends RenderOptions {
+    renderers?: {
+        math?: (source: string, display: boolean) => string;
+        diagrams?: Record<string, (source: string) => string>;
+    };
+}
+
 export interface LintWarning {
     /** 1-based line number. */
     line: number;
@@ -9,9 +90,14 @@ export interface LintWarning {
     /** Stable rule id, shared with carve-js and carve-php. */
     rule: string;
     message: string;
-    /** 0-based BYTE offset into the source, inclusive. */
+    /**
+     * 0-based offset into the source in UTF-16 CODE UNITS, inclusive. That is
+     * what indexes a JavaScript string, so `source.slice(start, end)` selects the
+     * span the warning is about. It was a UTF-8 byte offset before 0.1.6, which
+     * agreed with this on an ASCII document and not outside one.
+     */
     start: number;
-    /** 0-based BYTE offset into the source, exclusive. */
+    /** 0-based UTF-16 code unit offset into the source, exclusive. */
     end: number;
 }
 
@@ -77,10 +163,10 @@ export interface SourcePatch {
 }
 
 export interface StaticRendererError {
-    /** The renderer that failed. Only "math" is bound. */
-    renderer: "math";
-    /** True for display math. */
-    display: boolean;
+    /** "math", or the diagram fence class. */
+    renderer: string;
+    /** Present for math callbacks only. */
+    display?: boolean;
     /** The source the renderer was handed. */
     source: string;
     message: string;
@@ -96,9 +182,19 @@ export interface AccessibilityDiagnostic {
     rule: string;
     severity: "warning" | "error";
     message: string;
-    /** 0-based BYTE offset into the source, or null when the node carried none. */
+    /**
+     * 0-based Unicode CODEPOINT offset, or null when the node carried none.
+     * Codepoints, not the UTF-8 bytes `LintWarning` counts: the two lint
+     * families answer in different units.
+     */
     startOffset: number | null;
     endOffset: number | null;
+    /**
+     * The same span in UTF-16 code units, which is what indexes a JavaScript
+     * string. Null exactly when `startOffset` / `endOffset` are.
+     */
+    startUtf16: number | null;
+    endUtf16: number | null;
 }
 
 export interface SanitizeSvgOptions {
@@ -131,6 +227,53 @@ export interface ProseMirrorResult {
 
 
 
+export function astJsonToMarkdown(json: string, options?: RenderOptions | null): string;
+export function astJsonToPlainText(json: string, options?: RenderOptions | null): string;
+export function astJsonToAnsi(json: string, options?: RenderOptions | null): string;
+
+
+
+export function lintCarveWithOptions(source: string, options?: RenderOptions | null): LintWarning[];
+
+
+
+export function parseJsonWithOptions(source: string, options?: RenderOptions | null): string;
+export function astJsonToHtml(json: string, options?: RenderOptions | null): string;
+
+
+
+export function toHtmlWithReport(source: string, strict?: boolean | null, maximum?: number | null): RenderResult;
+export function toMarkdownWithReport(source: string, strict?: boolean | null, maximum?: number | null): RenderResult;
+export function toPlainTextWithReport(source: string, strict?: boolean | null, maximum?: number | null): RenderResult;
+export function toAnsiWithReport(source: string, strict?: boolean | null, maximum?: number | null): RenderResult;
+export function toCarveWithReport(source: string, strict?: boolean | null, maximum?: number | null): RenderResult;
+
+
+
+export function toMarkdownWithOptions(source: string, options?: RenderOptions | null): string;
+export function toPlainTextWithOptions(source: string, options?: RenderOptions | null): string;
+export function toAnsiWithOptions(source: string, options?: RenderOptions | null): string;
+export function toCarveWithOptions(source: string, options?: RenderOptions | null): string;
+
+
+
+/**
+ * A parser snapshot retained between editor updates. Call `free()` when done.
+ */
+export class ParserSession {
+    free(): void;
+    [Symbol.dispose](): void;
+    /**
+     * Apply byte edits; a rejected edit leaves the session unchanged.
+     */
+    edit(changes: string): string;
+    constructor(source: string);
+    /**
+     * The current result, with byte ranges and parser-work counters.
+     */
+    snapshot(): string;
+}
+
 /**
  * Replay patch JSON onto a PART 12 tree, returning the result as AST JSON.
  */
@@ -169,13 +312,7 @@ export function applyReversibleAstPatch(ast: string, patch: string, inverse?: bo
 /**
  * Apply a trusted patch after its source length and fingerprint still match.
  */
-export function applySourcePatch(source: string, patch: any): string;
-
-/**
- * Render an AST-JSON document (PART 12) to ANSI-styled text. See
- * [`ast_json_to_markdown`], including what a tree without positions costs.
- */
-export function astJsonToAnsi(json: string, options?: object | null): string;
+export function applySourcePatch(source: string, patch: SourcePatch): string;
 
 /**
  * Render an AST-JSON document (PART 12) back to canonical Carve source.
@@ -186,46 +323,6 @@ export function astJsonToAnsi(json: string, options?: object | null): string;
  */
 export function astJsonToCarve(json: string): string;
 
-/**
- * Render an AST-JSON document (PART 12) to HTML.
- *
- * The other half of `parseJson`. A host that reads the tree in a browser does
- * it to CHANGE something, and until now there was no way to render the result:
- * the binding could serialize a tree out and not take one back.
- *
- * Takes the same options object as [`to_html_with_options`], so an edited tree
- * renders under the profile, labels and switches the host already configured.
- */
-export function astJsonToHtml(json: string, options?: object | null): string;
-
-/**
- * Render an AST-JSON document (PART 12) to Markdown.
- *
- * The direct call for a host that already holds a tree. Without it Markdown was
- * reached through `astJsonToCarve` and then `toMarkdown`: a canonical write, a
- * re-parse and a second render for one answer, and lossier than this, because a
- * tree holding something no Carve source can spell is refused by the write
- * rather than rendered.
- *
- * Takes the same options object as [`to_markdown_with_options`], and reads the
- * same narrow part of it. The profile filter and the `before_render` hooks run,
- * as they do in [`ast_json_to_html`].
- *
- * ORDERING FOLLOWS THE TREE. `toMarkdown` parses with positions on, because
- * section 7 orders collected definitions by source position. A tree arriving as
- * JSON carries whatever positions its producer put there, and one carrying none
- * prints its footnote and link definitions in label order. That is the only
- * order available to a tree without spans, so it is reported here rather than
- * repaired.
- */
-export function astJsonToMarkdown(json: string, options?: object | null): string;
-
-/**
- * Render an AST-JSON document (PART 12) to plain text. See
- * [`ast_json_to_markdown`], including what a tree without positions costs.
- */
-export function astJsonToPlainText(json: string, options?: object | null): string;
-
 /**
  * The difference between two PART 12 trees, as patch JSON.
  *
@@ -310,7 +407,7 @@ export function createSourcePatch(source: string, replacement: string, kind: str
  * and a span on a node that came from a child would point into a source the
  * caller did not pass.
  */
-export function expandIncludes(source: string, options: object): IncludeExpansion;
+export function expandIncludes(source: string, options: IncludeOptions): IncludeExpansion;
 
 /**
  * Every extension name this build accepts, in registry order.
@@ -401,22 +498,15 @@ export function lintAccessibility(source: string): AccessibilityDiagnostic[];
  *
  * Returns an array of `{ line, column, rule, message, start, end }`. The rule
  * ids are shared with carve-js and carve-php, so the same trigger reports the
- * same id everywhere. Offsets are BYTE offsets into the source, matching the
- * engine.
+ * same id everywhere. Offsets count UTF-16 CODE UNITS, so they index the
+ * JavaScript string the caller holds; the engine answers in bytes and this
+ * wrapper converts (#164).
  *
  * Built as JS objects rather than a JSON string: a message carries arbitrary
  * document text, and hand-rolled JSON escaping is where that goes wrong.
  */
 export function lintCarve(source: string): LintWarning[];
 
-/**
- * Lint a document with the same options object the render entry points take.
- *
- * `lintCarve` is the option-less form. Which degradations exist depends on the
- * extensions in play, so a host that renders with a set has to lint with it.
- */
-export function lintCarveWithOptions(source: string, options?: object | null): LintWarning[];
-
 /**
  * Import Markdown straight to the tree, as AST JSON.
  *
@@ -490,16 +580,6 @@ export function needsReview(source: string, current_version: string): boolean;
  */
 export function parseJson(source: string): string;
 
-/**
- * Serialize the tree with the same options object as
- * [`to_html_with_options`], so a host can export the tree of an untrusted
- * document under the `profile` it renders that document with.
- *
- * `positions` is not read: every serialized tree this binding produces carries
- * them, as in [`parse_json`].
- */
-export function parseJsonWithOptions(source: string, options?: object | null): string;
-
 /**
  * Parse the locator portion of a citation into `{ label, value, suffixText }`.
  *
@@ -549,8 +629,8 @@ export function readStamp(source: string): Stamp | null;
  *
  * `changes` is a JSON array of `{ range: [start, end], replacement }`.
  *
- * THE OFFSETS ARE UTF-8 BYTE OFFSETS, which is what `parseJson` positions and
- * `createSourcePatch` ranges already mean. A browser editor counts UTF-16 code
+ * THE OFFSETS ARE UTF-8 BYTE OFFSETS, matching `createSourcePatch` ranges.
+ * `parseJson` positions count Unicode codepoints instead. A browser editor counts UTF-16 code
  * units, so a host holding a `selectionStart` converts before calling - an
  * offset that lands inside a multi-byte character is refused rather than
  * guessed at.
@@ -560,9 +640,9 @@ export function readStamp(source: string): Stamp | null;
  * result the caller asked for.
  *
  * `reusedPreviousTree` says whether the parse reused any of the previous one.
- * The pinned engine always reports `false` - it validates and applies the
- * edits and then parses the whole source - so a host should read this as the
- * engine's own answer rather than assume work was saved.
+ * The engine can reuse unchanged plain paragraphs. Other syntax falls back
+ * to a full parse. This function rebuilds the initial snapshot from source;
+ * use a parser session to retain it across edits.
  */
 export function reparse(source: string, changes: string): string;
 
@@ -593,14 +673,6 @@ export function stampCarve(formatted: string, generated_by: string, form?: strin
 
 export function toAnsi(source: string): string;
 
-/**
- * Render to ANSI text with an options object. See
- * [`to_markdown_with_options`].
- */
-export function toAnsiWithOptions(source: string, options?: object | null): string;
-
-export function toAnsiWithReport(source: string, strict?: boolean | null, maximum?: number | null): any;
-
 export function toCarve(source: string): string;
 
 /**
@@ -608,16 +680,6 @@ export function toCarve(source: string): string;
  */
 export function toCarvePatch(source: string): SourcePatch;
 
-/**
- * Write canonical Carve with an options object.
- *
- * `profile` is the only option this target reads; see
- * [`to_markdown_with_options`] for why.
- */
-export function toCarveWithOptions(source: string, options?: object | null): string;
-
-export function toCarveWithReport(source: string, strict?: boolean | null, maximum?: number | null): any;
-
 export function toHtml(source: string): string;
 
 /**
@@ -636,150 +698,6 @@ export function toHtml(source: string): string;
  */
 export function toHtmlFull(source: string, symbols?: object | null): string;
 
-/**
- * Render with an options object, the general form of the three shorthands
- * above.
- *
- * ```js
- * toHtmlWithOptions('# A\n\np\n', { sections: false })
- * // '<h1 id="A">A</h1>\n<p>p</p>'
- *
- * toHtmlWithOptions(src, { sections: false, symbols: { rocket: '🚀' }, full: true })
- *
- * toHtmlWithOptions(untrusted, { rawHtml: false })
- * ```
- *
- * Every field is optional:
- *
- * * `sections` (default `true`) - wrap each top-level heading, and the content
- *   following it up to the next same-or-shallower heading, in a
- *   `<section id="…">` (spec PART 9 §13). `false` renders headings flat with
- *   the id back on the `<h*>` and the former section children as siblings.
- *   For a host whose CSS or JS assumes rendered blocks are direct children of
- *   the content container - the `.stack > * + *` spacing idiom,
- *   `:first-child`, `nth-child()` counting, `element.children` walks - the
- *   wrapper is the one output change a clean source migration still breaks.
- * * `symbols` - the same map as [`to_html_with_symbols`], with the same
- *   TRUSTED-RAW contract: mapped values are emitted UNESCAPED, so never build
- *   it from untrusted input.
- * * `extensions` - an array of extension names to enable, e.g.
- *   `["glossary", "table-of-contents"]`. `extensions()` reports what this
- *   build accepts. An unknown name throws: a silently ignored extension would
- *   render as missing behavior that looks like a Carve bug. Takes precedence
- *   over `full`.
- * * `full` (default `false`) - enable the preview extension set instead of
- *   rendering core-only.
- * * `rawHtml` (default `true`) - render an explicit passthrough - the `=html`
- *   raw block and the `` `…`{=html} `` inline raw span - as markup. `false`
- *   emits it as escaped text instead, the same switch carve-js spells
- *   `allowRawHtml`. A host that renders a document it did not author (a shared
- *   link, a comment field, anything a reader supplies) wants `false`: without
- *   it a passthrough is a way to run script on the host's origin.
- * * `profile` - one of `"full"`, `"article"`, `"comment"`, `"minimal"`. The
- *   rest of the untrusted-input story: input length, denied constructs, link
- *   policy. A document the profile REJECTS throws a `ProfileViolationError`
- *   carrying `violations`, rather than resolving to an empty string.
- * * `profileBaseHost` - the host counted as internal when the profile's link
- *   policy distinguishes internal from external links.
- * * `mode` - `"interactive"` (default) or `"static"`, the self-contained form
- *   for print, PDF and archival: no client scripts.
- * * `sourceLine` (default `false`) - stamp top-level blocks with
- *   `data-source-line`, for editor preview scroll-sync.
- * * `positions` (default `false`) - keep source offsets on the nodes.
- * * `labels` - override the engine-written strings (admonition names, the
- *   endnotes heading, backlink text) for a page that is not in English. These
- *   are TEXT and are escaped where they land, unlike `symbols`.
- * * `smartTypography` - `"glyph"` (default) resolves `...` to an ellipsis,
- *   `"source"` keeps the author's run.
- * * `lowercaseHeadingIds` (default `false`) and `asciiHeadingIds`
- *   (`"off"` (default), `"fold"`, `"strict"`) - the slug policy, for a host
- *   whose anchors have to match another generator's.
- * * `mentionUrl` and `tagUrl` - URL templates for `@mention` and `#tag`.
- *   Without them both render as inert spans, which is why a host that wants
- *   them linked has to say where to. The token name is percent-encoded into
- *   `{name}` - `{user}` works too for a mention - and the result goes through
- *   the same URL sanitizer as an authored link. These are the HOST's
- *   configuration, not the document's: the template is trusted, the name
- *   substituted into it is not.
- *
- * An unrecognized key is ignored: the object is configuration, and a caller
- * who mistypes one deserves the render to still work. A wrong TYPE on a key
- * that is recognized does throw, because that changes behavior silently.
- *
- * `renderers` is the one recognized key this entry point refuses, because a
- * render callback can fail and a bare string has nowhere to report that. Use
- * [`to_html_with_renderers`].
- *
- * Turning sections off changes nothing else. Ids, collision dedup, `</#id>`
- * crossrefs, implicit `[Heading][]` references and heading numbering all
- * resolve against the slug rather than the element carrying it, and the
- * endnotes `<section role="doc-endnotes">` is a separate construct that is
- * still emitted.
- */
-export function toHtmlWithOptions(source: string, options?: object | null): string;
-
-/**
- * Render with a build-time math renderer, the option `mode: "static"` needs.
- *
- * Static output carries no client scripts, so a formula it contains has to be
- * rendered while the HTML is being written. `renderers.math` is the callback
- * the engine calls for each ``` ```math ``` fence, with the TeX source and a
- * display flag; KaTeX's `renderToString` has that exact shape.
- *
- * ```js
- * toHtmlWithRenderers(src, {
- *   mode: 'static',
- *   extensions: ['math-block'],
- *   renderers: { math: (tex, display) => katex.renderToString(tex, { displayMode: display }) },
- * })
- * // { html: '…', rendererErrors: [] }
- * ```
- *
- * SECURITY: what the callback returns is inserted as **TRUSTED RAW HTML**, the
- * same trust class as a `symbols` value. The difference worth stating: a symbol
- * value is host configuration keyed by a NAME, while a renderer is host
- * configuration that is HANDED DOCUMENT CONTENT and typically echoes some of it
- * back. A host rendering documents it did not author is accepting whatever its
- * renderer makes of that input, so the escaping is the renderer's job.
- *
- * The engine consults the renderer only under `mode: "static"`; interactive
- * output keeps the `\[…\]` source for the client to typeset, and so does a
- * static render with no renderer supplied.
- *
- * The callback must be SYNCHRONOUS. wasm-bindgen cannot await across it, so an
- * `async` renderer returns a Promise the engine has no way to resolve; that is
- * recorded as a failure rather than stringified into the document.
- *
- * `renderers.diagrams` is the same callback one level down, keyed by the
- * fence's css class: `{ mermaid: (source) => html }`. A host that renders its
- * diagrams beforehand passes the lookup in that one line -
- * `(source) => prerendered.get(source)`. Mermaid itself cannot be passed,
- * because its `render` returns a Promise from v10 on.
- *
- * ```js
- * toHtmlWithRenderers(src, {
- *   mode: 'static',
- *   extensions: ['fenced-render'],
- *   renderers: { diagrams: { mermaid: (source) => prerendered.get(source) } },
- * })
- * ```
- *
- * A diagram key the document never uses renders nothing and reports nothing.
- * So does a fence whose class the caller did not configure: the engine
- * degrades it to an escaped source block, and this binding never sees the
- * node.
- *
- * A callback that throws, or returns anything other than a string, does not
- * abort the render: the node it was called for emits nothing and the failure
- * is reported in `rendererErrors`, with `renderer` naming the css class.
- * This entry point exists because [`to_html_with_options`] returns a bare
- * string with nowhere to put that, and so it rejects `renderers` rather than
- * dropping the failures.
- */
-export function toHtmlWithRenderers(source: string, options?: object | null): StaticRenderResult;
-
-export function toHtmlWithReport(source: string, strict?: boolean | null, maximum?: number | null): any;
-
 /**
  * Render with the core profile and a **symbols map**: `{ rocket: "🚀" }` (a
  * plain object or a `Map`). A `:name:` symbol whose name is in the map renders
@@ -800,42 +718,8 @@ export function toHtmlWithSymbols(source: string, symbols?: object | null): stri
 
 export function toMarkdown(source: string): string;
 
-/**
- * Render to Markdown with the same options object as
- * [`to_html_with_options`].
- *
- * `profile` is why this exists. Without it a host can hold an untrusted
- * document to a profile on the way to HTML and not on the way to Markdown,
- * out of one package: the max-length bound, the denied constructs and the
- * link policy were all unreachable here. A document the profile rejects
- * throws a `ProfileViolationError` rather than resolving to an empty string.
- *
- * What these targets read is narrower than HTML's list: `profile` and
- * `smartTypography` change the output and extensions run, while `symbols`
- * (markup-carve/carve-rs#1668), `labels`, `sections`, `sourceLine`, `mode` and
- * the heading-id switches are HTML-side concerns the engine's other renderers
- * do not consult. `renderers` is refused for the reason
- * [`to_html_with_options`] refuses it.
- *
- * [`to_carve_with_options`] is narrower again and reads `profile` alone: the
- * engine's canonical writer is parse-only by contract, so extensions and
- * `smartTypography` are inert there. They are accepted rather than refused
- * because one options object is meant to serve every target.
- */
-export function toMarkdownWithOptions(source: string, options?: object | null): string;
-
-export function toMarkdownWithReport(source: string, strict?: boolean | null, maximum?: number | null): any;
-
 export function toPlainText(source: string): string;
 
-/**
- * Render to plain text with an options object. See
- * [`to_markdown_with_options`].
- */
-export function toPlainTextWithOptions(source: string, options?: object | null): string;
-
-export function toPlainTextWithReport(source: string, strict?: boolean | null, maximum?: number | null): any;
-
 /**
  * Convert Carve source to the ProseMirror document shape.
  *

package/carve_wasm.js

@@ -5,5 +5,5 @@ import { __wbg_set_wasm } from "./carve_wasm_bg.js";
 __wbg_set_wasm(wasm);
 wasm.__wbindgen_start();
 export {
-    applyAstPatch, applyProfile, applyReversibleAstPatch, applySourcePatch, astJsonToAnsi, astJsonToCarve, astJsonToHtml, astJsonToMarkdown, astJsonToPlainText, createAstPatch, createReversibleAstPatch, createSourcePatch, expandIncludes, extensions, fromBbcode, fromDjot, fromHtml, fromMarkdown, fromProseMirror, htmlToAst, htmlToCarve, lintAccessibility, lintCarve, lintCarveWithOptions, markdownToAstJson, mergeAst, migrateBbcode, migrateDjot, needsReview, parseJson, parseJsonWithOptions, parseLocator, parseSnapshot, parseSourceLayoutJson, readStamp, reparse, sanitizeSvg, stampCarve, toAnsi, toAnsiWithOptions, toAnsiWithReport, toCarve, toCarvePatch, toCarveWithOptions, toCarveWithReport, toHtml, toHtmlFull, toHtmlWithOptions, toHtmlWithRenderers, toHtmlWithReport, toHtmlWithSymbols, toMarkdown, toMarkdownWithOptions, toMarkdownWithReport, toPlainText, toPlainTextWithOptions, toPlainTextWithReport, toProseMirror, version
+    ParserSession, applyAstPatch, applyProfile, applyReversibleAstPatch, applySourcePatch, astJsonToAnsi, astJsonToCarve, astJsonToHtml, astJsonToMarkdown, astJsonToPlainText, createAstPatch, createReversibleAstPatch, createSourcePatch, expandIncludes, extensions, fromBbcode, fromDjot, fromHtml, fromMarkdown, fromProseMirror, htmlToAst, htmlToCarve, lintAccessibility, lintCarve, lintCarveWithOptions, markdownToAstJson, mergeAst, migrateBbcode, migrateDjot, needsReview, parseJson, parseJsonWithOptions, parseLocator, parseSnapshot, parseSourceLayoutJson, readStamp, reparse, sanitizeSvg, stampCarve, toAnsi, toAnsiWithOptions, toAnsiWithReport, toCarve, toCarvePatch, toCarveWithOptions, toCarveWithReport, toHtml, toHtmlFull, toHtmlWithOptions, toHtmlWithRenderers, toHtmlWithReport, toHtmlWithSymbols, toMarkdown, toMarkdownWithOptions, toMarkdownWithReport, toPlainText, toPlainTextWithOptions, toPlainTextWithReport, toProseMirror, version
 } from "./carve_wasm_bg.js";