markstone 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Actos Authors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,51 @@
+# markstone
+
+Unified Node.js and browser package for markstone: fast, safe Markdown-to-HTML and AST engine with Actos extensions.
+
+Uses native napi-rs addon on Node.js and WebAssembly (`wasm-bindgen`) in browsers via conditional `exports`. Both paths produce byte-for-byte identical output.
+
+## Installation
+
+```bash
+npm install markstone
+```
+
+Prebuilt addons ship for Linux (x64 and arm64, glibc 2.28+ and musl), macOS
+(x64 and arm64) and Windows (x64 and arm64). On any other platform, Node
+falls back to the WebAssembly build with no extra setup.
+
+## Usage
+
+### Node.js (Native Addon)
+
+```javascript
+import markstone, { toHtml, toAst, actos } from 'markstone';
+
+// Generic CommonMark + GFM
+const html = toHtml('# Hello world');
+const ast = toAst('# Hello world');
+
+// Actos extensions (@mentions and #tags)
+const actosHtml = actos.toHtml('Hello @alice and #rust');
+const actosAst = actos.toAst('Hello @alice and #rust');
+```
+
+### Browser (WebAssembly)
+
+```javascript
+import markstone, { init, toHtml, toAst, actos } from 'markstone';
+
+// Initialize WASM binary once in browser
+await init();
+
+// Render
+const html = toHtml('# Hello from the browser');
+const actosHtml = actos.toHtml('Hello @alice and #rust');
+```
+
+## Security & Conformance
+
+- No raw HTML or dangerous scripts pass through the AST sanitizer.
+- Depth limit: 64 block levels (`DEPTH_EXCEEDED`).
+- Input limit: 4 MiB (`INPUT_TOO_LARGE`).
+- 100% byte-for-byte conformance parity between Node native and browser WASM.

package/browser.d.ts

