Merge pull request #11 from mist-go/massive-update
Restructure documentation into categorized guide and internals
This commit is contained in:
@@ -1,135 +0,0 @@
|
||||
---
|
||||
title: Classes
|
||||
description: Unified data and behavior with Java-style organization and Rust-powered execution.
|
||||
icon: Shapes
|
||||
---
|
||||
|
||||
Classes in Mist bridge the gap between Java's organizational structure and Rust's performance. They group fields, constructors, and methods within a single cohesive block, using C-style method signatures with `&self` for the instance parameter.
|
||||
|
||||
## Basic Syntax
|
||||
|
||||
A class groups fields and methods together. Fields use semicolons and the `Type name` convention. Methods use C-style syntax with `&self` as the first parameter for shared access.
|
||||
|
||||
```mist
|
||||
pub class Logger {
|
||||
String prefix;
|
||||
|
||||
pub void info(&self, message str&) {
|
||||
self.log(LogLevel::Info, message);
|
||||
}
|
||||
|
||||
void log(&self, LogLevel level, message str&) {
|
||||
println!("{level} {} {}", self.prefix, message);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## The Constructor
|
||||
|
||||
Mist uses the explicit `constructor` keyword for initialization:
|
||||
|
||||
```mist
|
||||
pub constructor() {
|
||||
self.prefix = "default".to_string();
|
||||
}
|
||||
```
|
||||
|
||||
Constructors can take parameters:
|
||||
|
||||
```mist
|
||||
pub constructor(String prefix) {
|
||||
self.prefix = prefix;
|
||||
}
|
||||
```
|
||||
|
||||
## Instance Methods & `&self`
|
||||
|
||||
Methods use `&self` (shared reference) or `&mut self` (mutable reference) as the first parameter.
|
||||
|
||||
```mist
|
||||
pub void warning(&self, message str&) {
|
||||
self.log(LogLevel::Warning, message);
|
||||
}
|
||||
|
||||
pub void reset(&mut self) {
|
||||
self.prefix = String::new();
|
||||
}
|
||||
```
|
||||
|
||||
## Inheritance
|
||||
|
||||
Classes support single inheritance with the `:` syntax. Use `super = Super::new()` in the constructor to call the parent constructor. Override methods by placing `override(Parent)` after the parameter list.
|
||||
|
||||
```mist
|
||||
pub class Animal {
|
||||
pub String name;
|
||||
|
||||
constructor() {
|
||||
self.name = "Rex".to_string();
|
||||
}
|
||||
|
||||
pub String speak(&self) {
|
||||
"Unknown".to_string()
|
||||
}
|
||||
}
|
||||
|
||||
pub class Dog : Animal {
|
||||
constructor() {
|
||||
super = Super::new();
|
||||
}
|
||||
|
||||
pub String speak(&self) override(Animal) {
|
||||
"Woof!".to_string()
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Trait Implementations
|
||||
|
||||
Traits can be implemented directly inside a class body:
|
||||
|
||||
```mist
|
||||
pub class Dog : Animal {
|
||||
constructor() {
|
||||
self.name = name;
|
||||
}
|
||||
|
||||
pub String speak(&self) override(Animal) {
|
||||
"Woof!".to_string()
|
||||
}
|
||||
|
||||
impl std::fmt::Display {
|
||||
Result<(), std::fmt::Error> fmt(&self, std::fmt::Formatter<'_> mut& f) {
|
||||
write!(f, "🐾 {}", self.name)
|
||||
}
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Generics
|
||||
|
||||
Classes support generic type parameters:
|
||||
|
||||
```mist
|
||||
pub class Container<T> {
|
||||
T value;
|
||||
|
||||
constructor(T val) {
|
||||
self.value = val;
|
||||
}
|
||||
|
||||
pub &T get(&self) {
|
||||
&self.value
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Key Characteristics
|
||||
|
||||
- **Unified Scope**: Data and behavior live in one class block.
|
||||
- **C-Style Methods**: Return type before name — no `fn` keyword.
|
||||
- **`&self` Parameter**: The self reference is explicit and uses `&` syntax.
|
||||
- **Inheritance**: Single inheritance with `override(Parent)` for polymorphic dispatch.
|
||||
- **Encapsulation**: Visibility modifiers (`pub`) control API exposure.
|
||||
- **Inline Impl**: Traits can be implemented directly within the class body.
|
||||
- **Zero-Cost Classes**: Under the hood, Mist desugars these into idiomatic Rust structs and implementation blocks.
|
||||
@@ -1,87 +0,0 @@
|
||||
---
|
||||
title: Enums
|
||||
description: Defining algebraic data types with Mist's type-first convention.
|
||||
icon: Layers
|
||||
---
|
||||
|
||||
Enums in Mist serve as powerful algebraic data types (ADTs), maintaining the exact behavior and safety of Rust enums while using parentheses for tuple variants and `Type name` for struct-like fields.
|
||||
|
||||
## Basic Syntax
|
||||
|
||||
An enum can contain unit variants, tuple variants (with types in parentheses), or struct-like variants.
|
||||
|
||||
```mist
|
||||
pub enum TaskState {
|
||||
Pending,
|
||||
InProgress,
|
||||
Completed,
|
||||
Failed {
|
||||
String reason,
|
||||
i32 code,
|
||||
},
|
||||
}
|
||||
```
|
||||
|
||||
## Variant Types
|
||||
|
||||
Mist supports all standard variant shapes:
|
||||
|
||||
```mist
|
||||
enum OptionInt {
|
||||
None, // Unit
|
||||
Some(i32), // Tuple (parentheses)
|
||||
}
|
||||
|
||||
enum Shape {
|
||||
Circle { i32 radius }, // Struct-like
|
||||
Rect { i32 w, i32 h },
|
||||
}
|
||||
```
|
||||
|
||||
### Instantiation & Matching
|
||||
|
||||
Tuple variants are created and matched with parentheses:
|
||||
|
||||
```mist
|
||||
let x = OptionInt::Some(42);
|
||||
|
||||
match x {
|
||||
OptionInt::None => { println!("none"); }
|
||||
OptionInt::Some(v) => { println!("{}", v); }
|
||||
}
|
||||
```
|
||||
|
||||
Struct variants use brace notation:
|
||||
|
||||
```mist
|
||||
let c = Shape::Circle {
|
||||
radius: 5,
|
||||
};
|
||||
|
||||
match c {
|
||||
Shape::Circle { radius } => { println!("{}", radius); }
|
||||
Shape::Rect { .. } => { /* ignore */ }
|
||||
}
|
||||
```
|
||||
|
||||
## Generics
|
||||
|
||||
Enums declare generics and lifetimes in angle brackets after the name.
|
||||
|
||||
```mist
|
||||
pub enum Validation<'a, T> {
|
||||
Valid(T),
|
||||
Invalid {
|
||||
&'a str message,
|
||||
u32 error_id,
|
||||
},
|
||||
}
|
||||
```
|
||||
|
||||
## Key Characteristics
|
||||
|
||||
- **Consistent Declaration**: Struct-like variants use `Type name` order, consistent with Mist structs.
|
||||
- **Parentheses Tuples**: Tuple variants use `()` syntax, consistent with Rust.
|
||||
- **Rust-Native ADTs**: Enums compile directly to Rust enums, allowing exhaustive pattern matching and zero-cost abstraction.
|
||||
- **Shared Visibility**: The `pub` modifier at the enum level exports all variants.
|
||||
- **Comma-Separated Members**: Fields within struct-like variants are separated by commas.
|
||||
@@ -1,102 +0,0 @@
|
||||
---
|
||||
title: Functions
|
||||
description: Defining execution blocks with C-style ergonomics and Rust-powered safety.
|
||||
icon: SquareFunction
|
||||
---
|
||||
|
||||
Functions are the primary unit of execution in Mist, using C-style syntax with the return type before the name. The last expression in a block is implicitly returned.
|
||||
|
||||
## Basic Syntax
|
||||
|
||||
Functions place the return type before the name, followed by parameters in parentheses.
|
||||
|
||||
```mist
|
||||
void greet() {
|
||||
println!("Hello!");
|
||||
}
|
||||
|
||||
i32 add(i32 a, i32 b) {
|
||||
a + b
|
||||
}
|
||||
```
|
||||
|
||||
## Visibility & Modules
|
||||
|
||||
Functions use `pub` for public visibility. Files declare a module with `pub module name;`.
|
||||
|
||||
```mist
|
||||
pub module utils;
|
||||
|
||||
pub i32 get_version() {
|
||||
1
|
||||
}
|
||||
|
||||
pub void process() {
|
||||
// ...
|
||||
}
|
||||
```
|
||||
|
||||
## Mutable Parameters
|
||||
|
||||
Use `mut` after the type to allow reassignment within the function body.
|
||||
|
||||
```mist
|
||||
void update_score(i32 mut current_score, i32 bonus) {
|
||||
current_score = current_score + bonus;
|
||||
}
|
||||
```
|
||||
|
||||
## Methods & `&self`
|
||||
|
||||
Methods take `&self` (immutable) or `&mut self` (mutable) as the first parameter.
|
||||
|
||||
```mist
|
||||
struct Counter {
|
||||
i32 value,
|
||||
}
|
||||
|
||||
impl Counter {
|
||||
pub i32 get(&self) {
|
||||
self.value
|
||||
}
|
||||
|
||||
pub void increment(&mut self) {
|
||||
self.value += 1;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Closures
|
||||
|
||||
Closures are anonymous functions defined with arrow syntax:
|
||||
|
||||
```mist
|
||||
let add = (a, b) => a + b;
|
||||
add(2, 3);
|
||||
|
||||
// With a block body
|
||||
let greet = (name str&) => {
|
||||
println!("Hello {}", name);
|
||||
};
|
||||
```
|
||||
|
||||
## Attributes & Metadata
|
||||
|
||||
Metadata is applied via the `#[attr]` syntax directly above the declaration.
|
||||
|
||||
```mist
|
||||
#[inline]
|
||||
pub i32 clamp(i32 value, i32 min, i32 max) {
|
||||
if value < min { min }
|
||||
else if value > max { max }
|
||||
else { value }
|
||||
}
|
||||
```
|
||||
|
||||
## Key Characteristics
|
||||
|
||||
- **C-Style Syntax**: Return type before name — no `fn` keyword.
|
||||
- **Implicit Returns**: The final expression in a block is automatically returned.
|
||||
- **`&self` / `&mut self`**: Explicit self parameter in method definitions.
|
||||
- **Closure Support**: Arrow syntax `(params) => expr` for anonymous functions.
|
||||
- **Zero-Cost Mapping**: Every function maps directly to a Rust `fn`.
|
||||
@@ -1,85 +0,0 @@
|
||||
---
|
||||
title: Modules & Imports
|
||||
description: Organizing code across files with module declarations and path-based imports.
|
||||
icon: FolderTree
|
||||
---
|
||||
|
||||
Mist organizes code through a file-system based module system with explicit path imports.
|
||||
|
||||
## Module Declarations
|
||||
|
||||
Each `.mist` file declares itself as a module with `pub module name;` at the top. A `package.mist` file acts like `mod.rs` — it is the entry point for its directory.
|
||||
|
||||
```mist
|
||||
// src/utils/helper.mist
|
||||
pub module helper;
|
||||
|
||||
pub void greet() {
|
||||
println!("Hello!");
|
||||
}
|
||||
```
|
||||
|
||||
```mist
|
||||
// src/utils/package.mist
|
||||
pub module utils;
|
||||
// This module exports submodules and items
|
||||
```
|
||||
|
||||
## Imports
|
||||
|
||||
Use the `use` keyword with a path to bring items from other modules or external crates into scope.
|
||||
|
||||
```mist
|
||||
use std::fs;
|
||||
use std::process;
|
||||
use std::path::Path;
|
||||
use std::collections::HashMap;
|
||||
|
||||
// Import specific items
|
||||
use my_module::Helper;
|
||||
```
|
||||
|
||||
### Visibility
|
||||
|
||||
Items can be re-exported with a visibility modifier on the import:
|
||||
|
||||
```mist
|
||||
pub use internal::format;
|
||||
```
|
||||
|
||||
## Sidefiles
|
||||
|
||||
Any non-`.mist` file in `src/` (e.g., `.rs`, `.toml`, data files) is treated as a **sidefile** — it is copied directly into the output directory `.mist/src/` during transpilation. This allows you to keep Rust helper files or configuration alongside your Mist source.
|
||||
|
||||
```text
|
||||
src/
|
||||
├── main.mist
|
||||
├── helper.rs # copied to .mist/src/helper.rs
|
||||
└── config/
|
||||
└── data.json # copied to .mist/src/config/data.json
|
||||
```
|
||||
|
||||
## Project Structure
|
||||
|
||||
A typical Mist project looks like this:
|
||||
|
||||
```
|
||||
my-project/
|
||||
├── Cargo.toml
|
||||
├── Mist.toml
|
||||
├── src/
|
||||
│ ├── main.mist
|
||||
│ ├── my_api/
|
||||
│ │ ├── package.mist
|
||||
│ │ ├── methods.mist
|
||||
│ │ └── utils.mist
|
||||
└── .mist/
|
||||
└── src/
|
||||
├── main.rs
|
||||
└── my_api/
|
||||
├── mod.rs
|
||||
├── methods.rs
|
||||
└── utils.rs
|
||||
```
|
||||
|
||||
The `.mist/src/` directory contains the transpiled Rust output.
|
||||
@@ -1,67 +0,0 @@
|
||||
---
|
||||
title: Pointers & References
|
||||
description: Explicit memory access with postfix reference syntax and Rust-native safety.
|
||||
icon: MousePointer2
|
||||
---
|
||||
|
||||
Mist uses a postfix `&` syntax for reference types. While familiar from C++, these references adhere strictly to Rust's ownership and borrowing rules.
|
||||
|
||||
## Basic Syntax
|
||||
|
||||
Reference types are written with `&` after the type. Use `mut&` for mutable references. The `&` and `&mut` operators create references from values.
|
||||
|
||||
```mist
|
||||
i32 x = 42;
|
||||
i32& r = &x;
|
||||
|
||||
let mut y = 42;
|
||||
i32 mut& r = &mut y;
|
||||
*r = 100;
|
||||
```
|
||||
|
||||
In function parameters:
|
||||
|
||||
```mist
|
||||
void increment(i32 mut& value, i32& limit) {
|
||||
if *value < *limit {
|
||||
*value = *value + 1;
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Lifetimes
|
||||
|
||||
Lifetimes are placed before the type in the `&` suffix:
|
||||
|
||||
```mist
|
||||
pub struct Inspector<'a> {
|
||||
&'a str target,
|
||||
&'a mut u32 counter,
|
||||
}
|
||||
```
|
||||
|
||||
## In Classes
|
||||
|
||||
Methods use `&self` for immutable access and `&mut self` for mutable access:
|
||||
|
||||
```mist
|
||||
pub class Logger {
|
||||
String prefix;
|
||||
|
||||
pub void info(&self, message str&) {
|
||||
println!("{}", message);
|
||||
}
|
||||
|
||||
pub void reset(&mut self) {
|
||||
self.prefix = String::new();
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Key Characteristics
|
||||
|
||||
- **Postfix Reference Syntax**: `T&` for shared references, `T mut&` for mutable references.
|
||||
- **Explicit Intent**: The `mut&` syntax clearly distinguishes read-only from writable references.
|
||||
- **Visual Consistency**: Lifetimes (`'a`) are placed before the type in `&'a T`.
|
||||
- **Safety Guaranteed**: The Mist compiler enforces Rust's borrow checker.
|
||||
- **Zero Overhead**: Mist references compile to identical machine code as Rust references.
|
||||
@@ -1,84 +0,0 @@
|
||||
---
|
||||
title: Structs
|
||||
description: Data modeling with Mist's type-first field convention.
|
||||
icon: Form
|
||||
---
|
||||
|
||||
Structs in Mist follow the same structural logic as Rust, with fields using the language-wide `Type name` convention and comma-separated grouping.
|
||||
|
||||
## Basic Syntax
|
||||
|
||||
A struct is defined by its name followed by a block of fields. Each field places the type before the identifier.
|
||||
|
||||
```mist
|
||||
pub struct Task {
|
||||
pub String name,
|
||||
pub TaskState state,
|
||||
pub i32 executions,
|
||||
}
|
||||
```
|
||||
|
||||
## Visibility
|
||||
|
||||
Use the `pub` modifier to make the struct or its individual fields accessible from other modules.
|
||||
|
||||
```mist
|
||||
pub struct NetworkNode {
|
||||
pub u32 id,
|
||||
str& address,
|
||||
}
|
||||
```
|
||||
|
||||
## Instantiation
|
||||
|
||||
Structs are instantiated using standard brace syntax.
|
||||
|
||||
```mist
|
||||
let task = Task {
|
||||
name: "Initialize".to_string(),
|
||||
state: TaskState::Pending,
|
||||
executions: 0,
|
||||
};
|
||||
```
|
||||
|
||||
## Mutation
|
||||
|
||||
Use `let mut` to allow field reassignment.
|
||||
|
||||
```mist
|
||||
let mut p = Point {
|
||||
x: 1,
|
||||
y: 2,
|
||||
};
|
||||
p.x = 100;
|
||||
```
|
||||
|
||||
## Destructuring
|
||||
|
||||
Struct patterns use `let` with the struct name and field bindings:
|
||||
|
||||
```mist
|
||||
let p = Point {
|
||||
x: 3,
|
||||
y: 4,
|
||||
};
|
||||
let Point { x, y } = p;
|
||||
```
|
||||
|
||||
## Generics
|
||||
|
||||
Generics and lifetimes are declared in angle brackets after the struct name.
|
||||
|
||||
```mist
|
||||
pub struct Buffer<'a, T> {
|
||||
&'a T data,
|
||||
usize len,
|
||||
}
|
||||
```
|
||||
|
||||
## Key Characteristics
|
||||
|
||||
- **Type-First Declaration**: Fields use `Type name` order, consistent with function parameters and variable declarations.
|
||||
- **Comma-Separated Members**: Fields are separated by commas, maintaining a clean delimiter style.
|
||||
- **Rust Compatibility**: Maps 1:1 to Rust structs, ensuring zero-cost abstraction and full ecosystem interoperability.
|
||||
- **Direct Visibility**: The `pub` modifier controls access at the struct and field level.
|
||||
@@ -1,70 +0,0 @@
|
||||
---
|
||||
title: Traits
|
||||
description: Defining shared behavior and contracts with Mist's signature ergonomics.
|
||||
icon: Sparkles
|
||||
---
|
||||
|
||||
Traits in Mist define a set of methods that a type must implement, facilitating polymorphism and shared behavior. Method signatures use C-style syntax with `&self` for the instance parameter.
|
||||
|
||||
## Defining a Trait
|
||||
|
||||
A trait lists method signatures using return-type-first syntax, with `&self` as the instance parameter.
|
||||
|
||||
```mist
|
||||
pub trait Drawable {
|
||||
void draw(&self);
|
||||
str& metadata(&self);
|
||||
}
|
||||
```
|
||||
|
||||
## Implementing a Trait
|
||||
|
||||
Use `impl Trait for Type` to provide implementations:
|
||||
|
||||
```mist
|
||||
impl Drawable for Task {
|
||||
void draw(&self) {
|
||||
println!("Drawing task: {}", self.name);
|
||||
}
|
||||
|
||||
str& metadata(&self) {
|
||||
self.name
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Default Implementations
|
||||
|
||||
Traits can provide default behavior for methods that implementing types may override:
|
||||
|
||||
```mist
|
||||
pub trait Identifiable {
|
||||
u32 get_id(&self);
|
||||
|
||||
bool is_valid(&self) {
|
||||
self.get_id() > 0
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
## Super-traits
|
||||
|
||||
A trait can require another trait using the colon `:` syntax:
|
||||
|
||||
```mist
|
||||
pub trait Speak {
|
||||
String speak(&self);
|
||||
}
|
||||
|
||||
pub trait Greet : Speak {
|
||||
String greet(&self);
|
||||
}
|
||||
```
|
||||
|
||||
## Key Characteristics
|
||||
|
||||
- **C-Style Signatures**: Return type before name — no `fn` keyword.
|
||||
- **Explicit Context**: Methods use `&self` as the first parameter, mapping directly to Rust's reference rules.
|
||||
- **Default Methods**: Traits can provide default implementations.
|
||||
- **Super-traits**: Colon syntax for expressing trait requirements.
|
||||
- **Static Dispatch**: By default, Mist traits leverage Rust's zero-cost generics and monomorphization.
|
||||
@@ -0,0 +1,48 @@
|
||||
---
|
||||
title: Compiler Architecture
|
||||
description: High-level pipeline overview of the Mist compiler and crate organization.
|
||||
icon: Building2
|
||||
---
|
||||
|
||||
### Pipeline Overview
|
||||
|
||||
The Mist compiler operates in distinct phases:
|
||||
|
||||
```
|
||||
Source (.mist)
|
||||
│
|
||||
▼
|
||||
┌─────────────┐
|
||||
│ Lexer │ (pest PEG grammar)
|
||||
│ & Parser │
|
||||
└─────────────┘
|
||||
│ AST
|
||||
▼
|
||||
┌─────────────┐
|
||||
│ Semantics │ (field init checking)
|
||||
└─────────────┘
|
||||
│
|
||||
▼
|
||||
┌─────────────┐
|
||||
│ Codegen │ (AST → Rust source)
|
||||
└─────────────┘
|
||||
│ .rs + .map.json
|
||||
▼
|
||||
┌─────────────┐
|
||||
│ cargo │ (Rust compilation)
|
||||
└─────────────┘
|
||||
│
|
||||
▼
|
||||
Binary / Library
|
||||
```
|
||||
|
||||
### Crate Organization
|
||||
|
||||
The compiler is written in Rust and Mist itself, organized into four main crates:
|
||||
|
||||
| Crate | Language | Role |
|
||||
|-------|----------|------|
|
||||
| **mist-parser** | Rust | PEG parsing via pest, AST construction, semantic checks, position mapping |
|
||||
| **mist-codegen** | Rust | AST → Rust source code generation |
|
||||
| **mist-analyzer** | Rust | Language server bridging mist-editor ↔ rust-analyzer |
|
||||
| **mist-api** | Mist | Orchestrates transpilation, module tree building, cargo invocation, error remapping |
|
||||
@@ -0,0 +1,32 @@
|
||||
---
|
||||
title: Attributes
|
||||
description: Inner and outer attributes for modules, items, and metadata.
|
||||
icon: Hash
|
||||
---
|
||||
|
||||
Inner attributes apply to the containing module:
|
||||
|
||||
```mist
|
||||
#![allow(unused_variables)]
|
||||
```
|
||||
|
||||
Outer attributes apply to the next item:
|
||||
|
||||
```mist
|
||||
#[derive(Debug, Clone)]
|
||||
struct Point {
|
||||
i32 x,
|
||||
i32 y,
|
||||
}
|
||||
|
||||
#[test]
|
||||
void my_test()
|
||||
{
|
||||
assert_eq!(1, 1);
|
||||
}
|
||||
```
|
||||
|
||||
Attribute syntax:
|
||||
- `#[path]`
|
||||
- `#[path = literal]`
|
||||
- `#[path(item1, item2, ...)]`
|
||||
@@ -0,0 +1,69 @@
|
||||
---
|
||||
title: Classes
|
||||
description: Class declarations, constructors, inheritance, virtual dispatch, and the override keyword.
|
||||
icon: Shapes
|
||||
---
|
||||
|
||||
Mist introduces `class` as syntactic sugar for a Rust struct with a virtual method table (vtable).
|
||||
|
||||
```mist
|
||||
pub class Animal {
|
||||
str& name,
|
||||
|
||||
pub constructor(str& name)
|
||||
{
|
||||
self.name = name;
|
||||
}
|
||||
|
||||
pub void speak(&self)
|
||||
{
|
||||
println!("...");
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
Class fields can have default initializers:
|
||||
|
||||
```mist
|
||||
class Player {
|
||||
i32 health = 100,
|
||||
str& name,
|
||||
}
|
||||
```
|
||||
|
||||
### Inheritance
|
||||
|
||||
```mist
|
||||
class Dog : Animal {
|
||||
pub constructor(str& name)
|
||||
{
|
||||
super(name);
|
||||
}
|
||||
|
||||
void speak(&self) override
|
||||
{
|
||||
println!("Woof!");
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
The `override` keyword supports explicit base class targeting (Required if overriding a nested parent):
|
||||
|
||||
```mist
|
||||
void speak(&self) override(Animal)
|
||||
{
|
||||
println!("Woof!");
|
||||
}
|
||||
```
|
||||
|
||||
### Under the Hood
|
||||
|
||||
A class `Dog : Animal` generates:
|
||||
|
||||
1. A Rust struct with a `_super: Animal` field (or `_vptr: &'static [*const c_void]` for root classes)
|
||||
2. A vtable constant with function pointers for each public method
|
||||
3. An `impl` block with `Deref<Target = Animal>` and `DerefMut`
|
||||
4. Method trampolines (`__m_<name>`) that are dispatched through the vtable
|
||||
5. A `new()` constructor that initializes via `MaybeUninit` and calls the user's `constructor(&mut self)`
|
||||
|
||||
The vtable is unified: parent entries are copied, overridden entries replace parent slots, and new methods are appended.
|
||||
@@ -0,0 +1,87 @@
|
||||
---
|
||||
title: Control Flow
|
||||
description: If/else, while, for, c-style for, loop, match, break, continue, and return.
|
||||
icon: ArrowLeftRight
|
||||
---
|
||||
|
||||
### If/Else
|
||||
|
||||
```mist
|
||||
if condition {
|
||||
// body
|
||||
} else if other_condition {
|
||||
// body
|
||||
} else {
|
||||
// body
|
||||
}
|
||||
```
|
||||
|
||||
Conditions must be parenthesized: `if (expr) { }` or `if expr_no_struct { }` (struct literals require parentheses).
|
||||
|
||||
Used as an expression:
|
||||
|
||||
```mist
|
||||
let x = if true { 1 } else { 2 };
|
||||
```
|
||||
|
||||
### While
|
||||
|
||||
```mist
|
||||
while condition {
|
||||
// body
|
||||
}
|
||||
```
|
||||
|
||||
### For
|
||||
|
||||
```mist
|
||||
for pattern in iterator {
|
||||
// body
|
||||
}
|
||||
|
||||
for i in 0 .. 10 {
|
||||
// body
|
||||
}
|
||||
```
|
||||
|
||||
### C-Style For
|
||||
|
||||
```mist
|
||||
for (let mut i = 0; i < 10; i++) {
|
||||
// body
|
||||
}
|
||||
```
|
||||
|
||||
### Loop
|
||||
|
||||
```mist
|
||||
loop {
|
||||
// infinite loop
|
||||
}
|
||||
```
|
||||
|
||||
### Match
|
||||
|
||||
```mist
|
||||
match value {
|
||||
pattern1 => expr,
|
||||
pattern2 => {
|
||||
// block body
|
||||
}
|
||||
pattern3 | pattern4 => expr,
|
||||
}
|
||||
```
|
||||
|
||||
### Break / Continue
|
||||
|
||||
```mist
|
||||
break;
|
||||
continue;
|
||||
```
|
||||
|
||||
### Return
|
||||
|
||||
```mist
|
||||
return;
|
||||
return value;
|
||||
```
|
||||
@@ -0,0 +1,58 @@
|
||||
---
|
||||
title: Functions
|
||||
description: Function declarations, self parameters, return types, and unsafe functions.
|
||||
icon: SquareFunction
|
||||
---
|
||||
|
||||
```mist
|
||||
// Return type is `void` (unit)
|
||||
void greet(str& name)
|
||||
{
|
||||
println!("Hello, {name}");
|
||||
}
|
||||
|
||||
// With return type
|
||||
i32 add(i32 a, i32 b)
|
||||
{
|
||||
return a + b;
|
||||
}
|
||||
|
||||
// Expression body (last expression is the return value)
|
||||
i32 square(i32 x)
|
||||
{
|
||||
x * x
|
||||
}
|
||||
|
||||
// Public function
|
||||
pub i32 multiply(i32 a, i32 b)
|
||||
{
|
||||
a * b
|
||||
}
|
||||
|
||||
// Generic function
|
||||
T identity<T>(T value)
|
||||
{
|
||||
value
|
||||
}
|
||||
|
||||
// Unsafe function
|
||||
unsafe i32 dangerous()
|
||||
{
|
||||
42
|
||||
}
|
||||
```
|
||||
|
||||
Function syntax: `[pub] [void | <type>] <name>[<generics>](<params>) [override] { <body> }`
|
||||
|
||||
Functions use **Allman brace style** (opening brace on the next line).
|
||||
|
||||
### Self Parameter
|
||||
|
||||
Methods can take `self`, `mut self`, `&self`, `&mut self` additionally with lifetimes:
|
||||
|
||||
```mist
|
||||
pub void set_value(&mut self, i32 v)
|
||||
{
|
||||
self.value = v;
|
||||
}
|
||||
```
|
||||
@@ -0,0 +1,39 @@
|
||||
---
|
||||
title: Generics
|
||||
description: Generic functions, structs, enums, trait bounds, and lifetimes.
|
||||
icon: Braces
|
||||
---
|
||||
|
||||
```mist
|
||||
// Generic function
|
||||
T id<T>(T x)
|
||||
{
|
||||
x
|
||||
}
|
||||
|
||||
// Generic struct
|
||||
struct Pair<A, B> {
|
||||
A first,
|
||||
B second,
|
||||
}
|
||||
|
||||
// Generic enum
|
||||
enum Result<T, E> {
|
||||
Ok(T),
|
||||
Err(E),
|
||||
}
|
||||
|
||||
// Generic with trait bounds
|
||||
T max<T : Ord>(T a, T b)
|
||||
{
|
||||
if a > b { a } else { b }
|
||||
}
|
||||
|
||||
// Lifetime generics
|
||||
void process<'a>(&'a str& data)
|
||||
{
|
||||
// ...
|
||||
}
|
||||
```
|
||||
|
||||
Generic syntax uses `<` `>` delimiters. Lifetimes are prefixed with `'`.
|
||||
@@ -0,0 +1,33 @@
|
||||
---
|
||||
title: Modules & Imports
|
||||
description: Module declarations, imports, re-exports, and module resolution rules.
|
||||
icon: FolderTree
|
||||
---
|
||||
|
||||
Mist's module system was created to fix Rust's dreaded parent-declared module system, files declare themselves and their publicity via `pub module my_mod;` as the first statement.
|
||||
|
||||
|
||||
```mist
|
||||
// Declare a module
|
||||
pub module foo;
|
||||
|
||||
// Import
|
||||
use std::collections::HashMap;
|
||||
|
||||
// Re-exporting import (alias)
|
||||
pub use my_module::MyType;
|
||||
```
|
||||
|
||||
### Module Resolution
|
||||
|
||||
Mist maps the module tree to Rust's module system:
|
||||
|
||||
| Mist Path | Rust Output |
|
||||
|------------------------------|------------------------------|
|
||||
| `src/main.mist` | `.mist/src/main.rs` |
|
||||
| `src/utils/package.mist` | `.mist/src/utils/mod.rs` |
|
||||
| `pub module foo;` | `.mist/src/foo.rs` |
|
||||
|
||||
A `package.mist` file acts as a directory's module root, analogous to `mod.rs`, but it's not required, as long as the directory contains `.mist` files, it will auto generate `mod.rs`.
|
||||
|
||||
#### *💡 Tip*: File names don't matter, `module my_mod` determines the name.
|
||||
@@ -0,0 +1,98 @@
|
||||
---
|
||||
title: Operators, Macros & Closures
|
||||
description: Binary, prefix, and postfix operators, macro calls, and closure expressions.
|
||||
icon: Plus
|
||||
---
|
||||
|
||||
### Binary Operators
|
||||
|
||||
| Operator | Description |
|
||||
|----------|----------------------|
|
||||
| `+` | Addition |
|
||||
| `-` | Subtraction |
|
||||
| `*` | Multiplication |
|
||||
| `/` | Division |
|
||||
| `%` | Modulus |
|
||||
| `==` | Equality |
|
||||
| `!=` | Inequality |
|
||||
| `<` | Less than |
|
||||
| `>` | Greater than |
|
||||
| `<=` | Less or equal |
|
||||
| `>=` | Greater or equal |
|
||||
| `&&` | Logical AND |
|
||||
| `\|\|` | Logical OR |
|
||||
| `&` | Bitwise AND |
|
||||
| `\|` | Bitwise OR |
|
||||
| `^` | Bitwise XOR |
|
||||
| `<<` | Left shift |
|
||||
| `>>` | Right shift |
|
||||
| `=` | Assignment |
|
||||
| `+=` | Add assign |
|
||||
| `-=` | Subtract assign |
|
||||
| `*=` | Multiply assign |
|
||||
| `/=` | Divide assign |
|
||||
| `%=` | Modulus assign |
|
||||
| `&=` | Bitwise AND assign |
|
||||
| `\|=` | Bitwise OR assign |
|
||||
| `^=` | Bitwise XOR assign |
|
||||
| `<<=` | Left shift assign |
|
||||
| `>>=` | Right shift assign |
|
||||
| `..` | Range (exclusive) |
|
||||
| `..=` | Range (inclusive) |
|
||||
| `->` | Pointer write |
|
||||
|
||||
### Prefix Operators
|
||||
|
||||
| Operator | Description |
|
||||
|----------|-------------------|
|
||||
| `*` | Dereference |
|
||||
| `&` | Reference |
|
||||
| `&mut` | Mutable reference |
|
||||
| `!` | Logical NOT |
|
||||
| `-` | Numeric negation |
|
||||
|
||||
### Postfix Operators
|
||||
|
||||
| Operator | Description |
|
||||
|------------|----------------------|
|
||||
| `.field` | Field access |
|
||||
| `.0` | Tuple field access |
|
||||
| `()` | Function call |
|
||||
| `[]` | Index |
|
||||
| `{ f: v }` | Struct literal |
|
||||
| `as Type` | Type cast |
|
||||
| `?` | Try (error prop) |
|
||||
| `++` | Increment |
|
||||
| `--` | Decrement |
|
||||
| `!()` | Macro call (paren) |
|
||||
| `![]` | Macro call (bracket) |
|
||||
| `!{}` | Macro call (brace) |
|
||||
|
||||
### Macros
|
||||
|
||||
Mist reuses Rust's macro system directly:
|
||||
|
||||
```mist
|
||||
println!("hello");
|
||||
assert_eq!(a, b);
|
||||
vec![1, 2, 3];
|
||||
```
|
||||
|
||||
Macro calls use `!` followed by parentheses, brackets, or braces.
|
||||
|
||||
### Closures
|
||||
|
||||
```mist
|
||||
let add = (a, b) => a + b;
|
||||
let result = add(2, 3); // 5
|
||||
|
||||
f64 fn() square = (x) => x * x;
|
||||
```
|
||||
|
||||
Closures can have explicit return types:
|
||||
|
||||
```mist
|
||||
let transform = i32 (x) => {
|
||||
x * 2
|
||||
};
|
||||
```
|
||||
@@ -0,0 +1,41 @@
|
||||
---
|
||||
title: Patterns
|
||||
description: Pattern matching with literals, tuples, structs, named tuples, wildcards, and mutable bindings.
|
||||
icon: Split
|
||||
---
|
||||
|
||||
```mist
|
||||
// Literal patterns
|
||||
match x {
|
||||
1 => "one",
|
||||
2 => "two",
|
||||
_ => "other",
|
||||
}
|
||||
|
||||
// Tuple patterns
|
||||
let (a, b) = (1, 2);
|
||||
|
||||
// Struct patterns
|
||||
match value {
|
||||
Point { x, y } => x + y,
|
||||
Point { x: 0, y } => y,
|
||||
_ => 0,
|
||||
}
|
||||
|
||||
// Named tuple patterns (newtype)
|
||||
let MyType(value) = my_var;
|
||||
|
||||
// Wildcard / etc
|
||||
let _ = get_side_effect();
|
||||
match x {
|
||||
1 => ...,
|
||||
.. => ..., // rest / etc
|
||||
}
|
||||
|
||||
// Mutable binding in pattern
|
||||
let mut x = 42;
|
||||
match ref_to_option {
|
||||
Some(mut value) => value += 1,
|
||||
None => {},
|
||||
}
|
||||
```
|
||||
@@ -0,0 +1,47 @@
|
||||
---
|
||||
title: Structs & Enums
|
||||
description: Defining structs and enums with named, tuple, and struct variants.
|
||||
icon: Box
|
||||
---
|
||||
|
||||
### Structs
|
||||
|
||||
```mist
|
||||
pub struct Point {
|
||||
i32 x,
|
||||
i32 y,
|
||||
}
|
||||
|
||||
pub struct Generic<T> {
|
||||
T value,
|
||||
}
|
||||
```
|
||||
|
||||
Fields can be public or private:
|
||||
|
||||
```mist
|
||||
struct User {
|
||||
pub str& name,
|
||||
i32 age, // private
|
||||
}
|
||||
```
|
||||
|
||||
### Enums
|
||||
|
||||
```mist
|
||||
pub enum Option<T> {
|
||||
Some(T),
|
||||
None,
|
||||
}
|
||||
|
||||
pub enum Message {
|
||||
Quit,
|
||||
Move(i32, i32),
|
||||
Write { str& content, i32 length },
|
||||
}
|
||||
```
|
||||
|
||||
Enum variants can be:
|
||||
- **Named** — `Variant`
|
||||
- **Tuple** — `Variant(T1, T2)`
|
||||
- **Struct** — `Variant { T1 field1, T2 field2 }`
|
||||
@@ -0,0 +1,45 @@
|
||||
---
|
||||
title: Syntax Overview
|
||||
description: Comments, literals, identifiers, and keywords in Mist.
|
||||
icon: Code
|
||||
---
|
||||
|
||||
### Comments
|
||||
|
||||
```mist
|
||||
// Line comments only
|
||||
```
|
||||
|
||||
### Literals
|
||||
|
||||
```mist
|
||||
42 // Integer
|
||||
3.14 // Float
|
||||
true // Boolean
|
||||
false // Boolean
|
||||
"hello" // String
|
||||
(1, true, "x") // Tuple
|
||||
```
|
||||
|
||||
### Identifiers & Keywords
|
||||
|
||||
Keywords are reserved and cannot be used as identifiers:
|
||||
|
||||
`if`, `else`, `fn`, `for`, `while`, `match`, `return`, `break`, `continue`, `struct`, `enum`, `class`, `trait`, `impl`, `use`, `pub`, `mut`, `let`, `true`, `false`, `dyn`, `loop`, `unsafe`, `override`, `const`, `type`
|
||||
|
||||
Identifiers follow the pattern `[a-zA-Z_][a-zA-Z0-9_]*`.
|
||||
|
||||
### Visibility
|
||||
|
||||
```mist
|
||||
// Private (default)
|
||||
void internal() { }
|
||||
|
||||
// Public
|
||||
pub void external() { }
|
||||
|
||||
// Public to specific path
|
||||
pub(crate) void crate_only() { }
|
||||
pub(super) void parent_only() { }
|
||||
pub(my::module) void module_only() { }
|
||||
```
|
||||
@@ -0,0 +1,42 @@
|
||||
---
|
||||
title: Traits & Impls
|
||||
description: Defining traits, trait bounds, and implementation blocks.
|
||||
icon: Puzzle
|
||||
---
|
||||
|
||||
### Traits
|
||||
|
||||
```mist
|
||||
pub trait Drawable {
|
||||
void draw(&self);
|
||||
}
|
||||
|
||||
pub trait Comparable<T> : Eq {
|
||||
i32 cmp(&self, T other);
|
||||
}
|
||||
```
|
||||
|
||||
Trait requirements are specified after `:`:
|
||||
|
||||
```mist
|
||||
trait MyTrait : SuperTrait + OtherTrait {
|
||||
void required_method(&self);
|
||||
void another(&self);
|
||||
}
|
||||
```
|
||||
|
||||
### Impl Blocks
|
||||
|
||||
```mist
|
||||
impl MyType {
|
||||
void method(&self) { }
|
||||
}
|
||||
|
||||
impl Trait for MyType {
|
||||
void method(&self) { }
|
||||
}
|
||||
|
||||
impl<T> GenericTrait<T> for MyType {
|
||||
void method(&self, T value) { }
|
||||
}
|
||||
```
|
||||
@@ -0,0 +1,47 @@
|
||||
---
|
||||
title: Types
|
||||
description: The Mist type system including references, pointers, tuples, function types, and trait objects.
|
||||
icon: Type
|
||||
---
|
||||
|
||||
### Type System
|
||||
|
||||
```mist
|
||||
i32 // Path type
|
||||
str& // Reference type
|
||||
i32 mut& // Mutable reference
|
||||
i32 'a& // Reference with lifetime
|
||||
i32 unsafe& // Const pointer
|
||||
i32 mut unsafe& // Mutable pointer
|
||||
(i32, bool) // Tuple type
|
||||
bool fn(i32) // Function pointer type
|
||||
bool Fn(i32) // Closure trait (Fn)
|
||||
bool FnMut(i32) // Closure trait (FnMut)
|
||||
bool FnOnce(i32) // Closure trait (FnOnce)
|
||||
dyn Trait // Trait object
|
||||
void // Unit type (maps to Rust's ())
|
||||
'lifetime // Lifetime
|
||||
```
|
||||
|
||||
Type expressions can be composed:
|
||||
|
||||
```mist
|
||||
type_expr = { (void | path_type | tuple_type | dyn_type) ~ (unsafe_ref_type | ref_type | fn_type)* }
|
||||
```
|
||||
|
||||
This means types are written left-to-right naturally:
|
||||
|
||||
```mist
|
||||
i32& // &i32
|
||||
i32 mut& // &mut i32
|
||||
i32 'a& // &'a i32
|
||||
bool fn(i32) // fn(i32) -> bool
|
||||
```
|
||||
|
||||
### Type Aliases
|
||||
|
||||
```mist
|
||||
type MyInt = i32;
|
||||
|
||||
type Result<T> = std::result::Result<T, str&>;
|
||||
```
|
||||
@@ -0,0 +1,30 @@
|
||||
---
|
||||
title: Variables
|
||||
description: Variable declarations, mutability, type annotations, and destructuring.
|
||||
icon: Variable
|
||||
---
|
||||
|
||||
```mist
|
||||
let x = 42; // Type-inferred immutable
|
||||
let mut y = 10; // Mutable variable
|
||||
i32 z = 100; // Explicit type annotation
|
||||
str& s = "hello"; // Typed string reference
|
||||
bool b = true; // Typed boolean
|
||||
f64 f = 3.14; // Typed float
|
||||
let (a, b) = (1, "two"); // Destructuring
|
||||
let (x, (y, z)) = (1, (2, 3)); // Nested destructuring
|
||||
```
|
||||
|
||||
Variable declarations follow either of two forms:
|
||||
|
||||
```mist
|
||||
let <pattern> [= <expr>];
|
||||
<type> <pattern> [= <expr>];
|
||||
```
|
||||
|
||||
### Const and Static
|
||||
|
||||
```mist
|
||||
const MAX: i32 = 100;
|
||||
static NAME: str& = "hello";
|
||||
```
|
||||
+25
-41
@@ -11,7 +11,7 @@ Mist is currently distributed as a Cargo crate. To get started, you'll need to h
|
||||
Run the following command to install the Mist toolchain:
|
||||
|
||||
```bash title="Terminal"
|
||||
cargo install [email protected].7-alpha.0
|
||||
cargo install [email protected].8-alpha.0
|
||||
```
|
||||
|
||||
> (ℹ) For a more streamlined development experience, Install the following VSCode extensions:
|
||||
@@ -26,36 +26,15 @@ mist version
|
||||
|
||||
---
|
||||
|
||||
## 2. Setting Up Your Cargo Project
|
||||
|
||||
Mist works alongside Cargo to handle the heavy lifting. Use `cargo new` or `cargo init` to scaffold a new project:
|
||||
|
||||
```bash title="Terminal"
|
||||
cargo new my-mist-app
|
||||
cd my-mist-app
|
||||
## 2. Setting Up Your Mist Project
|
||||
```bash
|
||||
mist new mist-hello-world
|
||||
```
|
||||
or
|
||||
```bash
|
||||
mist init
|
||||
```
|
||||
|
||||
This creates a `src/main.mist` and wires up the output directory (`.mist/src/`) in your `Cargo.toml`.
|
||||
|
||||
### 3. Adding mist to your Cargo project
|
||||
|
||||
Mist needs a `Mist.toml` in the root of the project (Alongside `Cargo.toml`) to know what to transpile as the main file (eg. main.mist, lib.mist).
|
||||
|
||||
```toml title="Mist.toml"
|
||||
# main.mist is now the main package
|
||||
package = "main.mist"
|
||||
|
||||
# Side packages that work as cargo binaries
|
||||
packages = []
|
||||
```
|
||||
|
||||
Source files go in `src/` and the transpiled output goes to `.mist/src/`. Non-Mist files in `src/` (e.g. Rust sidecar files) are copied through as-is.
|
||||
|
||||
---
|
||||
|
||||
## 4. Your First Program
|
||||
|
||||
Create a new file at `src/main.mist` and add the following code:
|
||||
|
||||
```mist title="src/main.mist"
|
||||
void main() {
|
||||
@@ -63,13 +42,10 @@ void main() {
|
||||
}
|
||||
```
|
||||
|
||||
### Build and Run
|
||||
### 3. Build and Run
|
||||
|
||||
```bash title="Terminal"
|
||||
mist run # or: mist r
|
||||
mist build # or: mist b
|
||||
mist check # or: mist c
|
||||
mist transpile # or: mist t
|
||||
mist run
|
||||
```
|
||||
|
||||
---
|
||||
@@ -78,10 +54,18 @@ mist transpile # or: mist t
|
||||
|
||||
| Command | Alias | Description |
|
||||
| -------------------- | ----- | ----------------------------------------------- |
|
||||
| `mist init` | | Initializes a new Mist project (Deprecated) |
|
||||
| `mist run` | `r` | Runs the project in the current directory |
|
||||
| `mist build` | `b` | Builds the project in the current directory |
|
||||
| `mist transpile` | `t` | Transpiles the project in the current directory |
|
||||
| `mist check` | `c` | Checks the project in the current directory |
|
||||
| `mist version` | `-v` | Prints the compiler version |
|
||||
| `mist help` | `-h` | Prints this message |
|
||||
| mist run |r| |run the project |
|
||||
| mist build |b| |build the project |
|
||||
| mist transpile |t |transpile the project |
|
||||
| mist check |c |check the project |
|
||||
| mist test| |test the project |
|
||||
| mist publish| |publish the project |
|
||||
| mist bench| |benchmark the project |
|
||||
| mist doc| |build documentation |
|
||||
| mist fix| |automatically fix warnings |
|
||||
| mist clippy| |lint the project |
|
||||
| mist clean| |clean build artifacts |
|
||||
| mist init| |initialize a project in the current folder |
|
||||
| mist new| |create a new project |
|
||||
| mist version|-v |print the compiler version |
|
||||
| mist help|-h |print this message |
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
---
|
||||
title: Builder & Error Remapping
|
||||
description: How Mist invokes cargo and remaps Rust compiler errors back to Mist source locations.
|
||||
icon: Bug
|
||||
---
|
||||
|
||||
The builder module (`builder.mist` in the `mist_api` crate) wraps `cargo` to:
|
||||
|
||||
1. Spawn `cargo` with `--message-format=json`
|
||||
2. Parse JSON compiler messages
|
||||
3. For each diagnostic span, look up the corresponding `.map.json` file
|
||||
4. Remap Rust line/column to Mist line/column using the mapping
|
||||
5. Display errors/warnings with Mist source locations and context lines
|
||||
|
||||
```rust
|
||||
pub fn build(args: Vec<String>, root: PathBuf) -> bool {
|
||||
// Spawn cargo with JSON output
|
||||
// Parse CompilerMessage for each span
|
||||
// Look up rev_mapper::Mapping from .map.json
|
||||
// Remap to Mist positions
|
||||
// Print diagnostics
|
||||
}
|
||||
```
|
||||
|
||||
### Diagnostic Output
|
||||
|
||||
Errors and warnings are displayed with Mist source context:
|
||||
|
||||
```
|
||||
src/main.mist:10:5
|
||||
Error: mismatched types
|
||||
let x: i32 = "hello";
|
||||
^^^^^^^
|
||||
```
|
||||
@@ -0,0 +1,53 @@
|
||||
---
|
||||
title: Code Generation
|
||||
description: How the Mist AST is translated into Rust source code, including class vtables and position mapping.
|
||||
icon: Wrench
|
||||
---
|
||||
|
||||
The code generator converts the Mist AST into Rust source code directly — no intermediate representation.
|
||||
|
||||
### Key files
|
||||
|
||||
- `src/lib.rs` — `RustCodegen` struct with output buffer, indentation tracking, `Mapping` for position translation
|
||||
- `src/top_level.rs` — Generates Rust for top-level items (structs, enums, traits, functions, impls, imports, type aliases, const/static)
|
||||
- `src/statement.rs` — Generates Rust for statements and blocks
|
||||
- `src/expr.rs` — Generates Rust for expressions (literals, paths, binary ops, closures, arrays, prefix/postfix)
|
||||
- `src/class_decl.rs` — Class-specific code generation (struct + vtable + impl blocks + Deref)
|
||||
|
||||
### Codegen Design
|
||||
|
||||
The `RustCodegen` maintains:
|
||||
- A string `output` buffer
|
||||
- An `indent` level (4 spaces per level)
|
||||
- A `Mapping` that records `(RustMap, MistMap)` pairs for source position remapping
|
||||
- A current `position` tracker (`RustMap(line, column)`)
|
||||
|
||||
Generation follows the `GenRust` trait:
|
||||
|
||||
```rust
|
||||
pub trait GenRust {
|
||||
fn gen_rust(&self, ctx: &mut Context, cg: &mut RustCodegen);
|
||||
}
|
||||
```
|
||||
|
||||
And `GetRust` for simple string-returning types:
|
||||
|
||||
```rust
|
||||
pub trait GetRust {
|
||||
fn get_rust(&self) -> String;
|
||||
}
|
||||
```
|
||||
|
||||
The `Context` carries optional expression path information for class `super` / `Super` resolution.
|
||||
|
||||
### Class Codegen
|
||||
|
||||
Classes are the most complex codegen path. `ClassProcessedData` analyzes a class declaration and emits:
|
||||
|
||||
1. **Struct declaration** — `struct ClassName<G> { pub _super: Parent, pub field1: T1, ... }` (or `_vptr` for root classes)
|
||||
2. **Vtable constants** — Index constants `__FN_METHOD` and a `__V_TABLE` static array of function pointers. For inherited classes, parent vtable entries are copied and overridden entries replaced.
|
||||
3. **Constructor** — `pub fn new(...) -> Self` that creates an uninitialized instance via `MaybeUninit`, sets the vtable pointer, writes field defaults, calls `self.constructor(...)`, and returns `this`
|
||||
4. **Method trampolines** — Public methods with `self` get wrapper functions `__m_method` stored in the vtable, plus virtual dispatch methods
|
||||
5. **Override support** — Methods marked `override` are validated at compile time via generated test code
|
||||
6. **Deref impls** — `impl Deref<Target = Parent> for Child` and `DerefMut` for inherited classes
|
||||
7. **Impl declarations** — Inner `impl` blocks are rewritten to use the self type
|
||||
@@ -0,0 +1,55 @@
|
||||
---
|
||||
title: LSP Support
|
||||
description: How the Mist Language Server bridges editor requests through rust-analyzer.
|
||||
icon: Server
|
||||
---
|
||||
|
||||
The Mist Language Server Protocol implementation runs a headless `rust-analyzer` instance and bridges Mist editor requests to Rust positions.
|
||||
|
||||
### Architecture
|
||||
|
||||
```
|
||||
Editor (LSP client)
|
||||
│
|
||||
▼
|
||||
┌─────────────────────┐
|
||||
│ mist-analyzer │
|
||||
│ (Rust + Mist) │
|
||||
└─────────────────────┘
|
||||
│ ▲
|
||||
│ JSON-RPC │
|
||||
▼ │
|
||||
┌─────────────────────┐
|
||||
│ rust-analyzer │
|
||||
│ (headless child) │
|
||||
└─────────────────────┘
|
||||
```
|
||||
|
||||
### Flow
|
||||
|
||||
1. Editor sends Mist file edits to `mist-analyzer` via LSP
|
||||
2. `mist-analyzer` transpiles Mist to Rust
|
||||
3. The transpiled Rust is forwarded to the headless `rust-analyzer` process
|
||||
4. For goto-definition, hover, and completion, a unique marker token is injected at the cursor position
|
||||
5. The transpiled output with the marker is sent to `rust-analyzer`
|
||||
6. The marker position is located in the response
|
||||
7. Results are mapped back to Mist positions using the `rev_mapper`
|
||||
|
||||
### Key Features
|
||||
|
||||
- **Full document sync** — Open, change, save, close
|
||||
- **Go to definition** — Maps through transpiled Rust positions
|
||||
- **Completions** — Supports trigger characters `:`, `.`, `'`, `(`
|
||||
- **Hover** — Type information and docs
|
||||
- **Diagnostics** — Real-time errors from transpilation failures and Rust compilation
|
||||
- **Formatting** — Document formatting support
|
||||
- **Auto-import** — Automatically inserts `pub module <name>;` when new `.mist` files are created
|
||||
- **File watching** — Monitors `**/*.mist` for new files
|
||||
|
||||
### Diagnostic Remapping
|
||||
|
||||
When a transpilation error occurs in the `mist-analyzer`:
|
||||
|
||||
1. Parse errors are converted to `Diagnostic` with Mist source positions
|
||||
2. Semantic errors (uninitialized class fields) use the stored line/column
|
||||
3. Rust compiler errors are remapped via the `Mapping` system back to Mist positions
|
||||
@@ -0,0 +1,76 @@
|
||||
---
|
||||
title: Parsing
|
||||
description: PEG grammar structure, AST design, and how Mist source code is parsed.
|
||||
icon: FileCode
|
||||
---
|
||||
|
||||
The parser is built with [pest](https://pest.rs), a PEG parser generator. Grammar rules are defined in `grammar.pest` (693 rules).
|
||||
|
||||
### Key files
|
||||
|
||||
- `grammar.pest` — PEG grammar defining the entire language syntax
|
||||
- `src/parser/common/` — Parse rule → AST conversions for expressions, statements, types, declarations
|
||||
- `src/parser/items/` — Parse rule → AST conversions for top-level items (structs, enums, classes, functions, traits, impls, attributes)
|
||||
- `src/ast/` — AST node types (expr.rs, statement.rs, top_level.rs)
|
||||
- `src/error.rs` — Error types (PreAst parsing errors, Ast generation errors)
|
||||
|
||||
### Parsing entry points
|
||||
|
||||
```rust
|
||||
// Parse a complete program
|
||||
pub fn parse<'a>(source: &'a str) -> Result<Program, ParseError<'a>>
|
||||
|
||||
// Parse only the module declaration
|
||||
pub fn parse_module<'a>(source: &'a str) -> Result<Option<(Visibility, Identifier)>, ParseError<'a>>
|
||||
```
|
||||
|
||||
### Grammar Structure
|
||||
|
||||
The grammar follows a layered approach:
|
||||
|
||||
1. **Lexical rules** (silent) — `WHITESPACE`, `COMMENT`, `identifier`, `integer`, `float`, `string_lit`
|
||||
2. **Primary expressions** — literals, paths, tuples, arrays, closures, control flow
|
||||
3. **Term** — prefix operators + primary + postfix operators
|
||||
4. **Expression** — terms joined by binary operators (via Pratt parser)
|
||||
5. **Statements** — variable declarations, control flow (`if`, `while`, `for`, `match`, `loop`), blocks
|
||||
6. **Top-level items** — functions, structs, enums, classes, traits, impls, type aliases, imports, module declarations, constants
|
||||
|
||||
### AST Structure
|
||||
|
||||
The AST preserves source positions via `Spanned<T>`:
|
||||
|
||||
```rust
|
||||
pub struct Spanned<T> {
|
||||
pub line: usize,
|
||||
pub column: usize,
|
||||
pub item: T,
|
||||
}
|
||||
```
|
||||
|
||||
Top-level items are wrapped as:
|
||||
|
||||
```rust
|
||||
pub struct TopLevel(pub Spanned<TopLevelKind>, pub Vec<Attribute>);
|
||||
```
|
||||
|
||||
Expressions use a fix-point representation for prefix/postfix operators:
|
||||
|
||||
```rust
|
||||
Expression::Fix {
|
||||
initial: Box<Expression>,
|
||||
prefixes: Vec<Prefix>,
|
||||
postfixes: Vec<Postfix>,
|
||||
}
|
||||
```
|
||||
|
||||
Binary expressions use Pratt parsing for correct precedence:
|
||||
|
||||
```rust
|
||||
Expression::Binary {
|
||||
lhs: Box<Expression>,
|
||||
op: String,
|
||||
rhs: Box<Expression>,
|
||||
}
|
||||
```
|
||||
|
||||
All operators are left-associative with a single precedence level.
|
||||
@@ -0,0 +1,31 @@
|
||||
---
|
||||
title: Position Mapping
|
||||
description: Bidirectional mapping between Mist source positions and Rust output positions for error remapping and LSP features.
|
||||
icon: Map
|
||||
---
|
||||
|
||||
Mist maintains a bidirectional mapping between Mist source positions and Rust output positions. This is essential for:
|
||||
|
||||
1. **Error remapping** — Rust compiler errors point to the correct Mist source location
|
||||
2. **LSP features** — Go-to-definition, hover, and completion work from Mist source
|
||||
|
||||
### Data Structure
|
||||
|
||||
The mapping is stored as pairs:
|
||||
|
||||
```rust
|
||||
pub struct Mapping {
|
||||
pub mist_path: PathBuf,
|
||||
pub map: HashSet<(RustMap, MistMap)>,
|
||||
}
|
||||
```
|
||||
|
||||
- `RustMap(usize, usize)` — line/column in generated Rust
|
||||
- `MistMap(usize, usize)` — line/column in original Mist
|
||||
|
||||
### Mapping Lifecycle
|
||||
|
||||
1. **Codegen** — Each `Spanned<T>` AST node records its Mist position and the current Rust position in the codegen output buffer via `GenSpanTranslation`
|
||||
2. **Persistence** — The mapping is serialized to `<output>.map.json` alongside the transpiled `.rs` output
|
||||
3. **Build-time remapping** — The builder reads `.map.json` to remap `cargo` diagnostics back to Mist positions
|
||||
4. **LSP remapping** — Both Mist→Rust and Rust→Mist direction queries are supported via `find()` and `find_by_mist()`
|
||||
@@ -0,0 +1,36 @@
|
||||
---
|
||||
title: Semantic Analysis
|
||||
description: Class field initialization verification and the GetMutability analysis system.
|
||||
icon: SearchCheck
|
||||
---
|
||||
|
||||
The semantic checker (`semantics.rs`) performs class field initialization analysis. When a class has a constructor, it verifies that every declared field is mutated (directly or indirectly via method calls) within the constructor body.
|
||||
|
||||
### Field Initialization
|
||||
|
||||
The primary semantic check ensures all class fields are initialized in the constructor:
|
||||
|
||||
```mist
|
||||
class Player {
|
||||
i32 health,
|
||||
str& name,
|
||||
|
||||
pub constructor(str& name)
|
||||
{
|
||||
self.name = name;
|
||||
// Error: field 'health' is uninitialized
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### How It Works
|
||||
|
||||
The `GetMutability` trait tracks which identifiers are mutated:
|
||||
|
||||
1. Collects all identifiers that get `&mut` references
|
||||
2. Tracks `self.field = value` patterns
|
||||
3. Follows method calls that might initialize fields (transitively)
|
||||
4. Ensures all conditional branches initialize the same fields (intersection semantics)
|
||||
5. `super` assignments count for `_super` field initialization
|
||||
|
||||
If any field is uninitialized after the analysis, a `SemanticError` is reported with the field's source position.
|
||||
@@ -0,0 +1,61 @@
|
||||
---
|
||||
title: Transpilation Pipeline
|
||||
description: How Mist source files are discovered, transpiled to Rust, and cached.
|
||||
icon: Repeat
|
||||
---
|
||||
|
||||
The transpiler (`transpiler.mist` in `mist_api`) orchestrates the full pipeline.
|
||||
|
||||
### Pipeline
|
||||
|
||||
1. Read `Mist.toml` configuration
|
||||
2. Build a `Module` tree from the filesystem (discovering `package.mist` files)
|
||||
3. For each module:
|
||||
a. Parse Mist source
|
||||
b. Run semantic checks
|
||||
c. Generate Rust code and position mapping
|
||||
d. Write `.rs` file and `.map.json` file
|
||||
4. Recursively transpile included crates
|
||||
|
||||
### Module Tree
|
||||
|
||||
The `Module` struct represents the file-to-module mapping:
|
||||
|
||||
```rust
|
||||
pub class Module {
|
||||
pub String name;
|
||||
pub PathBuf path;
|
||||
pub Vec<Module> children;
|
||||
|
||||
pub constructor(PathBuf mist_path, MistConfig& config) { ... }
|
||||
pub bool is_package(&self) { ... }
|
||||
pub PathBuf output_dir(&self, PathBuf& parent_dir) { ... }
|
||||
pub PathBuf output_path(&self, PathBuf& parent_dir, ...) { ... }
|
||||
}
|
||||
```
|
||||
|
||||
### Transpilation Mapping Rules
|
||||
|
||||
| Mist Source | Rust Output |
|
||||
|----------------------------|----------------------------------|
|
||||
| `src/main.mist` | `.mist/src/main.rs` |
|
||||
| `src/foo.mist` | `.mist/src/foo.rs` |
|
||||
| `src/bar/package.mist` | `.mist/src/bar/mod.rs` |
|
||||
| `src/bar/baz.mist` | `.mist/src/bar/baz.rs` |
|
||||
|
||||
A `package.mist` file generates `mod.rs` in the output directory and contains `pub mod <child>;` declarations for its children.
|
||||
|
||||
### Caching
|
||||
|
||||
The transpiler implements basic caching via file modification times:
|
||||
|
||||
```rust
|
||||
fn is_source_newer(source: &Path, output: &Path) -> io::Result<bool> {
|
||||
if !output.exists() { return Ok(true); }
|
||||
let source_time = fs::metadata(source)?.modified()?;
|
||||
let output_time = fs::metadata(output)?.modified()?;
|
||||
Ok(source_time > output_time)
|
||||
}
|
||||
```
|
||||
|
||||
If a source file has not changed since the last transpilation, the `.rs` file is not regenerated.
|
||||
@@ -4,7 +4,7 @@ description: Understanding the Alpha state of Mist and our technical roadmap.
|
||||
icon: TriangleAlert
|
||||
---
|
||||
|
||||
Mist is currently in a **Volatile Alpha** stage (latest: v0.3.7-alpha.0). Our current priority is exploring **Syntax and Features**. We believe in stabilizing the developer experience and the "feel" of the language before locking in the deep architectural logic of the compiler.
|
||||
Mist is currently in a **Volatile Alpha** stage (latest: v0.3.8-alpha.0). Our current priority is exploring **Syntax and Features**. We believe in stabilizing the developer experience and the "feel" of the language before locking in the deep architectural logic of the compiler.
|
||||
|
||||
The compiler, transpiler, and CLI are partially bootstrapped — written in Mist itself. This gives us real-world feedback on every language design decision.
|
||||
|
||||
|
||||
@@ -1,115 +0,0 @@
|
||||
---
|
||||
title: Control Flow
|
||||
description: Directing execution with expression-based logic, pattern matching, and traditional loop structures.
|
||||
icon: Split
|
||||
---
|
||||
|
||||
Control flow in Mist provides a bridge between C-style procedural logic and Rust's expression-oriented design. Conditions do not require parentheses, and blocks support expression bodies.
|
||||
|
||||
## Conditionals
|
||||
|
||||
The `if` statement evaluates a boolean expression without parentheses:
|
||||
|
||||
```mist
|
||||
if score > 50 {
|
||||
println!("Pass");
|
||||
} else if score == 50 {
|
||||
println!("Borderline");
|
||||
} else {
|
||||
println!("Fail");
|
||||
}
|
||||
|
||||
// Expression body (implicit return)
|
||||
let result = if valid { "ok" } else { "err" };
|
||||
```
|
||||
|
||||
## Match
|
||||
|
||||
The `match` statement provides exhaustive pattern matching with support for multiple patterns per arm via `|`:
|
||||
|
||||
```mist
|
||||
match task_state {
|
||||
TaskState::Pending => { println!("Queued"); }
|
||||
TaskState::Failed { reason, code } => {
|
||||
println!("Error {}: {}", code, reason);
|
||||
}
|
||||
TaskState::NotResponding | TaskState::Progress => {
|
||||
draw_loading();
|
||||
}
|
||||
_ => { println!("Other state"); }
|
||||
}
|
||||
```
|
||||
|
||||
Patterns support destructuring, or-patterns, and wildcards:
|
||||
|
||||
```mist
|
||||
let x = 2;
|
||||
let result;
|
||||
|
||||
match x {
|
||||
1 => { result = 10; }
|
||||
2 => result = 20,
|
||||
3 => { result = 30; }
|
||||
_ => panic!();
|
||||
}
|
||||
```
|
||||
|
||||
## Loops
|
||||
|
||||
### Loop
|
||||
|
||||
An infinite loop construct:
|
||||
|
||||
```mist
|
||||
loop {
|
||||
println!("forever");
|
||||
if done { break; }
|
||||
}
|
||||
```
|
||||
|
||||
### For-In Loop
|
||||
|
||||
For loops iterate over an expression using `for pattern in expr` syntax:
|
||||
|
||||
```mist
|
||||
for i in 0 .. 4 {
|
||||
sum += i;
|
||||
}
|
||||
|
||||
// With pattern destructuring
|
||||
for (k, _) in pairs {
|
||||
keys += k;
|
||||
}
|
||||
|
||||
// With range variable
|
||||
let r = 0 .. 5;
|
||||
for i in r {
|
||||
count++;
|
||||
}
|
||||
```
|
||||
|
||||
### While Loop
|
||||
|
||||
```mist
|
||||
while count < 5 {
|
||||
count++;
|
||||
}
|
||||
|
||||
while active {
|
||||
wait_for_event();
|
||||
}
|
||||
```
|
||||
|
||||
## Jump Statements
|
||||
|
||||
- **`return`**: Exits the current function, optionally passing back a value.
|
||||
- **`break`**: Terminates the innermost looping construct.
|
||||
- **`continue`**: Skips the remainder of the current loop iteration.
|
||||
|
||||
## Key Characteristics
|
||||
|
||||
- **No Parentheses**: Conditions in `if`, `while`, and `match` do not require parentheses.
|
||||
- **Implicit Returns**: Expression bodies implicitly return their value.
|
||||
- **Pattern Integration**: Loops and match arms utilize Mist's pattern system for data destructuring.
|
||||
- **Multiple Patterns**: Match arms support `|` for matching multiple patterns.
|
||||
- **Expression `if`**: `if/else` blocks can be used as expressions.
|
||||
@@ -1,142 +0,0 @@
|
||||
---
|
||||
title: Expressions
|
||||
description: The building blocks of logic, from literals to complex postfix chains.
|
||||
icon: Binary
|
||||
---
|
||||
|
||||
Expressions in Mist are the fundamental units that evaluate to a value. The syntax follows a clean **prefix -> primary -> postfix** chain, providing a predictable structure.
|
||||
|
||||
## Primary Expressions
|
||||
|
||||
Primary expressions are the starting point of any logic chain. These include literal values, paths to members, tuples, arrays, and basic statements.
|
||||
|
||||
```mist
|
||||
let x = 42;
|
||||
let pi = Math::PI;
|
||||
let coordinates = (10, 20, 30);
|
||||
```
|
||||
|
||||
## Postfix Operations
|
||||
|
||||
Postfix expressions allow you to build on a primary value with field access, calls, indexing, type casting, error propagation, and mutation operators.
|
||||
|
||||
```mist
|
||||
let len = list.length();
|
||||
s.len();
|
||||
s.to_uppercase();
|
||||
|
||||
let task = Task {
|
||||
name: "Drafting",
|
||||
priority: 1,
|
||||
};
|
||||
|
||||
let first = items[0];
|
||||
println!("Value: {}", first);
|
||||
```
|
||||
|
||||
### Increment & Decrement
|
||||
|
||||
```mist
|
||||
let mut i = 0;
|
||||
i++;
|
||||
i--;
|
||||
```
|
||||
|
||||
### Compound Assignments
|
||||
|
||||
```mist
|
||||
i += 10;
|
||||
i -= 5;
|
||||
i *= 2;
|
||||
i /= 3;
|
||||
value &= mask;
|
||||
flags |= 0x01;
|
||||
```
|
||||
|
||||
### Type Casting
|
||||
|
||||
Use `as` to convert between compatible types:
|
||||
|
||||
```mist
|
||||
let x = 42;
|
||||
let y = x as f64;
|
||||
```
|
||||
|
||||
### Try Operator
|
||||
|
||||
Propagate errors with the `?` postfix operator:
|
||||
|
||||
```mist
|
||||
let content = fs::read_to_string(path)?;
|
||||
```
|
||||
|
||||
### Range Operators
|
||||
|
||||
Ranges use spaced `..` syntax:
|
||||
|
||||
```mist
|
||||
0 .. 10 // exclusive range (0 to 9)
|
||||
0 ..= 10 // inclusive range (0 to 10)
|
||||
```
|
||||
|
||||
### Arrays
|
||||
|
||||
Arrays are initialized with brackets, with an optional repeat notation:
|
||||
|
||||
```mist
|
||||
let arr = [1, 2, 3];
|
||||
let zeros = [0; 10]; // ten zeroes
|
||||
```
|
||||
|
||||
## Prefix Operations
|
||||
|
||||
Prefixes modify the primary expression that follows them — dereference, reference, negation, and logical not.
|
||||
|
||||
```mist
|
||||
let mut value = 10;
|
||||
|
||||
let ref = &value;
|
||||
let mref = &mut value;
|
||||
let val = *ref;
|
||||
let is_false = !true;
|
||||
let neg = -42;
|
||||
```
|
||||
|
||||
## Binary Operations
|
||||
|
||||
```mist
|
||||
let sum = 10 + 20;
|
||||
let is_equal = (x == y);
|
||||
let complex = (a + b) * (c / d);
|
||||
```
|
||||
|
||||
## Closures
|
||||
|
||||
Closures use arrow syntax with optional type annotations:
|
||||
|
||||
```mist
|
||||
let add = (a, b) => a + b;
|
||||
let greet = (name str&) => {
|
||||
println!("Hello {}", name);
|
||||
};
|
||||
```
|
||||
|
||||
## Operator Table
|
||||
|
||||
| Category | Operators |
|
||||
| -------------- | ---------------------------------------------------------------- |
|
||||
| **Arithmetic** | `+`, `-`, `*`, `/`, `%` |
|
||||
| **Comparison** | `==`, `!=`, `<`, `>`, `<=`, `>=` |
|
||||
| **Logical** | `&&`, `||` |
|
||||
| **Bitwise** | `<<`, `>>`, `&`, `\|`, `^` |
|
||||
| **Range** | `..`, `..=` |
|
||||
| **Assign** | `=`, `+=`, `-=`, `*=`, `/=`, `%=`, `&=`, `\|=`, `^=`, `<<=`, `>>=` |
|
||||
|
||||
## Key Characteristics
|
||||
|
||||
- **Predictable Chaining**: The `prefix* ~ primary ~ postfix*` grammar ensures complex expressions are parsed consistently.
|
||||
- **Rust-Style References**: Expressions use `&` and `&mut` to create references, maintaining borrow checker compatibility.
|
||||
- **Macro Integration**: Macros use `!` as a postfix operation.
|
||||
- **Type Casting**: `as Type` provides explicit type conversion at the expression level.
|
||||
- **Error Propagation**: The `?` operator enables early returns for `Result`/`Option` types.
|
||||
- **Arrow Closures**: `(params) => expr` for concise anonymous functions.
|
||||
@@ -1,77 +0,0 @@
|
||||
---
|
||||
title: Variables
|
||||
description: Local state management with type inference and explicit mutability.
|
||||
icon: Variable
|
||||
---
|
||||
|
||||
Variables in Mist support two declaration styles: inferred typing with `let` and explicit type annotation. Like Rust, variables are immutable by default.
|
||||
|
||||
## Basic Declaration
|
||||
|
||||
Use `let` for automatic type inference:
|
||||
|
||||
```mist
|
||||
let x = 42;
|
||||
let greeting = "Hello Mist";
|
||||
let s = "hello, world!";
|
||||
```
|
||||
|
||||
## Explicit Typing
|
||||
|
||||
Type annotations are placed before the name:
|
||||
|
||||
```mist
|
||||
i32 x = 42;
|
||||
bool is_active = true;
|
||||
str& name = "mist";
|
||||
f64 pi = 3.14;
|
||||
```
|
||||
|
||||
## Mutability
|
||||
|
||||
To allow a variable to be reassigned, use `let mut`:
|
||||
|
||||
```mist
|
||||
let mut score = 0;
|
||||
score = 100;
|
||||
```
|
||||
|
||||
Or with explicit typing:
|
||||
|
||||
```mist
|
||||
i32 mut counter = 0;
|
||||
counter = 10;
|
||||
```
|
||||
|
||||
## Strings
|
||||
|
||||
String references use `str&` for a natural left-to-right read:
|
||||
|
||||
```mist
|
||||
str& name = "mist";
|
||||
str& greeting = "Hello";
|
||||
```
|
||||
|
||||
## Arrays
|
||||
|
||||
```mist
|
||||
let list = [1, 2, 3]; // Standard init
|
||||
let zeros = [0; 10]; // Repeat notation: ten zeroes
|
||||
```
|
||||
|
||||
## Pattern Destructuring
|
||||
|
||||
Tuples are destructured using parentheses:
|
||||
|
||||
```mist
|
||||
let (a, b) = (10, "hello");
|
||||
let (a, (b, c)) = (1, (2, 3));
|
||||
```
|
||||
|
||||
## Key Characteristics
|
||||
|
||||
- **Dual Declaration Styles**: `let` for inference, `Type name` for explicit typing.
|
||||
- **Safety First**: Immutability by default prevents accidental state changes.
|
||||
- **Zero-Cost Inference**: Type inference is handled entirely at compile time.
|
||||
- **Shadowing**: Mist supports variable shadowing within the same scope.
|
||||
- **`str&` Notation**: String references use postfix `&` for clear left-to-right reading.
|
||||
+24
-15
@@ -1,22 +1,31 @@
|
||||
{
|
||||
"pages": [
|
||||
"---[Rocket]Introduction---",
|
||||
"---Introduction---",
|
||||
"index",
|
||||
"philosophy",
|
||||
"limitations",
|
||||
|
||||
"---[Box]Components---",
|
||||
"components/functions",
|
||||
"components/structs",
|
||||
"components/enums",
|
||||
"components/classes",
|
||||
"components/traits",
|
||||
"components/pointers-references",
|
||||
"components/modules-imports",
|
||||
|
||||
"---[ArrowDownUp]Logic---",
|
||||
"logic/variables",
|
||||
"logic/control-flow",
|
||||
"logic/expressions"
|
||||
"---Language Guide---",
|
||||
"guide/syntax-overview",
|
||||
"guide/variables",
|
||||
"guide/types",
|
||||
"guide/functions",
|
||||
"guide/control-flow",
|
||||
"guide/structs-enums",
|
||||
"guide/classes",
|
||||
"guide/traits-impls",
|
||||
"guide/generics",
|
||||
"guide/modules",
|
||||
"guide/patterns",
|
||||
"guide/operators",
|
||||
"guide/attributes",
|
||||
"---Compiler Internals---",
|
||||
"internals/architecture",
|
||||
"internals/parsing",
|
||||
"internals/semantic-analysis",
|
||||
"internals/codegen",
|
||||
"internals/transpiler",
|
||||
"internals/builder",
|
||||
"internals/lsp",
|
||||
"internals/position-mapping"
|
||||
]
|
||||
}
|
||||
@@ -14,49 +14,11 @@ All of your favorite Rust libraries work with Mist. It is designed for **low-lev
|
||||
|
||||
Mist is meant to feel like C++ but **be** Rust. It bridges the gap between the ergonomics of a classic systems language and the safety guarantees of Rust's ownership model.
|
||||
|
||||
### Type-First Syntax
|
||||
|
||||
Low-level and embedded development demands clarity about what your data is. Mist puts the **type first** — before the name — so declarations read naturally:
|
||||
|
||||
```mist
|
||||
i32 score = 100;
|
||||
Vec<String> args = env::args().collect();
|
||||
void* data = allocate(size);
|
||||
```
|
||||
|
||||
This mirrors C/C++ declaration syntax, making Mist instantly familiar to embedded and systems programmers while compiling into Rust's strict type system.
|
||||
|
||||
### C-Style Functions
|
||||
|
||||
Functions use the return type before the name — no `fn` keyword needed:
|
||||
|
||||
```mist
|
||||
i32 add(i32 a, i32 b) {
|
||||
a + b
|
||||
}
|
||||
|
||||
void log(message *str) {
|
||||
println!("{}", message);
|
||||
}
|
||||
```
|
||||
|
||||
Every function maps directly to a Rust `fn` underneath.
|
||||
|
||||
### Minimal Friction
|
||||
|
||||
* No `let` keyword — `Type name = value` is all you need.
|
||||
* Consistent `name Type` convention across parameters, fields, and locals.
|
||||
* Explicit pointers with `*T` and `*mut T` — clear intent without ceremony.
|
||||
* String references use `str&` for a natural left-to-right read.
|
||||
|
||||
---
|
||||
|
||||
## Built for Low-Level and Embedded
|
||||
|
||||
Mist is designed from the ground up for systems where resources are constrained and control is required:
|
||||
|
||||
* **No runtime** — no garbage collector, no hidden allocator, no VM.
|
||||
* **Direct memory control** — explicit pointers, manual allocation, predictable layout.
|
||||
* **Zero-cost abstractions** — classes, traits, and generics all resolve at compile time.
|
||||
* **Works with existing Cargo tooling** — use any Rust crate as a library.
|
||||
|
||||
@@ -74,11 +36,11 @@ Mist is not a replacement for Rust; it is an **ergonomic interface** for it. It
|
||||
|
||||
## Bootstrapped Development
|
||||
|
||||
Mist is partially bootstrapped — the compiler's CLI, transpiler, and analyzer modules are written in Mist itself. This gives us first-hand experience with the language's ergonomics and drives real-world improvements with every release.
|
||||
Mist is partially bootstrapped — the compiler's CLI and transpiler modules are written in Mist itself. This gives us first-hand experience with the language's ergonomics and drives real-world improvements with every release.
|
||||
|
||||
## Why Mist?
|
||||
|
||||
* **Familiarity:** C/C++ developers can be productive immediately — no new optical model to learn.
|
||||
* **Familiarity:** C/C++ developers can be productive immediately — no new optical model to learn (Note: Rust's semantics still need to be learned).
|
||||
* **Safety:** Rust's borrow checker and type system under every expression, no exceptions.
|
||||
* **Control:** Explicit types, explicit pointers, explicit allocation — nothing hidden.
|
||||
* **Ecosystem:** The entire Rust crate ecosystem available at your fingertips.
|
||||
|
||||
@@ -0,0 +1,21 @@
|
||||
let esmLoader;
|
||||
|
||||
module.exports = async function (source) {
|
||||
if (!esmLoader) {
|
||||
const mod = await import(
|
||||
require('path').resolve(
|
||||
__dirname,
|
||||
'../node_modules/fumadocs-mdx/dist/webpack/mdx.js'
|
||||
)
|
||||
);
|
||||
esmLoader = mod.default;
|
||||
}
|
||||
|
||||
return new Promise((resolve, reject) => {
|
||||
this.async = () => (err, result) => {
|
||||
if (err) reject(err);
|
||||
else resolve(result);
|
||||
};
|
||||
esmLoader.call(this, source);
|
||||
});
|
||||
};
|
||||
@@ -0,0 +1,21 @@
|
||||
let esmLoader;
|
||||
|
||||
module.exports = async function (source) {
|
||||
if (!esmLoader) {
|
||||
const mod = await import(
|
||||
require('path').resolve(
|
||||
__dirname,
|
||||
'../node_modules/fumadocs-mdx/dist/webpack/meta.js'
|
||||
)
|
||||
);
|
||||
esmLoader = mod.default;
|
||||
}
|
||||
|
||||
return new Promise((resolve, reject) => {
|
||||
this.async = () => (err, result) => {
|
||||
if (err) reject(err);
|
||||
else resolve(result);
|
||||
};
|
||||
esmLoader.call(this, source);
|
||||
});
|
||||
};
|
||||
+30
-2
@@ -1,10 +1,38 @@
|
||||
import { createMDX } from 'fumadocs-mdx/next';
|
||||
import path from 'node:path';
|
||||
import { fileURLToPath } from 'node:url';
|
||||
|
||||
const __dirname = path.dirname(fileURLToPath(import.meta.url));
|
||||
|
||||
const withMDX = createMDX();
|
||||
|
||||
/** @type {import('next').NextConfig} */
|
||||
const config = {
|
||||
reactStrictMode: true,
|
||||
};
|
||||
|
||||
export default withMDX(config);
|
||||
const nextConfig = withMDX(config);
|
||||
|
||||
const mdxLoaderPath = path.resolve(__dirname, 'loaders/fumadocs-mdx-loader.cjs');
|
||||
const metaLoaderPath = path.resolve(__dirname, 'loaders/fumadocs-meta-loader.cjs');
|
||||
|
||||
if (nextConfig.turbopack?.rules) {
|
||||
for (const rule of Object.values(nextConfig.turbopack.rules)) {
|
||||
if (rule.loaders) {
|
||||
for (const l of rule.loaders) {
|
||||
if (l.loader === 'fumadocs-mdx/webpack/mdx') l.loader = mdxLoaderPath;
|
||||
if (l.loader === 'fumadocs-mdx/webpack/meta') l.loader = metaLoaderPath;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const origWebpack = nextConfig.webpack;
|
||||
nextConfig.webpack = (config, options) => {
|
||||
config.resolveLoader ??= {};
|
||||
config.resolveLoader.alias ??= {};
|
||||
config.resolveLoader.alias['fumadocs-mdx/webpack/mdx'] = mdxLoaderPath;
|
||||
config.resolveLoader.alias['fumadocs-mdx/webpack/meta'] = metaLoaderPath;
|
||||
return origWebpack?.(config, options) ?? config;
|
||||
};
|
||||
|
||||
export default nextConfig;
|
||||
|
||||
Generated
+188
-182
@@ -10,10 +10,10 @@
|
||||
"hasInstallScript": true,
|
||||
"dependencies": {
|
||||
"fumadocs-core": "16.8.9",
|
||||
"fumadocs-mdx": "15.0.2",
|
||||
"fumadocs-mdx": "^15.0.13",
|
||||
"fumadocs-ui": "16.8.9",
|
||||
"lucide-react": "^1.14.0",
|
||||
"next": "16.2.6",
|
||||
"next": "^16.2.10",
|
||||
"react": "^19.2.6",
|
||||
"react-dom": "^19.2.6",
|
||||
"tailwind-merge": "^3.5.0"
|
||||
@@ -53,9 +53,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/aix-ppc64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.0.tgz",
|
||||
"integrity": "sha512-lhRUCeuOyJQURhTxl4WkpFTjIsbDayJHih5kZC1giwE+MhIzAb7mEsQMqMf18rHLsrb5qI1tafG20mLxEWcWlA==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/aix-ppc64/-/aix-ppc64-0.28.1.tgz",
|
||||
"integrity": "sha512-Svl7tq8k/08+p6CXPpRjQ1fKX+1odH/BQbb48fV6fj3CWHhsoIOoY87w1oHXm0qEpkIK3ZfVgp0hed3XBXzXMQ==",
|
||||
"cpu": [
|
||||
"ppc64"
|
||||
],
|
||||
@@ -69,9 +69,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/android-arm": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.0.tgz",
|
||||
"integrity": "sha512-wqh0ByljabXLKHeWXYLqoJ5jKC4XBaw6Hk08OfMrCRd2nP2ZQ5eleDZC41XHyCNgktBGYMbqnrJKq/K/lzPMSQ==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/android-arm/-/android-arm-0.28.1.tgz",
|
||||
"integrity": "sha512-0k2F129Xdio1TdJfzJ8sy1Q47vUD2NnwdhiAf7drUN1EBTfPf4hsFCtmMgu/6m8JSzsBrlmVjudMBQqOfG8usQ==",
|
||||
"cpu": [
|
||||
"arm"
|
||||
],
|
||||
@@ -85,9 +85,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/android-arm64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.0.tgz",
|
||||
"integrity": "sha512-+WzIXQOSaGs33tLEgYPYe/yQHf0WTU0X42Jca3y8NWMbUVhp7rUnw+vAsRC/QiDrdD31IszMrZy+qwPOPjd+rw==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/android-arm64/-/android-arm64-0.28.1.tgz",
|
||||
"integrity": "sha512-34EGEbCIAgosYz6goLcopX6Mo7NyGv9tfwEM2/7Ce2VcVRk568iSvniGWcUXIy7wEDR1wzolcxcriFVrWYcwBg==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -101,9 +101,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/android-x64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.0.tgz",
|
||||
"integrity": "sha512-+VJggoaKhk2VNNqVL7f6S189UzShHC/mR9EE8rDdSkdpN0KflSwWY/gWjDrNxxisg8Fp1ZCD9jLMo4m0OUfeUA==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/android-x64/-/android-x64-0.28.1.tgz",
|
||||
"integrity": "sha512-dbwY7ltSMDWsRatcRpCnES4F+im88OCUgGZjy52shC7GqHRE/cYlxNbB4Z4UpJswpcc4Qxd2oE/ufM0p61IKng==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -117,9 +117,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/darwin-arm64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.0.tgz",
|
||||
"integrity": "sha512-0T+A9WZm+bZ84nZBtk1ckYsOvyA3x7e2Acj1KdVfV4/2tdG4fzUp91YHx+GArWLtwqp77pBXVCPn2We7Letr0Q==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/darwin-arm64/-/darwin-arm64-0.28.1.tgz",
|
||||
"integrity": "sha512-TZbWkQY7kvTAXbXUT7uVACR5cMHsDiSz9z7ZKAX/RTq/WJEk3QyRr0wZpNhBDX+/0CtdqUIJlOiodQcta6tY3Q==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -133,9 +133,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/darwin-x64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.0.tgz",
|
||||
"integrity": "sha512-fyzLm/DLDl/84OCfp2f/XQ4flmORsjU7VKt8HLjvIXChJoFFOIL6pLJPH4Yhd1n1gGFF9mPwtlN5Wf82DZs+LQ==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/darwin-x64/-/darwin-x64-0.28.1.tgz",
|
||||
"integrity": "sha512-zfdzgK9ACBNZLI/CyHTOx81SyNbM6YXn7rxSgX97VjyiPl9W1i4Ka4fgKECEoFCKGpvBj5qArWIGgQjOwkgskQ==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -149,9 +149,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/freebsd-arm64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.0.tgz",
|
||||
"integrity": "sha512-l9GeW5UZBT9k9brBYI+0WDffcRxgHQD8ShN2Ur4xWq/NFzUKm3k5lsH4PdaRgb2w7mI9u61nr2gI2mLI27Nh3Q==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-arm64/-/freebsd-arm64-0.28.1.tgz",
|
||||
"integrity": "sha512-wG2EA8ENdEI0qhkSZMjfqrdY+ziCYCPMmtZjjIwOmXFjmyzEHn+UUxk5of+SYsjtfs3VpnlC7QLzSI5hY/rOAw==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -165,9 +165,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/freebsd-x64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.0.tgz",
|
||||
"integrity": "sha512-BXoQai/A0wPO6Es3yFJ7APCiKGc1tdAEOgeTNy3SsB491S3aHn4S4r3e976eUnPdU+NbdtmBuLncYir2tMU9Nw==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/freebsd-x64/-/freebsd-x64-0.28.1.tgz",
|
||||
"integrity": "sha512-i7dZ9vQgnvSCzi/rYCXNgtF/U+eKZNJBzu3eTQbRgHnM7tNSizLOkRFAl3qzVc/Op/u5YkHHa4pf/3DOYHthLQ==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -181,9 +181,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-arm": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.0.tgz",
|
||||
"integrity": "sha512-CjaaREJagqJp7iTaNQjjidaNbCKYcd4IDkzbwwxtSvjI7NZm79qiHc8HqciMddQ6CKvJT6aBd8lO9kN/ZudLlw==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm/-/linux-arm-0.28.1.tgz",
|
||||
"integrity": "sha512-qVXBOHQS+d5Y722GwJzJUtOLlX7km3CraOaGormF1pDtPd2C/l1SHRPgjLunLGe51Sh5YYWKMFDyV4SxgMQYTQ==",
|
||||
"cpu": [
|
||||
"arm"
|
||||
],
|
||||
@@ -197,9 +197,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-arm64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.0.tgz",
|
||||
"integrity": "sha512-RVyzfb3FWsGA55n6WY0MEIEPURL1FcbhFE6BffZEMEekfCzCIMtB5yyDcFnVbTnwk+CLAgTujmV/Lgvih56W+A==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-arm64/-/linux-arm64-0.28.1.tgz",
|
||||
"integrity": "sha512-yHs+0uc8+nvEAfAfxrWQKK5peSNzBc4PegcMO0EJ2hT71uA7vB8Ihg2e77R2P7SG5uYjPbHlLLmve4LLLRCf0g==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -213,9 +213,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-ia32": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.0.tgz",
|
||||
"integrity": "sha512-KBnSTt1kxl9x70q+ydterVdl+Cn0H18ngRMRCEQfrbqdUuntQQ0LoMZv47uB97NljZFzY6HcfqEZ2SAyIUTQBQ==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-ia32/-/linux-ia32-0.28.1.tgz",
|
||||
"integrity": "sha512-d1z4ZuP0ajrfz/FhGT4vv278rX8KnPPJx8i5+AtK7TYbx9Le9F1hyzurZpkEyjkGa9dUGhQow4C1NmeGvqxN2w==",
|
||||
"cpu": [
|
||||
"ia32"
|
||||
],
|
||||
@@ -229,9 +229,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-loong64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.0.tgz",
|
||||
"integrity": "sha512-zpSlUce1mnxzgBADvxKXX5sl8aYQHo2ezvMNI8I0lbblJtp8V4odlm3Yzlj7gPyt3T8ReksE6bK+pT3WD+aJRg==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-loong64/-/linux-loong64-0.28.1.tgz",
|
||||
"integrity": "sha512-M5sRjUVZrkm1OAPR3dlOYzNmN+loZKGVi1VUQGrwuqLcbR6qeAz+famMhjASeH3YVKvZz+zT1jlh/keC3Rj/lg==",
|
||||
"cpu": [
|
||||
"loong64"
|
||||
],
|
||||
@@ -245,9 +245,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-mips64el": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.0.tgz",
|
||||
"integrity": "sha512-2jIfP6mmjkdmeTlsX/9vmdmhBmKADrWqN7zcdtHIeNSCH1SqIoNI63cYsjQR8J+wGa4Y5izRcSHSm8K3QWmk3w==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-mips64el/-/linux-mips64el-0.28.1.tgz",
|
||||
"integrity": "sha512-mRObBZeHh2OxcBFPWE/FjylkRgZdYuiTR3vaTozquCGOH14iP9oN4x4Ge81CoIDYQrXmIxpFumJBu5MtZpnQJQ==",
|
||||
"cpu": [
|
||||
"mips64el"
|
||||
],
|
||||
@@ -261,9 +261,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-ppc64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.0.tgz",
|
||||
"integrity": "sha512-bc0FE9wWeC0WBm49IQMPSPILRocGTQt3j5KPCA8os6VprfuJ7KD+5PzESSrJ6GmPIPJK965ZJHTUlSA6GNYEhg==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-ppc64/-/linux-ppc64-0.28.1.tgz",
|
||||
"integrity": "sha512-slScBsMAb3GFDcdrCgLwZtPYRoH2H/youv10QiZyRjmsP48fznoveWytSgCI/R0ZcUgpc0ZhIUEx6LHts8yrfQ==",
|
||||
"cpu": [
|
||||
"ppc64"
|
||||
],
|
||||
@@ -277,9 +277,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-riscv64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.0.tgz",
|
||||
"integrity": "sha512-SQPZOwoTTT/HXFXQJG/vBX8sOFagGqvZyXcgLA3NhIqcBv1BJU1d46c0rGcrij2B56Z2rNiSLaZOYW5cUk7yLQ==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-riscv64/-/linux-riscv64-0.28.1.tgz",
|
||||
"integrity": "sha512-kw0owk1o0GFETUJyW0jc0G4Yzs0BHZn0JDZ8JRT088vjJYX777BAs1fDGxAC+q831qOs2DTC96mNsG2opdfyyQ==",
|
||||
"cpu": [
|
||||
"riscv64"
|
||||
],
|
||||
@@ -293,9 +293,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-s390x": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.0.tgz",
|
||||
"integrity": "sha512-SCfR0HN8CEEjnYnySJTd2cw0k9OHB/YFzt5zgJEwa+wL/T/raGWYMBqwDNAC6dqFKmJYZoQBRfHjgwLHGSrn3Q==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-s390x/-/linux-s390x-0.28.1.tgz",
|
||||
"integrity": "sha512-/lAIjX8aYFRByhh6L5rYtPEDRqa9de/4V/juOXcta5frjvzXO4/sqEtyytse0g3zZFuWu5cDN0MkLz2qRDD2Ag==",
|
||||
"cpu": [
|
||||
"s390x"
|
||||
],
|
||||
@@ -309,9 +309,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/linux-x64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.0.tgz",
|
||||
"integrity": "sha512-us0dSb9iFxIi8srnpl931Nvs65it/Jd2a2K3qs7fz2WfGPHqzfzZTfec7oxZJRNPXPnNYZtanmRc4AL/JwVzHQ==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/linux-x64/-/linux-x64-0.28.1.tgz",
|
||||
"integrity": "sha512-u/anNYF2mmVOEDwLtnQ1wOr3EZ9sTNGLWrsYGYwHWzGA3Si84IOkHXlbWTD1NB+9/1lcnweYKO54uhxZydNzfA==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -325,9 +325,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/netbsd-arm64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.0.tgz",
|
||||
"integrity": "sha512-CR/RYotgtCKwtftMwJlUU7xCVNg3lMYZ0RzTmAHSfLCXw3NtZtNpswLEj/Kkf6kEL3Gw+BpOekRX0BYCtklhUw==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-arm64/-/netbsd-arm64-0.28.1.tgz",
|
||||
"integrity": "sha512-oks0DYbLwWMmaakTsCb+zL4E+aHRVLom9IJZOAthMQEPiQmydXHkziYEsGYRx0uNV/IjEKGAV941JzH02pflqw==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -341,9 +341,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/netbsd-x64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.0.tgz",
|
||||
"integrity": "sha512-nU1yhmYutL+fQ71Kxnhg8uEOdC0pwEW9entHykTgEbna2pw2dkbFSMeqjjyHZoCmt8SBkOSvV+yNmm94aUrrqw==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/netbsd-x64/-/netbsd-x64-0.28.1.tgz",
|
||||
"integrity": "sha512-aeL6lAnN89Hz43Mlh1G8ARasbuoYvSITDEx0tHh5b7jJnHcssqgjy9Yx430GDpmCa6OyrKoS0aNRjKundRizGg==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -357,9 +357,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/openbsd-arm64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.0.tgz",
|
||||
"integrity": "sha512-cXb5vApOsRsxsEl4mcZ1XY3D4DzcoMxR/nnc4IyqYs0rTI8ZKmW6kyyg+11Z8yvgMfAEldKzP7AdP64HnSC/6g==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-arm64/-/openbsd-arm64-0.28.1.tgz",
|
||||
"integrity": "sha512-MEFJe5C3R8pwXdZ5Y21oo6m7ePiS0d9pWucn99O/wvyJZChoIQKrQDxKrGeW8F5+T0okTHesAmDeiHDTIq0V/Q==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -373,9 +373,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/openbsd-x64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.0.tgz",
|
||||
"integrity": "sha512-8wZM2qqtv9UP3mzy7HiGYNH/zjTA355mpeuA+859TyR+e+Tc08IHYpLJuMsfpDJwoLo1ikIJI8jC3GFjnRClzA==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/openbsd-x64/-/openbsd-x64-0.28.1.tgz",
|
||||
"integrity": "sha512-i/ZLIOafE0Z8cI/XANJAixoJL/uRAoS2xOA3rb0xN+KK0K177cMAsQYkzHtBrtMXAKuAc7HGgcWiZ/sRC1Nxgw==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -389,9 +389,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/openharmony-arm64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.0.tgz",
|
||||
"integrity": "sha512-FLGfyizszcef5C3YtoyQDACyg95+dndv79i2EekILBofh5wpCa1KuBqOWKrEHZg3zrL3t5ouE5jgr94vA+Wb2w==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/openharmony-arm64/-/openharmony-arm64-0.28.1.tgz",
|
||||
"integrity": "sha512-ge+Z7EXFNt2BO1oAMsVpiQ8EwndV9i1xXerAeTIK7AtPs3bKFXQM7nlRxDSIUIMeueR1CNXxqztLzdNeReKBJg==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -405,9 +405,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/sunos-x64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.0.tgz",
|
||||
"integrity": "sha512-1ZgjUoEdHZZl/YlV76TSCz9Hqj9h9YmMGAgAPYd+q4SicWNX3G5GCyx9uhQWSLcbvPW8Ni7lj4gDa1T40akdlw==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/sunos-x64/-/sunos-x64-0.28.1.tgz",
|
||||
"integrity": "sha512-BEjgtECkL3vY+SaSQ6nzVfiALUeFxpawyp8Jmf5PtYhf1Ug40N1h/hxlhts+f1FvSvarEigdxS3BlSMI2PJLcQ==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -421,9 +421,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/win32-arm64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.0.tgz",
|
||||
"integrity": "sha512-Q9StnDmQ/enxnpxCCLSg0oo4+34B9TdXpuyPeTedN/6+iXBJ4J+zwfQI28u/Jl40nOYAxGoNi7mFP40RUtkmUA==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/win32-arm64/-/win32-arm64-0.28.1.tgz",
|
||||
"integrity": "sha512-lCv9eK/H6ZJWbE7bh2nw54CZ9M2nupBxJcTsdk/QQnWkdSjKGuxmmH8/GWrlT1eMmZfn4dGcCjRte397WqfQXA==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -437,9 +437,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/win32-ia32": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.0.tgz",
|
||||
"integrity": "sha512-zF3ag/gfiCe6U2iczcRzSYJKH1DCI+ByzSENHlM2FcDbEeo5Zd2C86Aq0tKUYAJJ1obRP84ymxIAksZUcdztHA==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/win32-ia32/-/win32-ia32-0.28.1.tgz",
|
||||
"integrity": "sha512-zvb/mB2bSCoJOpoCBgYKKpX6YM6mJBlBUVUtVj41DlZJVEB6/0CKlRYxP5wWl1C1ILiCoAU5wZZ4q1P3qeS6Eg==",
|
||||
"cpu": [
|
||||
"ia32"
|
||||
],
|
||||
@@ -453,9 +453,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@esbuild/win32-x64": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.0.tgz",
|
||||
"integrity": "sha512-pEl1bO9mfAmIC+tW5btTmrKaujg3zGtUmWNdCw/xs70FBjwAL3o9OEKNHvNmnyylD6ubxUERiEhdsL0xBQ9efw==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/@esbuild/win32-x64/-/win32-x64-0.28.1.tgz",
|
||||
"integrity": "sha512-bm4Mowrv+GXMlpWX++EcXw/iLyd1o3+bJkC2DkWXYVvgZCqD/bSj9ctZeAMC3cIxgjRVR2Dufaiu4YPxr5gW1A==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -1126,15 +1126,15 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@next/env": {
|
||||
"version": "16.2.6",
|
||||
"resolved": "https://registry.npmjs.org/@next/env/-/env-16.2.6.tgz",
|
||||
"integrity": "sha512-gd8HoHN4ufj73WmR3JmVolrpJR47ILK6LouP5xElPglaVxir6e1a7VzvTvDWkOoPXT9rkkTzyCxBu4yeZfZwcw==",
|
||||
"version": "16.2.10",
|
||||
"resolved": "https://registry.npmjs.org/@next/env/-/env-16.2.10.tgz",
|
||||
"integrity": "sha512-zLPxg9M0MEHmygpj5OuxjQ+vHMiy/K7cSp74G8ecYolmgUWw0RwN02tF56npup/+qaI8JB97hQgS/r2Hb6QwVA==",
|
||||
"license": "MIT"
|
||||
},
|
||||
"node_modules/@next/swc-darwin-arm64": {
|
||||
"version": "16.2.6",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-16.2.6.tgz",
|
||||
"integrity": "sha512-ZJGkkcNfYgrrMkqOdZ7zoLa1TOy0qpcMfk/z4Mh/FKUz40gVO+HNQWqmLxf67Z5WB64DRp0dhEbyHfel+6sJUg==",
|
||||
"version": "16.2.10",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-darwin-arm64/-/swc-darwin-arm64-16.2.10.tgz",
|
||||
"integrity": "sha512-v9IdJCa0H0mbo+8z5zwUpOk1Vj7RjkcI5uNYf5Ws1y6szf/p3Mzl9hLaST8SCt6L9h8NGnruZcd2+o0NTNwDhA==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -1148,9 +1148,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@next/swc-darwin-x64": {
|
||||
"version": "16.2.6",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-16.2.6.tgz",
|
||||
"integrity": "sha512-v/YLBHIY132Ced3puBJ7YJKw1lqsCrgcNo2aRJlCEyQrrCeRJlvGlnmxhPxNQI3KE3N1DN5r9TPNPvka3nq5RQ==",
|
||||
"version": "16.2.10",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-darwin-x64/-/swc-darwin-x64-16.2.10.tgz",
|
||||
"integrity": "sha512-17IS0jJRViROGmA9uGdNR8VPJpfbnaVG7E9qhso5jDLkmyd0lSDORWxbcKINzcFqzZqGwGtMSnrFRxBpuUYjLQ==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -1164,9 +1164,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@next/swc-linux-arm64-gnu": {
|
||||
"version": "16.2.6",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-16.2.6.tgz",
|
||||
"integrity": "sha512-RPOvqlYBbcQjkz9VQQDZ2T2bARIjXZV1KFlt+V2Mr6SW/e4I9fcKsaA0hdyf2FHoTlsV2xnBd5Y912rP/1Ce6w==",
|
||||
"version": "16.2.10",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-gnu/-/swc-linux-arm64-gnu-16.2.10.tgz",
|
||||
"integrity": "sha512-GRQRsRtuciNJvB54AvvuQTiq0oZtFwa1owQqtZD8wwnGpM2L39MV22kpI72YSXLKIyY40LC66EiLFv4PiicXxg==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -1183,9 +1183,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@next/swc-linux-arm64-musl": {
|
||||
"version": "16.2.6",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-16.2.6.tgz",
|
||||
"integrity": "sha512-URUTu1+dMkxJsPFgm+OeEvq9wf5sujw0EvgYy80TDGHTSLTnIHeqb0Eu8A3sC95IRgjejQL+kC4mw+4yPxiAXA==",
|
||||
"version": "16.2.10",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-linux-arm64-musl/-/swc-linux-arm64-musl-16.2.10.tgz",
|
||||
"integrity": "sha512-zkN9MQYS7UQBro+FnISUq1itaQjXI9xqISzuQ+2bc921NcJ1x4yPCqrn77tVN6/dOOXaaWVX3k6/bR07pPwK+A==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -1202,9 +1202,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@next/swc-linux-x64-gnu": {
|
||||
"version": "16.2.6",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-16.2.6.tgz",
|
||||
"integrity": "sha512-DOj182mPV8G3UkrayLoREM5YEYI+Dk5wv7Ox9xl1fFibAELEsFD0lDPfHIeILlutMMfdyhlzYPELG3peuKaurw==",
|
||||
"version": "16.2.10",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-linux-x64-gnu/-/swc-linux-x64-gnu-16.2.10.tgz",
|
||||
"integrity": "sha512-iCVJnwvrPYECvA6WM/7+oo+OiTvedIKLxtCLAZP4xZR3nXa1zmzZyLPbYCmWvpd4CvMYF1EMTafd0ii3DygLvA==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -1221,9 +1221,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@next/swc-linux-x64-musl": {
|
||||
"version": "16.2.6",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-16.2.6.tgz",
|
||||
"integrity": "sha512-HKQ5SP/V/ub73UvF7n/zeJlxk2kLmtL7Wzrg4WfmkjmNos5onJ2tKu7yZOPdL18A6Svfn3max29ym+ry7NkK4g==",
|
||||
"version": "16.2.10",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-linux-x64-musl/-/swc-linux-x64-musl-16.2.10.tgz",
|
||||
"integrity": "sha512-ov2g4H0dHY9bPoOU83m91hWT7Iq5qy13bUnyyshLU3HGR1Ownn0X9QpmDPc5iIUaahTp7f7LeGAhV4DSFtackw==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -1240,9 +1240,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@next/swc-win32-arm64-msvc": {
|
||||
"version": "16.2.6",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-16.2.6.tgz",
|
||||
"integrity": "sha512-LZXpTlPyS5v7HhSmnvsLGP3iIYgYOBnc8r8ArlT55sGHV89bR2HlDdBjWQ+PY6SJMmk8TuVGFuxalnP3k/0Dwg==",
|
||||
"version": "16.2.10",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-win32-arm64-msvc/-/swc-win32-arm64-msvc-16.2.10.tgz",
|
||||
"integrity": "sha512-DwAnhLX76HQiFFQNgWlcK+JzlnD1rZ+UK/WY0ZMI/deXpvgnesjNYrqcfo1JzBuz4Kf7o3brIBL0glI1junatA==",
|
||||
"cpu": [
|
||||
"arm64"
|
||||
],
|
||||
@@ -1256,9 +1256,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/@next/swc-win32-x64-msvc": {
|
||||
"version": "16.2.6",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-16.2.6.tgz",
|
||||
"integrity": "sha512-F0+4i0h9J6C4eE3EAPWsoCk7UW/dbzOjyzxY0qnDUOYFu6FFmdZ6l97/XdV3/Nz3VYyO7UWjyEJUXkGqcoXfMA==",
|
||||
"version": "16.2.10",
|
||||
"resolved": "https://registry.npmjs.org/@next/swc-win32-x64-msvc/-/swc-win32-x64-msvc-16.2.10.tgz",
|
||||
"integrity": "sha512-0JXq3b85Jk9Jg4ntLUbXSPvoDw3gpZou7twuKdoFG2jOw635v7+IiXfTaa0TxVMyx78pUjnrVYwLgjKfX4e6/A==",
|
||||
"cpu": [
|
||||
"x64"
|
||||
],
|
||||
@@ -2915,9 +2915,9 @@
|
||||
}
|
||||
},
|
||||
"node_modules/esbuild": {
|
||||
"version": "0.28.0",
|
||||
"resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.0.tgz",
|
||||
"integrity": "sha512-sNR9MHpXSUV/XB4zmsFKN+QgVG82Cc7+/aaxJ8Adi8hyOac+EXptIp45QBPaVyX3N70664wRbTcLTOemCAnyqw==",
|
||||
"version": "0.28.1",
|
||||
"resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.28.1.tgz",
|
||||
"integrity": "sha512-HrJrvZv5ayxBzPfwphOoNzkzOIIlifzk0KJrGK2c8R4+LKpMtpYLQeUdjnwjWv/LZlkH2laZk+4w78pi99D4Vw==",
|
||||
"hasInstallScript": true,
|
||||
"license": "MIT",
|
||||
"bin": {
|
||||
@@ -2927,32 +2927,32 @@
|
||||
"node": ">=18"
|
||||
},
|
||||
"optionalDependencies": {
|
||||
"@esbuild/aix-ppc64": "0.28.0",
|
||||
"@esbuild/android-arm": "0.28.0",
|
||||
"@esbuild/android-arm64": "0.28.0",
|
||||
"@esbuild/android-x64": "0.28.0",
|
||||
"@esbuild/darwin-arm64": "0.28.0",
|
||||
"@esbuild/darwin-x64": "0.28.0",
|
||||
"@esbuild/freebsd-arm64": "0.28.0",
|
||||
"@esbuild/freebsd-x64": "0.28.0",
|
||||
"@esbuild/linux-arm": "0.28.0",
|
||||
"@esbuild/linux-arm64": "0.28.0",
|
||||
"@esbuild/linux-ia32": "0.28.0",
|
||||
"@esbuild/linux-loong64": "0.28.0",
|
||||
"@esbuild/linux-mips64el": "0.28.0",
|
||||
"@esbuild/linux-ppc64": "0.28.0",
|
||||
"@esbuild/linux-riscv64": "0.28.0",
|
||||
"@esbuild/linux-s390x": "0.28.0",
|
||||
"@esbuild/linux-x64": "0.28.0",
|
||||
"@esbuild/netbsd-arm64": "0.28.0",
|
||||
"@esbuild/netbsd-x64": "0.28.0",
|
||||
"@esbuild/openbsd-arm64": "0.28.0",
|
||||
"@esbuild/openbsd-x64": "0.28.0",
|
||||
"@esbuild/openharmony-arm64": "0.28.0",
|
||||
"@esbuild/sunos-x64": "0.28.0",
|
||||
"@esbuild/win32-arm64": "0.28.0",
|
||||
"@esbuild/win32-ia32": "0.28.0",
|
||||
"@esbuild/win32-x64": "0.28.0"
|
||||
"@esbuild/aix-ppc64": "0.28.1",
|
||||
"@esbuild/android-arm": "0.28.1",
|
||||
"@esbuild/android-arm64": "0.28.1",
|
||||
"@esbuild/android-x64": "0.28.1",
|
||||
"@esbuild/darwin-arm64": "0.28.1",
|
||||
"@esbuild/darwin-x64": "0.28.1",
|
||||
"@esbuild/freebsd-arm64": "0.28.1",
|
||||
"@esbuild/freebsd-x64": "0.28.1",
|
||||
"@esbuild/linux-arm": "0.28.1",
|
||||
"@esbuild/linux-arm64": "0.28.1",
|
||||
"@esbuild/linux-ia32": "0.28.1",
|
||||
"@esbuild/linux-loong64": "0.28.1",
|
||||
"@esbuild/linux-mips64el": "0.28.1",
|
||||
"@esbuild/linux-ppc64": "0.28.1",
|
||||
"@esbuild/linux-riscv64": "0.28.1",
|
||||
"@esbuild/linux-s390x": "0.28.1",
|
||||
"@esbuild/linux-x64": "0.28.1",
|
||||
"@esbuild/netbsd-arm64": "0.28.1",
|
||||
"@esbuild/netbsd-x64": "0.28.1",
|
||||
"@esbuild/openbsd-arm64": "0.28.1",
|
||||
"@esbuild/openbsd-x64": "0.28.1",
|
||||
"@esbuild/openharmony-arm64": "0.28.1",
|
||||
"@esbuild/sunos-x64": "0.28.1",
|
||||
"@esbuild/win32-arm64": "0.28.1",
|
||||
"@esbuild/win32-ia32": "0.28.1",
|
||||
"@esbuild/win32-x64": "0.28.1"
|
||||
}
|
||||
},
|
||||
"node_modules/escape-string-regexp": {
|
||||
@@ -3222,31 +3222,30 @@
|
||||
}
|
||||
},
|
||||
"node_modules/fumadocs-mdx": {
|
||||
"version": "15.0.2",
|
||||
"resolved": "https://registry.npmjs.org/fumadocs-mdx/-/fumadocs-mdx-15.0.2.tgz",
|
||||
"integrity": "sha512-lM8g8uoAY6MmBkBYNBnhU2phY8RrajttCbqi+tOXrBW620VT9Cd846uJvfQN6vcP5ieBvcsYv3BXIEZq+QCRGw==",
|
||||
"version": "15.0.13",
|
||||
"resolved": "https://registry.npmjs.org/fumadocs-mdx/-/fumadocs-mdx-15.0.13.tgz",
|
||||
"integrity": "sha512-VsGhCiLriXXMzm3WbgrVP7t6LvOthwh1BC+IGSI1ZW63UcSo1jE4aAiuUrTIF0jv1EGQkJG8cPsy0cOnf4sejA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@mdx-js/mdx": "^3.1.1",
|
||||
"@standard-schema/spec": "^1.1.0",
|
||||
"chokidar": "^5.0.0",
|
||||
"esbuild": "^0.28.0",
|
||||
"esbuild": "^0.28.1",
|
||||
"estree-util-value-to-estree": "^3.5.0",
|
||||
"js-yaml": "^4.1.1",
|
||||
"js-yaml": "^5.1.0",
|
||||
"mdast-util-mdx": "^3.0.0",
|
||||
"picocolors": "^1.1.1",
|
||||
"picomatch": "^4.0.4",
|
||||
"tinyexec": "^1.1.2",
|
||||
"tinyglobby": "^0.2.16",
|
||||
"tinyexec": "^1.2.4",
|
||||
"tinyglobby": "^0.2.17",
|
||||
"unified": "^11.0.5",
|
||||
"unist-util-remove-position": "^5.0.0",
|
||||
"unist-util-visit": "^5.1.0",
|
||||
"vfile": "^6.0.3",
|
||||
"vitefu": "^1.1.3",
|
||||
"zod": "^4.4.3"
|
||||
},
|
||||
"bin": {
|
||||
"fumadocs-mdx": "dist/bin.js"
|
||||
"fumadocs-mdx": "bin.js"
|
||||
},
|
||||
"peerDependencies": {
|
||||
"@types/mdast": "*",
|
||||
@@ -3256,6 +3255,7 @@
|
||||
"mdast-util-directive": "*",
|
||||
"next": "^15.3.0 || ^16.0.0",
|
||||
"react": "^19.2.0",
|
||||
"rolldown": "*",
|
||||
"vite": "7.x.x || 8.x.x"
|
||||
},
|
||||
"peerDependenciesMeta": {
|
||||
@@ -3277,11 +3277,36 @@
|
||||
"react": {
|
||||
"optional": true
|
||||
},
|
||||
"rolldown": {
|
||||
"optional": true
|
||||
},
|
||||
"vite": {
|
||||
"optional": true
|
||||
}
|
||||
}
|
||||
},
|
||||
"node_modules/fumadocs-mdx/node_modules/js-yaml": {
|
||||
"version": "5.2.1",
|
||||
"resolved": "https://registry.npmjs.org/js-yaml/-/js-yaml-5.2.1.tgz",
|
||||
"integrity": "sha512-zfLtNfQqxVqq3uaTqSkh4x4hZw3KHobGUA0fJUj4wawW8bsQLTVqpHdXSIzidh7o+4lEW36tANuAGdaFx6Zgnw==",
|
||||
"funding": [
|
||||
{
|
||||
"type": "github",
|
||||
"url": "https://github.com/sponsors/puzrin"
|
||||
},
|
||||
{
|
||||
"type": "github",
|
||||
"url": "https://github.com/sponsors/nodeca"
|
||||
}
|
||||
],
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"argparse": "^2.0.1"
|
||||
},
|
||||
"bin": {
|
||||
"js-yaml": "bin/js-yaml.mjs"
|
||||
}
|
||||
},
|
||||
"node_modules/fumadocs-ui": {
|
||||
"version": "16.8.9",
|
||||
"resolved": "https://registry.npmjs.org/fumadocs-ui/-/fumadocs-ui-16.8.9.tgz",
|
||||
@@ -5029,12 +5054,12 @@
|
||||
}
|
||||
},
|
||||
"node_modules/next": {
|
||||
"version": "16.2.6",
|
||||
"resolved": "https://registry.npmjs.org/next/-/next-16.2.6.tgz",
|
||||
"integrity": "sha512-qOVgKJg1+At15NpeUP+eJgCHvTCgXsogweq87Ri/Ix7PkqQHg4sdaXmSFqKlgaIXE4kW0g25LE68W87UANlHtw==",
|
||||
"version": "16.2.10",
|
||||
"resolved": "https://registry.npmjs.org/next/-/next-16.2.10.tgz",
|
||||
"integrity": "sha512-2som5AVXb3kE6Yjine3/mNbBayYF58eguBWIVVUdr1y/L426xyVEgYxgBG+1QC34P2x5E+tcDup6XkuOAX3dCA==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"@next/env": "16.2.6",
|
||||
"@next/env": "16.2.10",
|
||||
"@swc/helpers": "0.5.15",
|
||||
"baseline-browser-mapping": "^2.9.19",
|
||||
"caniuse-lite": "^1.0.30001579",
|
||||
@@ -5048,14 +5073,14 @@
|
||||
"node": ">=20.9.0"
|
||||
},
|
||||
"optionalDependencies": {
|
||||
"@next/swc-darwin-arm64": "16.2.6",
|
||||
"@next/swc-darwin-x64": "16.2.6",
|
||||
"@next/swc-linux-arm64-gnu": "16.2.6",
|
||||
"@next/swc-linux-arm64-musl": "16.2.6",
|
||||
"@next/swc-linux-x64-gnu": "16.2.6",
|
||||
"@next/swc-linux-x64-musl": "16.2.6",
|
||||
"@next/swc-win32-arm64-msvc": "16.2.6",
|
||||
"@next/swc-win32-x64-msvc": "16.2.6",
|
||||
"@next/swc-darwin-arm64": "16.2.10",
|
||||
"@next/swc-darwin-x64": "16.2.10",
|
||||
"@next/swc-linux-arm64-gnu": "16.2.10",
|
||||
"@next/swc-linux-arm64-musl": "16.2.10",
|
||||
"@next/swc-linux-x64-gnu": "16.2.10",
|
||||
"@next/swc-linux-x64-musl": "16.2.10",
|
||||
"@next/swc-win32-arm64-msvc": "16.2.10",
|
||||
"@next/swc-win32-x64-msvc": "16.2.10",
|
||||
"sharp": "^0.34.5"
|
||||
},
|
||||
"peerDependencies": {
|
||||
@@ -5757,18 +5782,18 @@
|
||||
}
|
||||
},
|
||||
"node_modules/tinyexec": {
|
||||
"version": "1.1.2",
|
||||
"resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.1.2.tgz",
|
||||
"integrity": "sha512-dAqSqE/RabpBKI8+h26GfLq6Vb3JVXs30XYQjdMjaj/c2tS8IYYMbIzP599KtRj7c57/wYApb3QjgRgXmrCukA==",
|
||||
"version": "1.2.4",
|
||||
"resolved": "https://registry.npmjs.org/tinyexec/-/tinyexec-1.2.4.tgz",
|
||||
"integrity": "sha512-SHf/r48b7vOrjve9PxJo3MN5v5yuyjHvdUcrQffT3WXMUfnGmHDVbC4k3sHJaJTgZCwpUplIaAo5ANtMyp3YHg==",
|
||||
"license": "MIT",
|
||||
"engines": {
|
||||
"node": ">=18"
|
||||
}
|
||||
},
|
||||
"node_modules/tinyglobby": {
|
||||
"version": "0.2.16",
|
||||
"resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.16.tgz",
|
||||
"integrity": "sha512-pn99VhoACYR8nFHhxqix+uvsbXineAasWm5ojXoN8xEwK5Kd3/TrhNn1wByuD52UxWRLy8pu+kRMniEi6Eq9Zg==",
|
||||
"version": "0.2.17",
|
||||
"resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz",
|
||||
"integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==",
|
||||
"license": "MIT",
|
||||
"dependencies": {
|
||||
"fdir": "^6.5.0",
|
||||
@@ -6027,25 +6052,6 @@
|
||||
"url": "https://opencollective.com/unified"
|
||||
}
|
||||
},
|
||||
"node_modules/vitefu": {
|
||||
"version": "1.1.3",
|
||||
"resolved": "https://registry.npmjs.org/vitefu/-/vitefu-1.1.3.tgz",
|
||||
"integrity": "sha512-ub4okH7Z5KLjb6hDyjqrGXqWtWvoYdU3IGm/NorpgHncKoLTCfRIbvlhBm7r0YstIaQRYlp4yEbFqDcKSzXSSg==",
|
||||
"license": "MIT",
|
||||
"workspaces": [
|
||||
"tests/deps/*",
|
||||
"tests/projects/*",
|
||||
"tests/projects/workspace/packages/*"
|
||||
],
|
||||
"peerDependencies": {
|
||||
"vite": "^3.0.0 || ^4.0.0 || ^5.0.0 || ^6.0.0 || ^7.0.0 || ^8.0.0"
|
||||
},
|
||||
"peerDependenciesMeta": {
|
||||
"vite": {
|
||||
"optional": true
|
||||
}
|
||||
}
|
||||
},
|
||||
"node_modules/web-namespaces": {
|
||||
"version": "2.0.1",
|
||||
"resolved": "https://registry.npmjs.org/web-namespaces/-/web-namespaces-2.0.1.tgz",
|
||||
|
||||
+2
-2
@@ -11,10 +11,10 @@
|
||||
},
|
||||
"dependencies": {
|
||||
"fumadocs-core": "16.8.9",
|
||||
"fumadocs-mdx": "15.0.2",
|
||||
"fumadocs-mdx": "^15.0.13",
|
||||
"fumadocs-ui": "16.8.9",
|
||||
"lucide-react": "^1.14.0",
|
||||
"next": "16.2.6",
|
||||
"next": "^16.2.10",
|
||||
"react": "^19.2.6",
|
||||
"react-dom": "^19.2.6",
|
||||
"tailwind-merge": "^3.5.0"
|
||||
|
||||
+1
-1
@@ -5,7 +5,7 @@ import {
|
||||
} from "fumadocs-mdx/config";
|
||||
import { metaSchema, pageSchema } from "fumadocs-core/source/schema";
|
||||
import { z } from "zod";
|
||||
import mist from "./public/mist.tmLanguage.json";
|
||||
import mist from "@/components/mist.tmLanguage.json";
|
||||
|
||||
// You can customize Zod schemas for frontmatter and `meta.json` here
|
||||
// see https://fumadocs.dev/docs/mdx/collections
|
||||
|
||||
@@ -173,7 +173,7 @@ export default function HomePage() {
|
||||
|
||||
return (
|
||||
<div className="h-[calc(100vh-58px)] overflow-auto snap-y snap-mandatory scroll-smooth no-scrollbar relative flex flex-col xl:flex-row">
|
||||
<div className="hidden pointer-events-none sticky top-0 right-0 z-50 md:flex order-first xl:order-last w-full xl:w-[40vw] h-svh items-center justify-center p-10 no-scrollbar">
|
||||
<div className="hidden pointer-events-none sticky top-0 right-0 z-50 xl:flex order-first xl:order-last w-full xl:w-[40vw] h-svh items-center justify-center p-10 no-scrollbar">
|
||||
<div className="w-full max-w-2xl overflow-hidden no-scrollbar">
|
||||
<motion.div
|
||||
className="will-change-transform transform-gpu w-full h-auto border border-fd-border p-5 rounded-xl min-h-24 backdrop-blur bg-black dark:bg-black/20 pointer-events-auto"
|
||||
|
||||
@@ -3,7 +3,7 @@
|
||||
import { BundledLanguage, codeToTokens, createHighlighter } from "shiki";
|
||||
import { motion, AnimatePresence } from "framer-motion";
|
||||
import { useEffect, useState } from "react";
|
||||
import mist from "../../public/mist.tmLanguage.json";
|
||||
import mist from "@/components/mist.tmLanguage.json";
|
||||
|
||||
interface Props {
|
||||
code: string;
|
||||
|
||||
Reference in New Issue
Block a user