(module
  (func $add (param $a i32) (param $b i32) (result i32)
    local.get $a
    local.get $b
    i32.add
  )
  (export "add" (func $add))
)

# WAT → Wasm
wat2wasm hello.wat -o hello.wasm

# Wasm → WAT
wasm2wat hello.wasm -o hello.wat

# 使用 wasm-tools（Rust 工具链）
wasm-tools parse hello.wat -o hello.wasm
wasm-tools print hello.wasm -o hello.wat

// 方式 1：一次性实例化
const { instance } = await WebAssembly.instantiate(buffer, imports);

// 方式 2：先编译再实例化（可复用已编译模块）
const module = await WebAssembly.compile(buffer);
const instance1 = await WebAssembly.instantiate(module, imports1);
const instance2 = await WebAssembly.instantiate(module, imports2);

(module
  (memory (export "memory") 1)  ;; 申请 1 页（64KB）内存

  (func $store (param $addr i32) (param $value i32)
    local.get $addr
    local.get $value
    i32.store                   ;; 将 value 存储到 addr
  )

  (func $load (param $addr i32) (result i32)
    local.get $addr
    i32.load                    ;; 从 addr 读取一个 i32
  )

  (export "store" (func $store))
  (export "load" (func $load))
)

;; 声明内存：初始 1 页，最大 16 页
(memory $mem 1 16)

;; 在 JS 中增长内存
;; memory.grow(pages) → 返回增长前的页数，失败返回 -1
(func $grow (param $pages i32) (result i32)
  local.get $pages
  memory.grow
)

const memory = new WebAssembly.Memory({ initial: 1 });
let view = new Uint8Array(memory.buffer);

// 调用 Wasm 内部的 grow...
// 之后必须重新创建视图
view = new Uint8Array(memory.buffer);

(module
  ;; 声明函数类型
  (type $callback (func (param i32) (result i32)))

  ;; 声明表：初始 2 个元素，类型为 funcref
  (table $tbl 2 funcref)

  ;; 两个函数
  (func $double (type $callback)
    local.get 0
    i32.const 2
    i32.mul
  )
  (func $triple (type $callback)
    local.get 0
    i32.const 3
    i32.mul
  )

  ;; 初始化表
  (elem (i32.const 0) $double $triple)

  ;; 间接调用：根据索引调用表中的函数
  (func $call_by_index (param $idx i32) (param $val i32) (result i32)
    local.get $val
    local.get $idx
    call_indirect (type $callback)
  )

  (export "callByIndex" (func $call_by_index))
)

(module
  ;; 导入一个外部函数
  (import "env" "log" (func $log (param i32)))

  ;; 导入外部内存
  (import "env" "memory" (memory 1))

  ;; 导入外部全局变量
  (import "env" "counter" (global $counter (mut i32)))

  (func $main
    i32.const 42
    call $log
  )

  (export "main" (func $main))
)

// JavaScript 提供导入
const imports = {
  env: {
    log: (value) => console.log('Wasm says:', value),
    memory: new WebAssembly.Memory({ initial: 1 }),
    counter: new WebAssembly.Global({ value: 'i32', mutable: true }, 0)
  }
};

const { instance } = await WebAssembly.instantiateStreaming(
  fetch('module.wasm'), imports
);
instance.exports.main();

(export "add"      (func $add))
(export "memory"   (memory 0))
(export "table"    (table 0))
(export "counter"  (global $counter))

// 方式 1：一步完成编译+实例化
async function instantiate1() {
  const response = await fetch('module.wasm');
  const buffer = await response.arrayBuffer();
  const { instance } = await WebAssembly.instantiate(buffer, imports);
  return instance;
}

// 方式 2：分步（推荐，可复用已编译模块）
async function instantiate2() {
  const response = await fetch('module.wasm');
  const buffer = await response.arrayBuffer();
  const module = await WebAssembly.compile(buffer);
  const instance1 = await WebAssembly.instantiate(module, imports);
  const instance2 = await WebAssembly.instantiate(module, imports);
  return [instance1, instance2];
}

// 方式 3：instantiateStreaming（最高效，直接从网络流编译）
async function instantiate3() {
  const { instance } = await WebAssembly.instantiateStreaming(
    fetch('module.wasm'), imports
  );
  return instance;
}

# Nginx 配置
types {
    application/wasm wasm;
}

// Express.js 配置
express.static.mime.define({ 'application/wasm': ['wasm'] });

;; 计算 (3 + 4) * 2
i32.const 3    ;; 栈: [3]
i32.const 4    ;; 栈: [3, 4]
i32.add        ;; 栈: [7]
i32.const 2    ;; 栈: [7, 2]
i32.mul        ;; 栈: [14]

(module
  ;; 不可变全局变量
  (global $PI f32 (f32.const 3.14159))

  ;; 可变全局变量
  (global $counter (mut i32) (i32.const 0))

  (func $increment (result i32)
    global.get $counter
    i32.const 1
    i32.add
    global.set $counter
    global.get $counter
  )

  (export "increment" (func $increment))
  (export "PI" (global $PI))
)

(module
  (memory (export "memory") 1)

  ;; 在地址 0 处初始化字符串 "Hello"
  (data (i32.const 0) "Hello\00")

  ;; 在地址 100 处初始化一个 i32 值
  (data (i32.const 100) "\2a\00\00\00")  ;; 小端序 42
)

(module
  (table 2 funcref)
  (func $f1 (result i32) (i32.const 1))
  (func $f2 (result i32) (i32.const 2))

  ;; 将 $f1 和 $f2 填入表的索引 0 和 1
  (elem (i32.const 0) $f1 $f2)
)

(module
  (memory (export "memory") 1)

  ;; 写入字符串到内存
  (data (i32.const 0) "Hello, WebAssembly!\00")

  ;; 计算字符串长度
  (func $strlen (param $ptr i32) (result i32)
    (local $len i32)
    (local.set $len (i32.const 0))
    (block $break
      (loop $loop
        ;; 如果当前字节为 0，跳出循环
        (br_if $break
          (i32.eqz (i32.load8_u (local.get $ptr)))
        )
        ;; 指针前进 1
        (local.set $ptr (i32.add (local.get $ptr) (i32.const 1)))
        ;; 长度加 1
        (local.set $len (i32.add (local.get $len) (i32.const 1)))
        (br $loop)
      )
    )
    (local.get $len)
  )

  ;; 导出字符串指针和长度函数
  (export "strlen" (func $strlen))
)

const { instance } = await WebAssembly.instantiateStreaming(fetch('string.wasm'));
const { memory, strlen } = instance.exports;

const str = new TextDecoder().decode(
  new Uint8Array(memory.buffer, 0, strlen(0))
);
console.log(str); // "Hello, WebAssembly!"