@@ -0,0 +1,25 @@
+export * from './index.js';
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Initializes the WebAssembly module asynchronously.
+ * In a browser, passing no arguments fetches the wasm binary relative to the module.
+ */
+export function init(moduleOrPath?: InitInput | Promise<InitInput>): Promise<unknown>;
+
+/**
+ * Synchronously initializes the WebAssembly module from bytes or compiled module.
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): unknown;
+
+import markstone from './index.js';
+
+export interface MarkstoneBrowserBinding extends typeof markstone {
+  init: typeof init;
+  initSync: typeof initSync;
+}
+
+declare const markstoneBrowser: MarkstoneBrowserBinding;
+export default markstoneBrowser;

package/browser.js

@@ -0,0 +1,148 @@
+import initWasm, {
+  initSync as wasmInitSync,
+  toHtml as wasmToHtml,
+  to_html as wasm_to_html,
+  toAst as wasmToAst,
+  to_ast as wasm_to_ast,
+  actosToHtml as wasmActosToHtml,
+  actos_to_html as wasm_actos_to_html,
+  actosToAst as wasmActosToAst,
+  actos_to_ast as wasm_actos_to_ast,
+  astSchemaVersion as wasmAstSchemaVersion,
+  ast_schema_version as wasm_ast_schema_version,
+  version as wasmVersion,
+} from './wasm/markstone_wasm.js';
+
+let isInitialized = false;
+
+function ensureInitialized() {
+  if (isInitialized) return;
+  // If in Node.js, attempt synchronous auto-initialization from local wasm file
+  if (typeof process !== 'undefined' && process.versions && process.versions.node) {
+    try {
+      // In CommonJS or Node environments with require
+      const fs = typeof require !== 'undefined' ? require('node:fs') : null;
+      const path = typeof require !== 'undefined' ? require('node:path') : null;
+      if (fs && path) {
+        const wasmPath = path.join(__dirname, 'wasm', 'markstone_wasm_bg.wasm');
+        if (fs.existsSync(wasmPath)) {
+          wasmInitSync({ module: fs.readFileSync(wasmPath) });
+          isInitialized = true;
+          return;
+        }
+      }
+    } catch (_) {
+      // Fall through
+    }
+  }
+
+  // Check if wasm-bindgen already initialized wasm
+  try {
+    wasmVersion();
+    isInitialized = true;
+    return;
+  } catch (_) {
+    // Not yet initialized
+  }
+
+  throw new Error(
+    'markstone WASM module is not initialized. Please call "await init()" before using markstone in the browser.'
+  );
+}
+
+function sanitizeInput(input) {
+  if (typeof input === 'string') {
+    return input;
+  }
+  if (
+    (typeof Buffer !== 'undefined' && Buffer.isBuffer(input)) ||
+    input instanceof Uint8Array
+  ) {
+    try {
+      const decoder = new TextDecoder('utf-8', { fatal: true });
+      return decoder.decode(input);
+    } catch (_) {
+      const err = new Error('invalid utf-8 byte sequence');
+      err.code = 'INVALID_UTF8';
+      throw err;
+    }
+  }
+  throw new TypeError('input must be a string or Buffer');
+}
+
+export function toHtml(input) {
+  ensureInitialized();
+  return wasmToHtml(sanitizeInput(input));
+}
+
+export function to_html(input) {
+  return toHtml(input);
+}
+
+export function toAst(input) {
+  ensureInitialized();
+  return wasmToAst(sanitizeInput(input));
+}
+
+export function to_ast(input) {
+  return toAst(input);
+}
+
+export function astSchemaVersion() {
+  ensureInitialized();
+  return wasmAstSchemaVersion();
+}
+
+export function ast_schema_version() {
+  return astSchemaVersion();
+}
+
+export const AST_SCHEMA_VERSION = 1;
+export const version = '0.1.0';
+
+export const actos = {
+  toHtml(input) {
+    ensureInitialized();
+    return wasmActosToHtml(sanitizeInput(input));
+  },
+  to_html(input) {
+    return actos.toHtml(input);
+  },
+  toAst(input) {
+    ensureInitialized();
+    return wasmActosToAst(sanitizeInput(input));
+  },
+  to_ast(input) {
+    return actos.toAst(input);
+  },
+  astSchemaVersion,
+  ast_schema_version,
+  AST_SCHEMA_VERSION,
+  version,
+};
+
+export async function init(moduleOrPath) {
+  const result = await initWasm(moduleOrPath);
+  isInitialized = true;
+  return result;
+}
+
+export function initSync(module) {
+  const result = wasmInitSync(module);
+  isInitialized = true;
+  return result;
+}
+
+export default {
+  toHtml,
+  to_html,
+  toAst,
+  to_ast,
+  astSchemaVersion,
+  ast_schema_version,
+  AST_SCHEMA_VERSION,
+  version,
+  actos,
+  init,
+  initSync,
+};

package/fallback.js

@@ -0,0 +1,34 @@
+// Entry point for Node and other non-browser runtimes: the native addon when
+// this platform has one, the WebAssembly build otherwise.
+let binding;
+
+try {
+  binding = await import('./index.js');
+} catch (_) {
+  // No addon for this platform, or it failed to load.
+}
+
+if (!binding) {
+  binding = await import('./browser.js');
+  if (typeof process !== 'undefined' && process.versions?.node) {
+    const { readFileSync } = await import('node:fs');
+    const wasm = readFileSync(new URL('./wasm/markstone_wasm_bg.wasm', import.meta.url));
+    binding.initSync({ module: wasm });
+  }
+}
+
+export const {
+  toHtml,
+  to_html,
+  toAst,
+  to_ast,
+  astSchemaVersion,
+  ast_schema_version,
+  AST_SCHEMA_VERSION,
+  version,
+  actos,
+  init,
+  initSync,
+} = binding;
+
+export default binding.default || binding;

package/index.d.ts

@@ -0,0 +1,247 @@
+/**
+ * Position of a node in source markdown: [start_line, start_col, end_line, end_col], 1-based.
+ */
+export type NodePosition = [number, number, number, number];
+
+export type TableAlignment = 'none' | 'left' | 'center' | 'right';
+
+export interface BaseAstNode {
+  type: string;
+  pos: NodePosition;
+  children?: AstNode[];
+}
+
+export interface DocumentNode extends BaseAstNode {
+  type: 'document';
+  children: AstNode[];
+}
+
+export interface ParagraphNode extends BaseAstNode {
+  type: 'paragraph';
+  children: AstNode[];
+}
+
+export interface HeadingNode extends BaseAstNode {
+  type: 'heading';
+  level: 1 | 2 | 3 | 4 | 5 | 6;
+  children: AstNode[];
+}
+
+export interface BlockQuoteNode extends BaseAstNode {
+  type: 'block_quote';
+  children: AstNode[];
+}
+
+export interface ListNode extends BaseAstNode {
+  type: 'list';
+  ordered: boolean;
+  start?: number;
+  tight: boolean;
+  children: AstNode[];
+}
+
+export interface ListItemNode extends BaseAstNode {
+  type: 'list_item';
+  children: AstNode[];
+}
+
+export interface TaskItemNode extends BaseAstNode {
+  type: 'task_item';
+  checked: boolean;
+  children: AstNode[];
+}
+
+export interface CodeBlockNode extends BaseAstNode {
+  type: 'code_block';
+  language?: string;
+  value: string;
+}
+
+export interface ThematicBreakNode extends BaseAstNode {
+  type: 'thematic_break';
+}
+
+export interface TableNode extends BaseAstNode {
+  type: 'table';
+  alignments: TableAlignment[];
+  children: AstNode[];
+}
+
+export interface TableRowNode extends BaseAstNode {
+  type: 'table_row';
+  header: boolean;
+  children: AstNode[];
+}
+
+export interface TableCellNode extends BaseAstNode {
+  type: 'table_cell';
+  children: AstNode[];
+}
+
+export interface TextNode extends BaseAstNode {
+  type: 'text';
+  value: string;
+}
+
+export interface EmphasisNode extends BaseAstNode {
+  type: 'emphasis';
+  children: AstNode[];
+}
+
+export interface StrongNode extends BaseAstNode {
+  type: 'strong';
+  children: AstNode[];
+}
+
+export interface StrikethroughNode extends BaseAstNode {
+  type: 'strikethrough';
+  children: AstNode[];
+}
+
+export interface CodeNode extends BaseAstNode {
+  type: 'code';
+  value: string;
+}
+
+export interface LinkNode extends BaseAstNode {
+  type: 'link';
+  url: string;
+  title?: string;
+  children: AstNode[];
+}
+
+export interface ImageNode extends BaseAstNode {
+  type: 'image';
+  url: string;
+  title?: string;
+  children: AstNode[];
+}
+
+export interface SoftBreakNode extends BaseAstNode {
+  type: 'soft_break';
+}
+
+export interface LineBreakNode extends BaseAstNode {
+  type: 'line_break';
+}
+
+export interface FootnoteDefinitionNode extends BaseAstNode {
+  type: 'footnote_definition';
+  name: string;
+  children: AstNode[];
+}
+
+export interface FootnoteReferenceNode extends BaseAstNode {
+  type: 'footnote_reference';
+  name: string;
+}
+
+export interface MentionNode extends BaseAstNode {
+  type: 'mention';
+  username: string;
+  text: string;
+}
+
+export interface TagNode extends BaseAstNode {
+  type: 'tag';
+  name: string;
+  text: string;
+}
+
+export type AstNode =
+  | DocumentNode
+  | ParagraphNode
+  | HeadingNode
+  | BlockQuoteNode
+  | ListNode
+  | ListItemNode
+  | TaskItemNode
+  | CodeBlockNode
+  | ThematicBreakNode
+  | TableNode
+  | TableRowNode
+  | TableCellNode
+  | TextNode
+  | EmphasisNode
+  | StrongNode
+  | StrikethroughNode
+  | CodeNode
+  | LinkNode
+  | ImageNode
+  | SoftBreakNode
+  | LineBreakNode
+  | FootnoteDefinitionNode
+  | FootnoteReferenceNode
+  | MentionNode
+  | TagNode;
+
+export interface AstDocument {
+  schema: number;
+  root: DocumentNode;
+}
+
+/**
+ * Converts Markdown string or buffer to safe HTML using generic CommonMark + GFM pipeline.
+ */
+export function toHtml(input: string | Uint8Array): string;
+export function to_html(input: string | Uint8Array): string;
+
+/**
+ * Converts Markdown string or buffer to AST JSON string using generic CommonMark + GFM pipeline.
+ */
+export function toAst(input: string | Uint8Array): string;
+export function to_ast(input: string | Uint8Array): string;
+
+/**
+ * Returns the current AST schema version (currently 1).
+ */
+export function astSchemaVersion(): number;
+export function ast_schema_version(): number;
+
+/**
+ * AST JSON schema version constant.
+ */
+export const AST_SCHEMA_VERSION: number;
+
+/**
+ * markstone package version.
+ */
+export const version: string;
+
+/**
+ * Actos-specific extensions (@mentions and #tags).
+ */
+export namespace actos {
+  /**
+   * Converts Markdown string or buffer to safe HTML with Actos extensions (@mentions, #tags).
+   */
+  export function toHtml(input: string | Uint8Array): string;
+  export function to_html(input: string | Uint8Array): string;
+
+  /**
+   * Converts Markdown string or buffer to AST JSON string with Actos extensions (@mentions, #tags).
+   */
+  export function toAst(input: string | Uint8Array): string;
+  export function to_ast(input: string | Uint8Array): string;
+
+  export function astSchemaVersion(): number;
+  export function ast_schema_version(): number;
+
+  export const AST_SCHEMA_VERSION: number;
+  export const version: string;
+}
+
+export interface MarkstoneBinding {
+  toHtml: typeof toHtml;
+  to_html: typeof to_html;
+  toAst: typeof toAst;
+  to_ast: typeof to_ast;
+  astSchemaVersion: typeof astSchemaVersion;
+  ast_schema_version: typeof ast_schema_version;
+  AST_SCHEMA_VERSION: typeof AST_SCHEMA_VERSION;
+  version: typeof version;
+  actos: typeof actos;
+}
+
+declare const markstone: MarkstoneBinding;
+export default markstone;

