@rsvelte/compiler 0.2.0 → 0.3.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yuichiro Yamashita
+
+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

@@ -1,182 +1,237 @@
 # rsvelte
 
-A high-performance Rust implementation of the Svelte compiler. Drop-in replacement for `svelte/compiler` with up to 100x performance improvement.
+> **⚠️ Early Stage Project** — This project can compile a wide range of Svelte components and is fully passing the official compiler test suite, but it is still in an early phase of development. APIs, output, and behavior may change without notice. Not yet recommended for production use.
 
-## Installation
+A Rust port of the official Svelte 5 compiler. Targets **100% test compatibility** with `svelte/compiler` and is designed to slot into the [OXC](https://oxc.rs/) JavaScript/TypeScript toolchain.
+
+## Packages
+
+rsvelte ships drop-in replacements for the main pieces of the Svelte toolchain. All packages are published under the `@rsvelte` scope on npm.
+
+| Package | Drop-in for | Status |
+|---|---|---|
+| [`@rsvelte/compiler`](npm/compiler) | [`svelte/compiler`](https://svelte.dev/docs/svelte-compiler) | ✅ 100% test compat ([details](#compatibility)) |
+| [`@rsvelte/svelte2tsx`](npm/svelte2tsx) | [`svelte2tsx`](https://github.com/sveltejs/language-tools/tree/master/packages/svelte2tsx) | ✅ 245 / 245 fixtures |
+| [`@rsvelte/svelte-check`](npm/svelte-check) | [`svelte-check`](https://github.com/sveltejs/language-tools/tree/master/packages/svelte-check) CLI | 🟡 In progress (walker + overlay + tsgo backend) |
+| [`@rsvelte/vite-plugin-svelte`](https://github.com/baseballyama/vite-plugin-svelte/tree/rsvelte) | [`@sveltejs/vite-plugin-svelte`](https://github.com/sveltejs/vite-plugin-svelte) | 🟡 Fork that swaps in the Rust compiler |
+| [`@rsvelte/vite-plugin-svelte-native`](npm/vite-plugin-svelte-native) | — | NAPI bindings consumed by the Vite plugin |
+
+See [`docs/ecosystem-implementation-plan.md`](docs/ecosystem-implementation-plan.md) for the full ecosystem port plan.
+
+## Quick Start
+
+### Node.js
 
 ```bash
 npm install @rsvelte/compiler
 ```
 
-## Usage
-
-### Basic Usage
+Use it as a drop-in replacement for `svelte/compiler`:
 
 ```js
-import { compile, parse, VERSION } from '@rsvelte/compiler';
+import { compile, compileModule, parse } from '@rsvelte/compiler';
 
-const result = compile('<h1>Hello {name}!</h1>', {
-  filename: 'App.svelte',
-  generate: 'client',
+const result = compile('<h1>Hello, {name}!</h1>', {
+  generate: 'client', // or 'server'
+  filename: 'App.svelte'
 });
 
 console.log(result.js.code);
+console.log(result.css?.code);
+
+// Compile a Svelte module (.svelte.js / .svelte.ts)
+const moduleResult = compileModule('export const count = $state(0);', {
+  filename: 'counter.svelte.js'
+});
+
+// Parse into AST
+const ast = parse('<h1>Hello</h1>', { modern: true });
 ```
 
-### With Vite + vite-plugin-svelte
+The API matches the official [`svelte/compiler`](https://svelte.dev/docs/svelte-compiler) — `compile`, `compileModule`, `parse`, and `VERSION` are all available.
+
+### Vite
+
+Use [`@rsvelte/vite-plugin-svelte`](https://github.com/baseballyama/vite-plugin-svelte/tree/rsvelte) — a fork of `@sveltejs/vite-plugin-svelte` that swaps in the Rust compiler:
 
-Use `resolve.alias` to replace the Svelte compiler:
+```bash
+npm install -D @rsvelte/vite-plugin-svelte
+```
 
 ```js
 // vite.config.js
+import { svelte } from '@rsvelte/vite-plugin-svelte';
 import { defineConfig } from 'vite';
-import { svelte } from '@sveltejs/vite-plugin-svelte';
 
 export default defineConfig({
-  resolve: {
-    alias: {
-      'svelte/compiler': '@rsvelte/compiler',
-    },
-  },
-  plugins: [svelte()],
+  plugins: [svelte()]
 });
 ```
 
-## API
-
-### `compile(source, options?)`
+### SvelteKit
 
-Compile a Svelte component to JavaScript.
+SvelteKit imports `@sveltejs/vite-plugin-svelte` internally. Use pnpm `overrides` to redirect it to the rsvelte fork:
 
-```js
-const result = compile(source, {
-  dev: false,
-  generate: 'client', // 'client' | 'server'
-  filename: 'Component.svelte',
-  css: 'external', // 'injected' | 'external'
-  // ... see CompileOptions for all options
-});
+```bash
+pnpm add -D @rsvelte/vite-plugin-svelte
+```
 
-// result.js.code - Generated JavaScript
-// result.js.map - Source map
-// result.css?.code - Generated CSS (if css: 'external')
-// result.css?.map - CSS source map
-// result.warnings - Compiler warnings
-// result.metadata.runes - Whether component uses runes
+```json
+// package.json
+{
+  "pnpm": {
+    "overrides": {
+      "@sveltejs/vite-plugin-svelte": "npm:@rsvelte/vite-plugin-svelte@^0.1.0"
+    }
+  }
+}
 ```
 
-### `compileModule(source, options?)`
+Then run `pnpm install`. No changes to `vite.config.js` or `svelte.config.js` are needed.
 
-Compile a Svelte module (`.svelte.js` / `.svelte.ts`).
+### Rust
 
-```js
-const result = compileModule(source, {
-  dev: false,
-  generate: 'client',
-  filename: 'utils.svelte.js',
-});
+```rust
+use rsvelte::{compile, CompileOptions};
+
+let source = r#"<h1>Hello, {name}!</h1>"#;
+let result = compile(source, CompileOptions::default()).unwrap();
+println!("{}", result.js.code);
 ```
 
-### `parse(source, options?)`
+## Highlights
 
-Parse a Svelte component into an AST.
+- **3,341 / 3,341 in-scope tests passing** — every in-scope category of the official Svelte 5 compiler test suite at 100%
+- **2.1x faster single-threaded, 15.8x faster multi-threaded** vs the official JS compiler
+- **Drop-in replacement** — N-API bindings for seamless use with existing tools (Vite, SvelteKit, …)
+- **WASM build** — runs in the browser (used by the docs playground)
+- **Ecosystem port underway** — `svelte2tsx` already at 100%; `svelte-check` and `vite-plugin-svelte` shim in progress
 
-```js
-const ast = parse('<h1>Hello</h1>', {
-  modern: true, // Use modern AST format
-});
-```
+## Performance
 
-### `preprocess(source, preprocessors, options?)`
+Compile benchmark across 3,654 real Svelte files (average of 3 runs):
 
-Preprocess a Svelte component (async).
+| Runner | Time | Throughput | Speedup |
+|---|---:|---:|---:|
+| **JavaScript (`svelte/compiler`)** | 689 ms | 5,304 files/sec | 1.0× |
+| **Rust (single-threaded)** | 333 ms | 10,986 files/sec | **2.1×** |
+| **Rust (multi-threaded)** | 44 ms | 83,797 files/sec | **15.8×** |
 
-```js
-const processed = await preprocess(source, [
-  {
-    markup({ content, filename }) {
-      return { code: transformedContent };
-    },
-    script({ content, filename }) {
-      return { code: transformedContent };
-    },
-    style({ content, filename }) {
-      return { code: transformedContent };
-    },
-  },
-], { filename: 'App.svelte' });
-```
+> Apple M1 Max · 3,654 files · average of 3 runs. Reproduce locally with `./scripts/bench.sh`.
 
-### `print(ast, options?)`
+A single-threaded **100× speedup** over the JS compiler is one of this project's explicit goals — current numbers are a snapshot, not a ceiling.
 
-Print an AST back to source code.
+## Compatibility
 
-```js
-const ast = parse(source, { modern: true });
-const { code } = print(ast);
-```
+Current compatibility with the official Svelte compiler test suite:
 
-### `parseCss(source)`
+| Test Suite | Pass | Total | Status | Notes |
+|---|---:|---:|---|---|
+| Parser Modern | 22 | 22 | 100% | |
+| Parser Legacy | 82 | 83 | 100% | 1 skipped (acorn vs OXC comment attachment) |
+| Compiler Snapshot | 28 | 28 | 100% | |
+| CSS | 179 | 179 | 100% | |
+| Validator | 324 | 325 | 100% | 1 skipped (`error-mode-warn`) |
+| Compiler Errors | 144 | 144 | 100% | |
+| Runtime Runes | 865 | 865 | 100% | |
+| Runtime Legacy | 1,202 | 1,202 | 100% | |
+| Runtime Browser | 31 | 31 | 100% | |
+| Hydration | 78 | 78 | 100% | |
+| SSR | 82 | 82 | 100% | |
+| Preprocess | 19 | 19 | 100% | |
+| Print | 40 | 40 | 100% | |
+| svelte2tsx | 245 | 245 | 100% | 2 skipped (`expected.error.json` error fixtures) |
+| **Total (in-scope)** | **3,341** | **3,341** | **100%** | |
+| Migrate | 0 | 76 | — | **Out of scope** — rsvelte is a Svelte 5 compiler port, not a 4→5 migrator |
+| Sourcemaps | 0 | 0 | — | No fixtures yet |
 
-Parse CSS into an AST.
+Re-run `pnpm run test-and-update` to refresh these numbers.
 
-### `VERSION`
+## Goals
 
-The compiler version string.
+1. **100% test compatibility** with the official `svelte/compiler` test suite
+2. **100× single-threaded speedup** over the JS compiler via Rust + OXC
+3. **Drop-in replacement** — identical output, N-API bindings, no toolchain changes required
+4. **Ecosystem port** — pluggable into `svelte-check`, `vite-plugin-svelte`, and the wider Svelte tooling chain (see [`docs/ecosystem-implementation-plan.md`](docs/ecosystem-implementation-plan.md))
+5. **OXC integration** — serve as the foundation for Svelte support in OXC's linter, formatter, and bundler ecosystem
 
-```js
-import { VERSION } from '@rsvelte/compiler';
-console.log(VERSION); // "0.1.0"
+## Architecture
+
+The directory structure mirrors `submodules/svelte/packages/svelte/src/compiler/`:
+
+```
+src/compiler/phases/
+├── 1_parse/     # Parsing (Svelte syntax → AST)
+├── 2_analyze/   # Analysis (scope tree, bindings, rune detection)
+└── 3_transform/ # Code generation (AST → JS/CSS, client + SSR)
 ```
 
-## Limitations
+Key design decisions:
 
-### Callback Options Not Supported
+- Memory-efficient AST (u32 positions, `compact_str`)
+- JavaScript parsing / codegen via OXC
+- Direct AST passing between phases — no re-parsing
+- Parallel processing with `rayon`
+- No backward-compat shims for internal APIs — refactor freely
 
-The following options accept JavaScript callback functions and are **not currently supported** in rsvelte. These options will be silently ignored, and the default behavior will be used instead:
+## Development
 
-| Option | Description | Default Behavior |
-|--------|-------------|-----------------|
-| `cssHash` | Custom function to generate CSS hash for scoping | Uses the built-in hash function (same algorithm as the official Svelte compiler default) |
-| `warningFilter` | Function to filter compiler warnings | All warnings are included in the result |
+### Setup
 
-**Why?** rsvelte is implemented in Rust and compiled to a native binary. JavaScript callback functions cannot be directly executed inside the Rust runtime. Supporting these would require crossing the Rust-JavaScript boundary for each invocation, which would negate the performance benefits.
+```bash
+git submodule update --init --recursive
+git config core.hooksPath .githooks
+pnpm install
+pnpm run generate-fixtures   # required before running tests
+```
 
-**Workaround for `warningFilter`:** Filter warnings from the result after compilation:
+### Build & test
 
-```js
-const result = compile(source, options);
-const filteredWarnings = result.warnings.filter(
-  (w) => w.code !== 'a11y-missing-attribute'
-);
+```bash
+cargo build
+cargo test                                          # all tests
+cargo test --release                                # recommended for full runs
+cargo test --test parser_fixtures -- --nocapture    # single suite
+pnpm run compatibility-report                       # generate compatibility JSON
+pnpm run test-and-update                            # refresh report + docs
+./scripts/bench.sh                                  # JS vs Rust benchmark
 ```
 
-**Workaround for `cssHash`:** Currently no workaround. The default hash function is used. If you require a custom hash, please open an issue.
+The pre-commit hook (`.githooks/pre-commit`) runs `cargo fmt` and `cargo clippy` automatically.
+
+### Docker (optional)
+
+A `Dockerfile` and `docker-compose.yml` provide a reproducible toolchain (Rust nightly + Node 22 + pnpm):
+
+```bash
+docker compose up -d
+docker compose exec dev bash
+docker compose exec dev cargo test
+```
+
+VS Code Dev Containers ("Reopen in Container") also works.
+
+### Upgrading Svelte
+
+```bash
+./scripts/upgrade-svelte.sh 5.52.0
+```
 
-### Not Yet Implemented
+Updates the Svelte submodule, rebuilds, regenerates fixtures, and refreshes the compatibility report.
 
-| API | Status |
-|-----|--------|
-| `migrate()` | Not implemented - throws error |
-| `walk()` | Deprecated in Svelte 5 - throws error directing to estree-walker |
+## Known incompatibilities
 
-## Platform Support
+### Parser Legacy: `javascript-comments` (1 test skipped)
 
-rsvelte ships native binaries for the following platforms:
+The official compiler uses acorn and attaches comments to AST nodes as `leadingComments` / `trailingComments`. rsvelte uses OXC, where comments are provided as a separate list. This only affects the legacy AST format (Svelte 4 compatibility mode) and does **not** impact compiled output or runtime behavior.
 
-| Platform | Architecture | Package |
-|----------|-------------|---------|
-| macOS | ARM64 (Apple Silicon) | `@rsvelte/binding-darwin-arm64` |
-| macOS | x64 (Intel) | `@rsvelte/binding-darwin-x64` |
-| Linux | x64 | `@rsvelte/binding-linux-x64-gnu` |
-| Linux | ARM64 | `@rsvelte/binding-linux-arm64-gnu` |
-| Windows | x64 | `@rsvelte/binding-win32-x64-msvc` |
+### Validator: `error-mode-warn` (1 test skipped)
 
-Native binaries are installed automatically via `optionalDependencies`. If no native binary is available for your platform, an error will be thrown at runtime.
+Tests an error-mode option not yet wired through rsvelte's diagnostic pipeline. Compiled output is unaffected.
 
-## Svelte Compatibility
+### svelte2tsx: 2 error-fixture skips
 
-rsvelte targets compatibility with **Svelte 5** (`svelte/compiler`). It passes 100% of the official Svelte compiler test suite (3028/3028 tests).
+Two svelte2tsx fixtures shaped around `expected.error.json` (error-path assertions) are skipped pending a structured error-fixture runner.
 
 ## License
 

package/package.json

@@ -1,45 +1,31 @@
 {
   "name": "@rsvelte/compiler",
-  "version": "0.2.0",
-  "description": "A high-performance Rust implementation of the Svelte compiler - drop-in replacement",
-  "author": "baseballyama",
   "type": "module",
-  "main": "index.cjs",
-  "module": "index.js",
-  "types": "index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "import": "./index.js",
-      "require": "./index.cjs"
-    }
+  "description": "A high-performance Rust implementation of the Svelte compiler",
+  "version": "0.3.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/baseballyama/rsvelte.git"
   },
   "files": [
-    "index.js",
-    "index.cjs",
-    "index.d.ts",
-    "README.md"
+    "svelte_compiler_rust_bg.wasm",
+    "svelte_compiler_rust.js",
+    "svelte_compiler_rust.d.ts"
+  ],
+  "main": "svelte_compiler_rust.js",
+  "homepage": "https://github.com/baseballyama/rsvelte#readme",
+  "types": "svelte_compiler_rust.d.ts",
+  "sideEffects": [
+    "./snippets/*"
   ],
-  "optionalDependencies": {
-    "@rsvelte/binding-darwin-arm64": "0.2.0",
-    "@rsvelte/binding-darwin-x64": "0.1.0",
-    "@rsvelte/binding-linux-x64-gnu": "0.1.0",
-    "@rsvelte/binding-linux-arm64-gnu": "0.1.0",
-    "@rsvelte/binding-win32-x64-msvc": "0.1.0"
-  },
   "keywords": [
     "svelte",
     "compiler",
     "rust",
-    "napi",
-    "performance"
+    "wasm"
   ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/baseballyama/svelte-compiler-rust"
-  },
-  "engines": {
-    "node": ">= 18"
+  "bugs": {
+    "url": "https://github.com/baseballyama/rsvelte/issues"
   }
-}
+}

package/svelte_compiler_rust.d.ts

@@ -0,0 +1,108 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Result of compiling a Svelte component.
+ */
+export class CompileResultWasm {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly css: string;
+    readonly error: string | undefined;
+    readonly js: string;
+    readonly success: boolean;
+}
+
+/**
+ * Result of parsing a Svelte component.
+ */
+export class ParseResultWasm {
+    private constructor();
+    free(): void;
+    [Symbol.dispose](): void;
+    readonly ast: string;
+    readonly error: string | undefined;
+    readonly success: boolean;
+}
+
+/**
+ * Compile a Svelte component to client-side JavaScript.
+ */
+export function compile_client(source: string, name: string): CompileResultWasm;
+
+/**
+ * Compile a Svelte component to server-side JavaScript.
+ */
+export function compile_server(source: string, name: string): CompileResultWasm;
+
+/**
+ * Initialize panic hook for better error messages in the browser console.
+ */
+export function init(): void;
+
+/**
+ * Parse a Svelte component and return the AST as JSON.
+ */
+export function parse_svelte(source: string): ParseResultWasm;
+
+/**
+ * Convert a Svelte component to TypeScript/TSX. Mirrors the napi `svelte2tsx`
+ * shape — `options_json` and the return value are JSON strings so the wasm
+ * boundary stays at primitive types and no bespoke `wasm_bindgen` struct is
+ * needed for every field of `Svelte2TsxResult`.
+ */
+export function svelte2tsx(source: string, options_json: string): string;
+
+/**
+ * Get the version of the compiler.
+ */
+export function version(): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly __wbg_compileresultwasm_free: (a: number, b: number) => void;
+    readonly __wbg_parseresultwasm_free: (a: number, b: number) => void;
+    readonly compile_client: (a: number, b: number, c: number, d: number) => number;
+    readonly compile_server: (a: number, b: number, c: number, d: number) => number;
+    readonly compileresultwasm_css: (a: number) => [number, number];
+    readonly compileresultwasm_error: (a: number) => [number, number];
+    readonly compileresultwasm_js: (a: number) => [number, number];
+    readonly compileresultwasm_success: (a: number) => number;
+    readonly parse_svelte: (a: number, b: number) => number;
+    readonly parseresultwasm_ast: (a: number) => [number, number];
+    readonly parseresultwasm_error: (a: number) => [number, number];
+    readonly parseresultwasm_success: (a: number) => number;
+    readonly svelte2tsx: (a: number, b: number, c: number, d: number) => [number, number];
+    readonly version: () => [number, number];
+    readonly init: () => void;
+    readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_malloc: (a: number, b: number) => number;
+    readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_externrefs: WebAssembly.Table;
+    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>;

package/svelte_compiler_rust.js

@@ -0,0 +1,455 @@
+/* @ts-self-types="./svelte_compiler_rust.d.ts" */
+
+/**
+ * Result of compiling a Svelte component.
+ */
+export class CompileResultWasm {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(CompileResultWasm.prototype);
+        obj.__wbg_ptr = ptr;
+        CompileResultWasmFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        CompileResultWasmFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_compileresultwasm_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get css() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.compileresultwasm_css(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get error() {
+        const ret = wasm.compileresultwasm_error(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * @returns {string}
+     */
+    get js() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.compileresultwasm_js(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {boolean}
+     */
+    get success() {
+        const ret = wasm.compileresultwasm_success(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) CompileResultWasm.prototype[Symbol.dispose] = CompileResultWasm.prototype.free;
+
+/**
+ * Result of parsing a Svelte component.
+ */
+export class ParseResultWasm {
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(ParseResultWasm.prototype);
+        obj.__wbg_ptr = ptr;
+        ParseResultWasmFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        ParseResultWasmFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_parseresultwasm_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get ast() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.parseresultwasm_ast(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get error() {
+        const ret = wasm.parseresultwasm_error(this.__wbg_ptr);
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * @returns {boolean}
+     */
+    get success() {
+        const ret = wasm.parseresultwasm_success(this.__wbg_ptr);
+        return ret !== 0;
+    }
+}
+if (Symbol.dispose) ParseResultWasm.prototype[Symbol.dispose] = ParseResultWasm.prototype.free;
+
+/**
+ * Compile a Svelte component to client-side JavaScript.
+ * @param {string} source
+ * @param {string} name
+ * @returns {CompileResultWasm}
+ */
+export function compile_client(source, name) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.compile_client(ptr0, len0, ptr1, len1);
+    return CompileResultWasm.__wrap(ret);
+}
+
+/**
+ * Compile a Svelte component to server-side JavaScript.
+ * @param {string} source
+ * @param {string} name
+ * @returns {CompileResultWasm}
+ */
+export function compile_server(source, name) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(name, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ret = wasm.compile_server(ptr0, len0, ptr1, len1);
+    return CompileResultWasm.__wrap(ret);
+}
+
+/**
+ * Initialize panic hook for better error messages in the browser console.
+ */
+export function init() {
+    wasm.init();
+}
+
+/**
+ * Parse a Svelte component and return the AST as JSON.
+ * @param {string} source
+ * @returns {ParseResultWasm}
+ */
+export function parse_svelte(source) {
+    const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.parse_svelte(ptr0, len0);
+    return ParseResultWasm.__wrap(ret);
+}
+
+/**
+ * Convert a Svelte component to TypeScript/TSX. Mirrors the napi `svelte2tsx`
+ * shape — `options_json` and the return value are JSON strings so the wasm
+ * boundary stays at primitive types and no bespoke `wasm_bindgen` struct is
+ * needed for every field of `Svelte2TsxResult`.
+ * @param {string} source
+ * @param {string} options_json
+ * @returns {string}
+ */
+export function svelte2tsx(source, options_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(source, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.svelte2tsx(ptr0, len0, ptr1, len1);
+        deferred3_0 = ret[0];
+        deferred3_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+}
+
+/**
+ * Get the version of the compiler.
+ * @returns {string}
+ */
+export function version() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+        const ret = wasm.version();
+        deferred1_0 = ret[0];
+        deferred1_1 = ret[1];
+        return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+        wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+}
+
+function __wbg_get_imports() {
+    const import0 = {
+        __proto__: null,
+        __wbg___wbindgen_throw_be289d5034ed271b: function(arg0, arg1) {
+            throw new Error(getStringFromWasm0(arg0, arg1));
+        },
+        __wbg_error_7534b8e9a36f1ab4: function(arg0, arg1) {
+            let deferred0_0;
+            let deferred0_1;
+            try {
+                deferred0_0 = arg0;
+                deferred0_1 = arg1;
+                console.error(getStringFromWasm0(arg0, arg1));
+            } finally {
+                wasm.__wbindgen_free(deferred0_0, deferred0_1, 1);
+            }
+        },
+        __wbg_new_8a6f238a6ece86ea: function() {
+            const ret = new Error();
+            return ret;
+        },
+        __wbg_stack_0ed75d68575b0f3c: function(arg0, arg1) {
+            const ret = arg1.stack;
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
+        __wbindgen_init_externref_table: function() {
+            const table = wasm.__wbindgen_externrefs;
+            const offset = table.grow(4);
+            table.set(0, undefined);
+            table.set(offset + 0, undefined);
+            table.set(offset + 1, null);
+            table.set(offset + 2, true);
+            table.set(offset + 3, false);
+        },
+    };
+    return {
+        __proto__: null,
+        "./svelte_compiler_rust_bg.js": import0,
+    };
+}
+
+const CompileResultWasmFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_compileresultwasm_free(ptr >>> 0, 1));
+const ParseResultWasmFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_parseresultwasm_free(ptr >>> 0, 1));
+
+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) {
+    ptr = ptr >>> 0;
+    return decodeText(ptr, len);
+}
+
+let cachedUint8ArrayMemory0 = null;
+function getUint8ArrayMemory0() {
+    if (cachedUint8ArrayMemory0 === null || cachedUint8ArrayMemory0.byteLength === 0) {
+        cachedUint8ArrayMemory0 = new Uint8Array(wasm.memory.buffer);
+    }
+    return cachedUint8ArrayMemory0;
+}
+
+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;
+}
+
+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, wasm;
+function __wbg_finalize_init(instance, module) {
+    wasm = instance.exports;
+    wasmModule = module;
+    cachedDataViewMemory0 = null;
+    cachedUint8ArrayMemory0 = null;
+    wasm.__wbindgen_start();
+    return wasm;
+}
+
+async function __wbg_load(module, imports) {
+    if (typeof Response === 'function' && module instanceof Response) {
+        if (typeof WebAssembly.instantiateStreaming === 'function') {
+            try {
+                return await WebAssembly.instantiateStreaming(module, imports);
+            } catch (e) {
+                const validResponse = module.ok && 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('svelte_compiler_rust_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/index.cjs

@@ -1,79 +0,0 @@
-'use strict';
-
-const { createRequire } = require('node:module');
-
-let nativeBinding = null;
-let loadError = null;
-
-const platform = process.platform;
-const arch = process.arch;
-
-const platformPackages = {
-  'darwin-arm64': '@rsvelte/binding-darwin-arm64',
-  'darwin-x64': '@rsvelte/binding-darwin-x64',
-  'linux-x64': '@rsvelte/binding-linux-x64-gnu',
-  'linux-arm64': '@rsvelte/binding-linux-arm64-gnu',
-  'win32-x64': '@rsvelte/binding-win32-x64-msvc',
-};
-
-const key = `${platform}-${arch}`;
-const packageName = platformPackages[key];
-
-if (packageName) {
-  try {
-    nativeBinding = require(packageName);
-  } catch (e) {
-    loadError = e;
-  }
-} else {
-  loadError = new Error(`Unsupported platform: ${key}`);
-}
-
-function getBinding() {
-  if (nativeBinding) return nativeBinding;
-  throw new Error(
-    `rsvelte native binding not available for this platform. ` +
-    `Ensure the correct @rsvelte/binding-* package is installed. ` +
-    `Error: ${loadError?.message}`
-  );
-}
-
-module.exports.compile = function compile(source, options = {}) {
-  return getBinding().compile(source, options);
-};
-
-module.exports.compileModule = function compileModule(source, options = {}) {
-  return getBinding().compileModule(source, options);
-};
-
-module.exports.parse = function parse(source, options = {}) {
-  return getBinding().parse(source, options);
-};
-
-module.exports.preprocess = async function preprocess(source, preprocessor, options = {}) {
-  return getBinding().preprocess(source, preprocessor, options);
-};
-
-module.exports.print = function print(ast, options = {}) {
-  return getBinding().print(ast, options);
-};
-
-module.exports.parseCss = function parseCss(source) {
-  return getBinding().parseCss(source);
-};
-
-module.exports.walk = function walk() {
-  throw new Error(
-    'walk() is deprecated. Use estree-walker instead: https://github.com/Rich-Harris/estree-walker'
-  );
-};
-
-module.exports.migrate = function migrate() {
-  throw new Error('migrate() is not yet implemented in rsvelte.');
-};
-
-try {
-  module.exports.VERSION = nativeBinding?.getVersion?.() ?? '0.2.0';
-} catch {
-  module.exports.VERSION = '0.2.0';
-}

package/index.d.ts

@@ -1,140 +0,0 @@
-export interface CompileOptions {
-  /** Enable dev mode */
-  dev?: boolean;
-  /** Generate client or server code */
-  generate?: 'client' | 'server' | false;
-  /** Component filename */
-  filename?: string;
-  /** Root directory */
-  rootDir?: string;
-  /** Component name */
-  name?: string;
-  /** Enable custom element mode */
-  customElement?: boolean;
-  /** Enable accessors */
-  accessors?: boolean;
-  /** HTML namespace */
-  namespace?: 'html' | 'svg' | 'mathml';
-  /** Enable immutable mode */
-  immutable?: boolean;
-  /** CSS mode */
-  css?: 'injected' | 'external';
-  /**
-   * Custom CSS hash function.
-   *
-   * **Note:** Currently not supported in @rsvelte/compiler. The default hash function
-   * will always be used. See README for details.
-   */
-  cssHash?: (args: { hash: (input: string) => string; css: string; name: string; filename: string | undefined }) => string;
-  /** Preserve HTML comments */
-  preserveComments?: boolean;
-  /** Preserve whitespace */
-  preserveWhitespace?: boolean;
-  /** Enable runes mode */
-  runes?: boolean;
-  /** Disclose compiler version in output */
-  discloseVersion?: boolean;
-  /** Source map configuration */
-  sourcemap?: object | string;
-  /** Output JS filename */
-  outputFilename?: string;
-  /** Output CSS filename */
-  cssOutputFilename?: string;
-  /** Enable HMR */
-  hmr?: boolean;
-  /** Use modern AST */
-  modernAst?: boolean;
-  /**
-   * Warning filter function.
-   *
-   * **Note:** Currently not supported in @rsvelte/compiler. All warnings will be
-   * included. See README for details.
-   */
-  warningFilter?: (warning: Warning) => boolean;
-  /** Experimental options */
-  experimental?: {
-    async?: boolean;
-  };
-  /** Compatibility options */
-  compatibility?: {
-    componentApi?: 4 | 5;
-  };
-}
-
-export interface ModuleCompileOptions {
-  dev?: boolean;
-  generate?: 'client' | 'server' | false;
-  filename?: string;
-  rootDir?: string;
-}
-
-export interface Warning {
-  code: string;
-  message: string;
-  start?: { line: number; column: number; character: number };
-  end?: { line: number; column: number; character: number };
-}
-
-export interface CompileResult {
-  js: { code: string; map: any };
-  css: { code: string; map: any; hasGlobal: boolean } | null;
-  warnings: Warning[];
-  metadata: { runes: boolean };
-  ast?: any;
-}
-
-export interface PrintResult {
-  code: string;
-  map?: any;
-}
-
-export interface Processed {
-  code: string;
-  map?: any;
-  dependencies?: string[];
-}
-
-/**
- * Compile a Svelte component.
- */
-export function compile(source: string, options?: CompileOptions): CompileResult;
-
-/**
- * Compile a Svelte module (.svelte.js / .svelte.ts).
- */
-export function compileModule(source: string, options?: ModuleCompileOptions): CompileResult;
-
-/**
- * Parse a Svelte component into an AST.
- */
-export function parse(source: string, options?: { modern?: boolean; loose?: boolean }): any;
-
-/**
- * Parse CSS.
- */
-export function parseCss(source: string): any;
-
-/**
- * Preprocess a Svelte component.
- */
-export function preprocess(source: string, preprocessor: any | any[], options?: { filename?: string }): Promise<Processed>;
-
-/**
- * Print an AST back to source code.
- */
-export function print(ast: any, options?: any): PrintResult;
-
-/**
- * Compiler version.
- */
-export const VERSION: string;
-
-/**
- * @deprecated Use estree-walker instead.
- */
-export function walk(): never;
-
-/**
- * Not yet implemented in @rsvelte/compiler.
- */
-export function migrate(): never;

package/index.js

@@ -1,133 +0,0 @@
-// rsvelte - High-performance Svelte compiler
-// Native binding with WASM fallback
-
-import { createRequire } from 'node:module';
-
-let nativeBinding = null;
-let loadError = null;
-
-function loadNativeBinding() {
-  const platform = process.platform;
-  const arch = process.arch;
-
-  const platformPackages = {
-    'darwin-arm64': '@rsvelte/binding-darwin-arm64',
-    'darwin-x64': '@rsvelte/binding-darwin-x64',
-    'linux-x64': '@rsvelte/binding-linux-x64-gnu',
-    'linux-arm64': '@rsvelte/binding-linux-arm64-gnu',
-    'win32-x64': '@rsvelte/binding-win32-x64-msvc',
-  };
-
-  const key = `${platform}-${arch}`;
-  const packageName = platformPackages[key];
-
-  if (!packageName) {
-    loadError = new Error(`Unsupported platform: ${key}`);
-    return null;
-  }
-
-  try {
-    const require = createRequire(import.meta.url);
-    return require(packageName);
-  } catch (e) {
-    loadError = e;
-    return null;
-  }
-}
-
-nativeBinding = loadNativeBinding();
-
-function getBinding() {
-  if (nativeBinding) return nativeBinding;
-  throw new Error(
-    `rsvelte native binding not available for this platform. ` +
-    `Ensure the correct @rsvelte/binding-* package is installed. ` +
-    `Error: ${loadError?.message}`
-  );
-}
-
-/**
- * Compile a Svelte component.
- * @param {string} source - Svelte component source code
- * @param {object} [options] - Compilation options
- * @returns {object} Compilation result with js, css, warnings, and metadata
- */
-export function compile(source, options = {}) {
-  return getBinding().compile(source, options);
-}
-
-/**
- * Compile a Svelte module (.svelte.js/.svelte.ts).
- * @param {string} source - Module source code
- * @param {object} [options] - Compilation options
- * @returns {object} Compilation result
- */
-export function compileModule(source, options = {}) {
-  return getBinding().compileModule(source, options);
-}
-
-/**
- * Parse a Svelte component into an AST.
- * @param {string} source - Svelte component source code
- * @param {object} [options] - Parse options
- * @returns {object} AST
- */
-export function parse(source, options = {}) {
-  return getBinding().parse(source, options);
-}
-
-/**
- * Preprocess a Svelte component.
- * NOTE: This is an async function.
- * @param {string} source - Svelte component source code
- * @param {object|object[]} preprocessor - Preprocessor(s)
- * @param {object} [options] - Preprocess options
- * @returns {Promise<object>} Preprocessed result
- */
-export async function preprocess(source, preprocessor, options = {}) {
-  return getBinding().preprocess(source, preprocessor, options);
-}
-
-/**
- * Print an AST back to source code.
- * @param {object} ast - Svelte AST
- * @param {object} [options] - Print options
- * @returns {object} Print result with code and map
- */
-export function print(ast, options = {}) {
-  return getBinding().print(ast, options);
-}
-
-/**
- * Parse CSS.
- * @param {string} source - CSS source code
- * @returns {object} Parsed CSS AST
- */
-export function parseCss(source) {
-  return getBinding().parseCss(source);
-}
-
-/**
- * @deprecated Use estree-walker instead.
- */
-export function walk() {
-  throw new Error(
-    'walk() is deprecated. Use estree-walker instead: https://github.com/Rich-Harris/estree-walker'
-  );
-}
-
-/**
- * Not yet implemented in rsvelte.
- */
-export function migrate() {
-  throw new Error('migrate() is not yet implemented in rsvelte.');
-}
-
-/** Compiler version string. */
-let _version;
-try {
-  _version = nativeBinding?.getVersion?.() ?? '0.2.0';
-} catch {
-  _version = '0.2.0';
-}
-export const VERSION = _version;