package/index.js

@@ -0,0 +1,121 @@
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import fs from 'node:fs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Published packages carry one prebuilt addon per platform, named after the
+// platform tag below. `markstone.node` is a local build (`npm run
+// build:native`) and wins when present.
+function isMusl() {
+  if (process.platform !== 'linux') return false;
+  const report = process.report?.getReport?.();
+  const header = typeof report === 'string' ? JSON.parse(report).header : report?.header;
+  return !header?.glibcVersionRuntime;
+}
+
+function platformTag() {
+  const base = `${process.platform}-${process.arch}`;
+  if (process.platform !== 'linux') return base;
+  return `${base}-${isMusl() ? 'musl' : 'gnu'}`;
+}
+
+function loadNativeBinding() {
+  const tag = platformTag();
+  const candidates = [
+    path.join(__dirname, 'markstone.node'),
+    path.join(__dirname, `markstone.${tag}.node`),
+  ];
+
+  const failures = [];
+  for (const candidate of candidates) {
+    if (!fs.existsSync(candidate)) continue;
+    try {
+      const addon = { exports: {} };
+      process.dlopen(addon, candidate);
+      return addon.exports;
+    } catch (err) {
+      failures.push(`${path.basename(candidate)}: ${err.message}`);
+    }
+  }
+
+  const detail = failures.length > 0 ? ` (${failures.join('; ')})` : '';
+  throw new Error(`markstone has no native addon for ${tag}${detail}`);
+}
+
+const binding = loadNativeBinding();
+
+function sanitizeInput(input) {
+  if (typeof input === 'string') {
+    return input;
+  }
+  if (Buffer.isBuffer(input) || input instanceof Uint8Array) {
+    try {
+      const decoder = new TextDecoder('utf-8', { fatal: true });
+      return decoder.decode(input);
+    } catch (_) {
+      const err = new Error('invalid utf-8 byte sequence');
+      err.code = 'INVALID_UTF8';
+      throw err;
+    }
+  }
+  throw new TypeError('input must be a string or Buffer');
+}
+
+export function toHtml(input) {
+  return binding.toHtml(sanitizeInput(input));
+}
+
+export function to_html(input) {
+  return toHtml(input);
+}
+
+export function toAst(input) {
+  return binding.toAst(sanitizeInput(input));
+}
+
+export function to_ast(input) {
+  return toAst(input);
+}
+
+export function astSchemaVersion() {
+  return binding.astSchemaVersion ? binding.astSchemaVersion() : binding.AST_SCHEMA_VERSION;
+}
+
+export function ast_schema_version() {
+  return astSchemaVersion();
+}
+
+export const AST_SCHEMA_VERSION = binding.AST_SCHEMA_VERSION ?? 1;
+export const version = typeof binding.version === 'function' ? binding.version() : (binding.version || '0.1.0');
+
+export const actos = {
+  toHtml(input) {
+    return binding.actos.toHtml(sanitizeInput(input));
+  },
+  to_html(input) {
+    return binding.actos.to_html(sanitizeInput(input));
+  },
+  toAst(input) {
+    return binding.actos.toAst(sanitizeInput(input));
+  },
+  to_ast(input) {
+    return binding.actos.to_ast(sanitizeInput(input));
+  },
+  astSchemaVersion,
+  ast_schema_version,
+  AST_SCHEMA_VERSION,
+  version,
+};
+
+export default {
+  toHtml,
+  to_html,
+  toAst,
+  to_ast,
+  astSchemaVersion,
+  ast_schema_version,
+  AST_SCHEMA_VERSION,
+  version,
+  actos,
+};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "markstone",
+  "version": "0.1.0",
+  "description": "Fast, safe Markdown-to-HTML and AST engine with Actos extensions for Node.js and the browser",
+  "type": "module",
+  "main": "index.js",
+  "browser": "browser.js",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "node": {
+        "types": "./index.d.ts",
+        "default": "./fallback.js"
+      },
+      "browser": {
+        "types": "./browser.d.ts",
+        "default": "./browser.js"
+      },
+      "default": {
+        "types": "./index.d.ts",
+        "default": "./fallback.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "browser.js",
+    "browser.d.ts",
+    "fallback.js",
+    "markstone.*.node",
+    "wasm/markstone_wasm.js",
+    "wasm/markstone_wasm.d.ts",
+    "wasm/markstone_wasm_bg.wasm",
+    "wasm/markstone_wasm_bg.wasm.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build:native": "cargo build --release -p markstone-node && cp ../../target/release/libmarkstone_node.so ./markstone.node",
+    "build:wasm": "npx wasm-pack build ../wasm --target web --out-dir ../node/wasm && rm -f wasm/.gitignore",
+    "build": "npm run build:native && npm run build:wasm",
+    "test": "node --test test/index.test.js",
+    "prepack": "node -e \"require('node:fs').copyFileSync('../../LICENSE', 'LICENSE')\""
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^3.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/actos-dev/markstone.git",
+    "directory": "bindings/node"
+  },
+  "keywords": [
+    "markdown",
+    "commonmark",
+    "gfm",
+    "sanitizer",
+    "html",
+    "ast",
+    "actos"
+  ]
+}

package/wasm/README.md

@@ -0,0 +1,5 @@
+# markstone-wasm
+
+WebAssembly crate (`wasm-bindgen`) for markstone: fast, safe Markdown-to-HTML and AST engine with Actos extensions.
+
+Compiled via `wasm-pack` and bundled into the unified `markstone` npm package under `bindings/node/wasm`.

package/wasm/markstone_wasm.d.ts

@@ -0,0 +1,68 @@
+/* tslint:disable */
+/* eslint-disable */
+
+export function actosToAst(input: string): string;
+
+export function actosToHtml(input: string): string;
+
+export function actos_to_ast(input: string): string;
+
+export function actos_to_html(input: string): string;
+
+export function astSchemaVersion(): number;
+
+export function ast_schema_version(): number;
+
+export function toAst(input: string): string;
+
+export function toHtml(input: string): string;
+
+export function to_ast(input: string): string;
+
+export function to_html(input: string): string;
+
+export function version(): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly actosToAst: (a: number, b: number, c: number) => void;
+    readonly actosToHtml: (a: number, b: number, c: number) => void;
+    readonly actos_to_ast: (a: number, b: number, c: number) => void;
+    readonly actos_to_html: (a: number, b: number, c: number) => void;
+    readonly astSchemaVersion: () => number;
+    readonly ast_schema_version: () => number;
+    readonly toAst: (a: number, b: number, c: number) => void;
+    readonly toHtml: (a: number, b: number, c: number) => void;
+    readonly to_ast: (a: number, b: number, c: number) => void;
+    readonly to_html: (a: number, b: number, c: number) => void;
+    readonly version: (a: number) => void;
+    readonly __wbindgen_export: (a: number) => void;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_export2: (a: number, b: number) => number;
+    readonly __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_export4: (a: number, b: number, c: number) => 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>;

package/wasm/markstone_wasm.js

@@ -0,0 +1,532 @@
+/* @ts-self-types="./markstone_wasm.d.ts" */
+
+/**
+ * @param {string} input
+ * @returns {string}
+ */
+export function actosToAst(input) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.actosToAst(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {string} input
+ * @returns {string}
+ */
+export function actosToHtml(input) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.actosToHtml(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {string} input
+ * @returns {string}
+ */
+export function actos_to_ast(input) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.actos_to_ast(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {string} input
+ * @returns {string}
+ */
+export function actos_to_html(input) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.actos_to_html(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @returns {number}
+ */
+export function astSchemaVersion() {
+    const ret = wasm.astSchemaVersion();
+    return ret >>> 0;
+}
+
+/**
+ * @returns {number}
+ */
+export function ast_schema_version() {
+    const ret = wasm.ast_schema_version();
+    return ret >>> 0;
+}
+
+/**
+ * @param {string} input
+ * @returns {string}
+ */
+export function toAst(input) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.toAst(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {string} input
+ * @returns {string}
+ */
+export function toHtml(input) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.toHtml(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {string} input
+ * @returns {string}
+ */
+export function to_ast(input) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.to_ast(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @param {string} input
+ * @returns {string}
+ */
+export function to_html(input) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        const ptr0 = passStringToWasm0(input, wasm.__wbindgen_export2, wasm.__wbindgen_export3);
+        const len0 = WASM_VECTOR_LEN;
+        wasm.to_html(retptr, ptr0, len0);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        var r2 = getDataViewMemory0().getInt32(retptr + 4 * 2, true);
+        var r3 = getDataViewMemory0().getInt32(retptr + 4 * 3, true);
+        var ptr2 = r0;
+        var len2 = r1;
+        if (r3) {
+            ptr2 = 0; len2 = 0;
+            throw takeObject(r2);
+        }
+        deferred3_0 = ptr2;
+        deferred3_1 = len2;
+        return getStringFromWasm0(ptr2, len2);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * @returns {string}
+ */
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+        wasm.version(retptr);
+        var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+        var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+        deferred1_0 = r0;
+        deferred1_1 = r1;
+        return getStringFromWasm0(r0, r1);
+    } finally {
+        wasm.__wbindgen_add_to_stack_pointer(16);
+        wasm.__wbindgen_export4(deferred1_0, deferred1_1, 1);
+    }
+}
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_5d9e815e6fdf150f: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_new_a32a1ab6c6655abe: function(arg0, arg1) {
+            const ret = new Error(getStringFromWasm0(arg0, arg1));
+            return addHeapObject(ret);
+        },
+        __wbg_set_a377297433dfea63: function() { return handleError(function (arg0, arg1, arg2) {
+            const ret = Reflect.set(getObject(arg0), getObject(arg1), getObject(arg2));
+            return ret;
+        }, arguments); },
+        __wbindgen_generic_0000000000000001: function(arg0, arg1) {
+            // Cast intrinsic for `Ref(String) -> Externref`.
+            const ret = getStringFromWasm0(arg0, arg1);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_drop_ref: function(arg0) {
+            takeObject(arg0);
+        },
+    };
+    return {
+        __proto__: null,
+        "./markstone_wasm_bg.js": import0,
+    };
+}
+
+function addHeapObject(obj) {
+    if (heap_next === heap.length) heap.push(heap.length + 1);
+    const idx = heap_next;
+    heap_next = heap[idx];
+
+    heap[idx] = obj;
+    return idx;
+}
+
+function dropObject(idx) {
+    if (idx < 1028) return;
+    heap[idx] = heap_next;
+    heap_next = idx;
+}
+
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function getStringFromWasm0(ptr, len) {
+    return decodeText(ptr >>> 0, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+function getObject(idx) { return heap[idx]; }
+
+function handleError(f, args) {
+    try {
+        return f.apply(this, args);
+    } catch (e) {
+        wasm.__wbindgen_export(addHeapObject(e));
+    }
+}
+
+let heap = new Array(1024).fill(undefined);
+heap.push(undefined, null, true, false);
+
+let heap_next = heap.length;
+
+function passStringToWasm0(arg, malloc, realloc) {
+    if (realloc === undefined) {
+        const buf = cachedTextEncoder.encode(arg);
+        const ptr = malloc(buf.length, 1) >>> 0;
+        getUint8ArrayMemory0().subarray(ptr, ptr + buf.length).set(buf);
+        WASM_VECTOR_LEN = buf.length;
+        return ptr;
+    }
+
+    let len = arg.length;
+    let ptr = malloc(len, 1) >>> 0;
+
+    const mem = getUint8ArrayMemory0();
+
+    let offset = 0;
+
+    for (; offset < len; offset++) {
+        const code = arg.charCodeAt(offset);
+        if (code > 0x7F) break;
+        mem[ptr + offset] = code;
+    }
+    if (offset !== len) {
+        if (offset !== 0) {
+            arg = arg.slice(offset);
+        }
+        ptr = realloc(ptr, len, len = offset + arg.length * 3, 1) >>> 0;
+        const view = getUint8ArrayMemory0().subarray(ptr + offset, ptr + len);
+        const ret = cachedTextEncoder.encodeInto(arg, view);
+
+        offset += ret.written;
+        ptr = realloc(ptr, len, offset, 1) >>> 0;
+    }
+
+    WASM_VECTOR_LEN = offset;
+    return ptr;
+}
+
+function takeObject(idx) {
+    const ret = getObject(idx);
+    dropObject(idx);
+    return ret;
+}
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+cachedTextDecoder.decode();
+const MAX_SAFARI_DECODE_BYTES = 2146435072;
+let numBytesDecoded = 0;
+function decodeText(ptr, len) {
+    numBytesDecoded += len;
+    if (numBytesDecoded >= MAX_SAFARI_DECODE_BYTES) {
+        cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+        cachedTextDecoder.decode();
+        numBytesDecoded = len;
+    }
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+let WASM_VECTOR_LEN = 0;
+
+let wasmModule, wasmInstance, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasmInstance = instance;
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (!module.ok) {
+            throw new Error(`failed to fetch Wasm: ${module.status} ${module.statusText} fetching '${module.url}'`);
+        }
+
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = expectedResponseType(module.type);
+
+                if (validResponse && module.headers.get('Content-Type') !== 'application/wasm') {
+                    console.warn("`WebAssembly.instantiateStreaming` failed because your server does not serve Wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n", e);
+
+                } else { throw e; }
+            }
+        }
+
+        const bytes = await module.arrayBuffer();
+        return await WebAssembly.instantiate(bytes, imports);
+    } else {
+        const instance = await WebAssembly.instantiate(module, imports);
+
+        if (instance instanceof WebAssembly.Instance) {
+            return { instance, module };
+        } else {
+            return instance;
+        }
+    }
+
+    function expectedResponseType(type) {
+        switch (type) {
+            case 'basic': case 'cors': case 'default': return true;
+        }
+        return false;
+    }
+}
+
+function initSync(module) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module !== undefined) {
+        if (Object.getPrototypeOf(module) === Object.prototype) {
+            ({module} = module)
+        } else {
+            console.warn('using deprecated parameters for `initSync()`; pass a single object instead')
+        }
+    }
+
+    const imports = __wbg_get_imports();
+    if (!(module instanceof WebAssembly.Module)) {
+        module = new WebAssembly.Module(module);
+    }
+    const instance = new WebAssembly.Instance(module, imports);
+    return __wbg_finalize_init(instance, module);
+}
+
+async function __wbg_init(module_or_path) {
+    if (wasm !== undefined) return wasm;
+
+
+    if (module_or_path !== undefined) {
+        if (Object.getPrototypeOf(module_or_path) === Object.prototype) {
+            ({module_or_path} = module_or_path)
+        } else {
+            console.warn('using deprecated parameters for the initialization function; pass a single object instead')
+        }
+    }
+
+    if (module_or_path === undefined) {
+        module_or_path = new URL('markstone_wasm_bg.wasm', import.meta.url);
+    }
+    const imports = __wbg_get_imports();
+
+    if (typeof module_or_path === 'string' || (typeof Request === 'function' && module_or_path instanceof Request) || (typeof URL === 'function' && module_or_path instanceof URL)) {
+        module_or_path = fetch(module_or_path);
+    }
+
+    const { instance, module } = await __wbg_load(await module_or_path, imports);
+
+    return __wbg_finalize_init(instance, module);
+}
+
+export { initSync, __wbg_init as default };

package/wasm/markstone_wasm_bg.wasm.d.ts

@@ -0,0 +1,19 @@
+/* tslint:disable */
+/* eslint-disable */
+export const memory: WebAssembly.Memory;
+export const actosToAst: (a: number, b: number, c: number) => void;
+export const actosToHtml: (a: number, b: number, c: number) => void;
+export const actos_to_ast: (a: number, b: number, c: number) => void;
+export const actos_to_html: (a: number, b: number, c: number) => void;
+export const astSchemaVersion: () => number;
+export const ast_schema_version: () => number;
+export const toAst: (a: number, b: number, c: number) => void;
+export const toHtml: (a: number, b: number, c: number) => void;
+export const to_ast: (a: number, b: number, c: number) => void;
+export const to_html: (a: number, b: number, c: number) => void;
+export const version: (a: number) => void;
+export const __wbindgen_export: (a: number) => void;
+export const __wbindgen_add_to_stack_pointer: (a: number) => number;
+export const __wbindgen_export2: (a: number, b: number) => number;
+export const __wbindgen_export3: (a: number, b: number, c: number, d: number) => number;
+export const __wbindgen_export4: (a: number, b: number, c: number) => void;