@luonghaminhvy/songma 0.5.0

package/LICENSE

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

package/bin/songma.js

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+const path = require('path');
+const { transpileFile } = require('../index');
+
+const args = process.argv.slice(2);
+
+if (args.length === 0 || args.includes('-h') || args.includes('--help')) {
+  console.log(`
+SongMa (Sông Mã) Node.js CLI Runner
+
+Cách sử dụng:
+  songma <tệp.smjs|tệp.smts>       Chạy trực tiếp tệp mã nguồn SongMa trên Node.js
+  songma build <tệp> [-o đầu_ra]   Biên dịch tệp sang JavaScript hoặc TypeScript
+
+Ví dụ:
+  songma nguon/chinh.smjs
+  songma build nguon/kieu_du_lieu.smts -o dist/bundle.ts
+`);
+  process.exit(0);
+}
+
+const command = args[0];
+
+if (command === 'build') {
+  const targetFile = args[1];
+  if (!targetFile) {
+    console.error('Lỗi: Cần đường dẫn tệp để biên dịch.');
+    process.exit(1);
+  }
+
+  let outIndex = args.indexOf('-o');
+  if (outIndex === -1) outIndex = args.indexOf('--output');
+  const outPath = outIndex !== -1 ? args[outIndex + 1] : null;
+  const isTs = args.includes('--ts');
+
+  try {
+    const output = transpileFile(targetFile, { isTs });
+    if (outPath) {
+      const fs = require('fs');
+      fs.writeFileSync(outPath, output, 'utf-8');
+      console.log(`Đã biên dịch thành công sang: ${outPath}`);
+    } else {
+      console.log(output);
+    }
+  } catch (err) {
+    console.error(err.message);
+    process.exit(1);
+  }
+} else {
+  // Chạy trực tiếp tệp với require('songma/register')
+  const targetFile = path.resolve(process.cwd(), command);
+  require('../register');
+
+  try {
+    require(targetFile);
+  } catch (err) {
+    console.error(err);
+    process.exit(1);
+  }
+}

package/index.js

@@ -0,0 +1,79 @@
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const os = require('os');
+const { transpilePureJS } = require('./transpiler');
+
+/**
+ * Kiểm tra xem binary `sm` hoặc `songma` có sẵn trên hệ thống hay không
+ */
+function getBinaryPath() {
+  if (process.env.SONGMA_BIN && fs.existsSync(process.env.SONGMA_BIN)) {
+    return process.env.SONGMA_BIN;
+  }
+  const localBinName = process.platform === 'win32' ? 'sm.exe' : 'sm';
+  const workspaceDebug = path.resolve(__dirname, '../../target/debug', localBinName);
+  const workspaceRelease = path.resolve(__dirname, '../../target/release', localBinName);
+
+  if (fs.existsSync(workspaceRelease)) {
+    return workspaceRelease;
+  }
+  if (fs.existsSync(workspaceDebug)) {
+    return workspaceDebug;
+  }
+
+  return localBinName;
+}
+
+/**
+ * Biên dịch một tệp mã nguồn SongMa sang JavaScript hoặc TypeScript
+ * Tự động chuyển tiếp sang JavaScript Transpiler tích hợp nếu máy chưa cài binary Rust.
+ * @param {string} filePath - Đường dẫn tới tệp (.smjs hoặc .smts)
+ * @param {object} options - Tùy chọn biên dịch ({ isTs?: boolean })
+ * @returns {string} Mã nguồn JavaScript hoặc TypeScript đã biên dịch
+ */
+function transpileFile(filePath, options = {}) {
+  const isTs = options.isTs !== undefined ? options.isTs : false;
+
+  // Đọc nội dung tệp
+  const source = fs.readFileSync(filePath, 'utf-8');
+
+  // Thử gọi binary Rust `sm` trước để đạt tốc độ tối đa nếu có sẵn
+  try {
+    const bin = getBinaryPath();
+    const args = ['build', filePath];
+    if (isTs) {
+      args.push('--ts');
+    }
+
+    const result = spawnSync(bin, args, {
+      encoding: 'utf-8',
+      windowsHide: true,
+    });
+
+    if (!result.error && result.status === 0 && result.stdout) {
+      return result.stdout;
+    }
+  } catch (_) {
+    // Bỏ qua lỗi spawn để chuyển sang JavaScript Engine tích hợp sẵn
+  }
+
+  // Fallback: Chạy trình biên dịch JavaScript thuần tích hợp sẵn
+  return transpilePureJS(source, isTs);
+}
+
+/**
+ * Biên dịch một chuỗi mã nguồn SongMa
+ * @param {string} code - Chuỗi mã nguồn tiếng Việt
+ * @param {object} options - Tùy chọn biên dịch ({ filename?: string, isTs?: boolean })
+ * @returns {string}
+ */
+function transpile(code, options = {}) {
+  const isTs = options.isTs !== undefined ? options.isTs : false;
+  return transpilePureJS(code, isTs);
+}
+
+module.exports = {
+  transpile,
+  transpileFile,
+};

package/loader.mjs

@@ -0,0 +1,30 @@
+import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const { transpileFile } = require('./index.js');
+
+/**
+ * Node.js ESM resolve hook
+ */
+export async function resolve(specifier, context, nextResolve) {
+  return nextResolve(specifier, context);
+}
+
+/**
+ * Node.js ESM load hook
+ */
+export async function load(url, context, nextLoad) {
+  if (url.endsWith('.sm') || url.endsWith('.smx')) {
+    const filePath = fileURLToPath(url);
+    const source = transpileFile(filePath, { isTs: false });
+
+    return {
+      format: 'commonjs',
+      shortCircuit: true,
+      source,
+    };
+  }
+
+  return nextLoad(url, context);
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@luonghaminhvy/songma",
+  "version": "0.5.0",
+  "description": "Node.js Runtime Loader and CLI for SongMa (Sông Mã) programming language",
+  "main": "index.js",
+  "bin": {
+    "songma": "bin/songma.js",
+    "sm": "bin/songma.js"
+  },
+  "exports": {
+    ".": "./index.js",
+    "./register": "./register.js",
+    "./loader": "./loader.mjs"
+  },
+  "keywords": [
+    "songma",
+    "vietlang",
+    "vietscript",
+    "vietnamese",
+    "transpiler",
+    "loader"
+  ],
+  "author": "Luong Ha Minh Vy",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LuongHaMinhVy/SongMa.git"
+  },
+  "homepage": "https://github.com/LuongHaMinhVy/SongMa",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/register.js

@@ -0,0 +1,14 @@
+const { transpileFile } = require('./index');
+
+/**
+ * Đăng ký extension hook cho CommonJS require()
+ */
+function compileSongMa(module, filename) {
+  const compiledJs = transpileFile(filename, { isTs: false });
+  module._compile(compiledJs, filename);
+}
+
+if (require.extensions) {
+  require.extensions['.sm'] = compileSongMa;
+  require.extensions['.smx'] = compileSongMa;
+}

package/test_runner.js

@@ -0,0 +1,33 @@
+const path = require('path');
+const assert = require('assert');
+const { transpile, transpileFile } = require('./index');
+
+console.log('--- 1. Kiểm tra API transpile() ---');
+const sampleCode = `
+biến a = 10;
+biến b = 20;
+hàm tinh_tong(x, y) {
+    trả x + y;
+}
+in("Tổng: " + tinh_tong(a, b));
+`;
+const outputJs = transpile(sampleCode);
+assert(outputJs.includes('function tinh_tong'), 'Cần chứa định nghĩa hàm');
+console.log('✓ transpile() hoạt động chính xác.');
+
+console.log('--- 2. Kiểm tra require() hook (register.js) ---');
+require('./register');
+const xinChaoPath = path.resolve(__dirname, '../../examples/xin_chao.sm');
+require(xinChaoPath);
+console.log('✓ require(examples/xin_chao.sm) thành công.');
+
+console.log('--- 3. Kiểm tra transpileFile() với .smts ---');
+const tsPath = path.resolve(__dirname, '../../examples/typescript_demo.sm');
+const tsOutput = transpileFile(tsPath, { isTs: true });
+assert(tsOutput.includes('interface SanPham'), 'Cần chứa interface SanPham');
+assert(tsOutput.includes('function tinh_thue_vat'), 'Cần chứa hàm TypeScript');
+console.log('✓ transpileFile(.sm) thành công.');
+
+console.log('\n========================================');
+console.log('TẤT CẢ TEST CỦA GIAI ĐOẠN 1 ĐỀU THÀNH CÔNG!');
+console.log('========================================');

package/transpiler.js

@@ -0,0 +1,242 @@
+/**
+ * SongMa Pure JavaScript Transpiler Engine
+ * Tự động chuyển đổi mã nguồn SongMa (.smjs / .smts) sang JavaScript/TypeScript mà không cần cài đặt binary Rust.
+ */
+
+function getRuntimeHeader(isTs = false) {
+  return isTs
+    ? `// --- SongMa TypeScript Runtime Library ---
+const fs_songma = typeof require !== 'undefined' ? require('fs') : null;
+const in_songma = (...args: any[]) => console.log(...args);
+const in_dòng = in_songma;
+const in_ngang = (...args: any[]) => (typeof process !== 'undefined' ? process.stdout.write(args.join(' ')) : console.log(...args));
+const độ_dài = (item: any) => (item ? (typeof item === 'string' ? [...item].length : item.length) : 0);
+const ép_số = (val: any) => Number(val);
+const ép_chuỗi = (val: any) => String(val);
+const thời_gian = () => Date.now();
+const căn_bậc_hai = (n: number) => Math.sqrt(n);
+const làm_tròn = (n: number) => Math.round(n);
+const sàn = (n: number) => Math.floor(n);
+const trần = (n: number) => Math.ceil(n);
+const trị_tuyệt_đối = (n: number) => Math.abs(n);
+const mũ = (a: number, b: number) => Math.pow(a, b);
+const lớn_nhất = (...args: number[]) => Math.max(...args);
+const nhỏ_nhất = (...args: number[]) => Math.min(...args);
+const ngẫu_nhiên = (min?: number, max?: number) => (min !== undefined && max !== undefined ? Math.floor(Math.random() * (max - min + 1)) + min : Math.random());
+const thêm = (arr: any[], item: any) => { arr.push(item); return arr; };
+const đọc_tệp = (p: string) => (fs_songma ? fs_songma.readFileSync(p, 'utf-8') : '');
+const ghi_tệp = (p: string, data: any) => (fs_songma ? (fs_songma.writeFileSync(p, String(data), 'utf-8'), true) : false);
+const tồn_tại_tệp = (p: string) => (fs_songma ? fs_songma.existsSync(p) : false);
+const lấy_môi_trường = (k: string) => (typeof process !== 'undefined' && process.env[k] ? process.env[k] : null);
+const giải_mã_json = (s: string) => JSON.parse(s);
+const tạo_json = (v: any) => JSON.stringify(v, null, 2);
+const tách = (s: string, d = ' ') => String(s).split(d);
+const tách_chuỗi = tách;
+const nối = (arr: any[], d = '') => (Array.isArray(arr) ? arr.join(d) : String(arr));
+const nối_mảng = nối;
+const cắt = (s: string, start: number, len?: number) => (len !== undefined ? String(s).substring(start, start + len) : String(s).substring(start));
+const cắt_chuỗi = cắt;
+const viết_hoa = (s: string) => String(s).toUpperCase();
+const viết_thường = (s: string) => String(s).toLowerCase();
+const cắt_khoảng_trắng = (s: string) => String(s).trim();
+const chứa = (s: any, q: any) => (typeof s === 'string' || Array.isArray(s) ? s.includes(q) : false);
+const bắt_đầu_bằng = (s: string, prefix: string) => String(s).startsWith(prefix);
+const kết_thúc_bằng = (s: string, suffix: string) => String(s).endsWith(suffix);
+const thay_thế = (s: string, find: any, replace: string) => String(s).replace(find, replace);
+const thay_thế_tất_cả = (s: string, find: any, replace: string) => String(s).replaceAll(find, replace);
+const khớp_mẫu = (s: string, pattern: string | RegExp) => new RegExp(pattern).test(String(s));
+const mã_hóa_base64 = (s: string) => (typeof Buffer !== 'undefined' ? Buffer.from(s).toString('base64') : btoa(s));
+const giải_mã_base64 = (s: string) => (typeof Buffer !== 'undefined' ? Buffer.from(s, 'base64').toString('utf-8') : atob(s));
+const tìm = (target: any, q: any) => (typeof target === 'string' || Array.isArray(target) ? target.indexOf(q) : -1);
+const dừng_chờ = (ms: number) => { const start = Date.now(); while (Date.now() - start < ms) {} };
+const lấy_dữ_liệu = (url: string, opts?: any) => fetch(url, opts);
+const hẹn_giờ = (fn: (...args: any[]) => void, ms: number) => setTimeout(fn, ms);
+const hủy_hẹn_giờ = (id: any) => clearTimeout(id);
+const lặp_định_kỳ = (fn: (...args: any[]) => void, ms: number) => setInterval(fn, ms);
+const hủy_lặp = (id: any) => clearInterval(id);
+// --- End Runtime ---
+
+`
+    : `// --- SongMa JavaScript Runtime Library ---
+const fs_songma = typeof require !== 'undefined' ? require('fs') : null;
+const in_songma = (...args) => console.log(...args);
+const in_dòng = in_songma;
+const in_ngang = (...args) => (typeof process !== 'undefined' ? process.stdout.write(args.join(' ')) : console.log(...args));
+const độ_dài = (item) => (item ? (typeof item === 'string' ? [...item].length : item.length) : 0);
+const ép_số = (val) => Number(val);
+const ép_chuỗi = (val) => String(val);
+const thời_gian = () => Date.now();
+const căn_bậc_hai = (n) => Math.sqrt(n);
+const làm_tròn = (n) => Math.round(n);
+const sàn = (n) => Math.floor(n);
+const trần = (n) => Math.ceil(n);
+const trị_tuyệt_đối = (n) => Math.abs(n);
+const mũ = (a, b) => Math.pow(a, b);
+const lớn_nhất = (...args) => Math.max(...args);
+const nhỏ_nhất = (...args) => Math.min(...args);
+const ngẫu_nhiên = (min, max) => (min !== undefined && max !== undefined ? Math.floor(Math.random() * (max - min + 1)) + min : Math.random());
+const thêm = (arr, item) => { arr.push(item); return arr; };
+const đọc_tệp = (p) => (fs_songma ? fs_songma.readFileSync(p, 'utf-8') : '');
+const ghi_tệp = (p, data) => (fs_songma ? (fs_songma.writeFileSync(p, String(data), 'utf-8'), true) : false);
+const tồn_tại_tệp = (p) => (fs_songma ? fs_songma.existsSync(p) : false);
+const lấy_môi_trường = (k) => (typeof process !== 'undefined' && process.env[k] ? process.env[k] : null);
+const giải_mã_json = (s) => JSON.parse(s);
+const tạo_json = (v) => JSON.stringify(v, null, 2);
+const tách = (s, d = ' ') => String(s).split(d);
+const tách_chuỗi = tách;
+const nối = (arr, d = '') => (Array.isArray(arr) ? arr.join(d) : String(arr));
+const nối_mảng = nối;
+const cắt = (s, start, len) => (len !== undefined ? String(s).substring(start, start + len) : String(s).substring(start));
+const cắt_chuỗi = cắt;
+const viết_hoa = (s) => String(s).toUpperCase();
+const viết_thường = (s) => String(s).toLowerCase();
+const cắt_khoảng_trắng = (s) => String(s).trim();
+const chứa = (s, q) => (typeof s === 'string' || Array.isArray(s) ? s.includes(q) : false);
+const bắt_đầu_bằng = (s, prefix) => String(s).startsWith(prefix);
+const kết_thúc_bằng = (s, suffix) => String(s).endsWith(suffix);
+const thay_thế = (s, find, replace) => String(s).replace(find, replace);
+const thay_thế_tất_cả = (s, find, replace) => String(s).replaceAll(find, replace);
+const khớp_mẫu = (s, pattern) => new RegExp(pattern).test(String(s));
+const mã_hóa_base64 = (s) => (typeof Buffer !== 'undefined' ? Buffer.from(s).toString('base64') : btoa(s));
+const giải_mã_base64 = (s) => (typeof Buffer !== 'undefined' ? Buffer.from(s, 'base64').toString('utf-8') : atob(s));
+const tìm = (target, q) => (typeof target === 'string' || Array.isArray(target) ? target.indexOf(q) : -1);
+const dừng_chờ = (ms) => { const start = Date.now(); while (Date.now() - start < ms) {} };
+const lấy_dữ_liệu = (url, opts) => fetch(url, opts);
+const hẹn_giờ = (fn, ms) => setTimeout(fn, ms);
+const hủy_hẹn_giờ = (id) => clearTimeout(id);
+const lặp_định_kỳ = (fn, ms) => setInterval(fn, ms);
+const hủy_lặp = (id) => clearInterval(id);
+if (typeof Array !== 'undefined') {
+  const ap = Array.prototype;
+  ap.ánh_xạ = ap.map; ap.lọc = ap.filter; ap.thu_gọn = ap.reduce; ap.duyệt = ap.forEach; ap.cho_mỗi = ap.forEach;
+  ap.tìm = ap.find; ap.tìm_vị_trí = ap.findIndex; ap.có_ít_nhất = ap.some; ap.tất_cả = ap.every;
+  ap.chứa = ap.includes; ap.bao_gồm = ap.includes; ap.thêm = ap.push; ap.đẩy = ap.push;
+  ap.rút = ap.pop; ap.lấy_ra = ap.pop; ap.thêm_đầu = ap.unshift; ap.lấy_đầu = ap.shift;
+  ap.trích = ap.slice; ap.cắt = ap.slice; ap.chắp_vá = ap.splice; ap.sắp_xếp = ap.sort;
+  ap.đảo_ngược = ap.reverse; ap.nối = ap.join; ap.gộp = ap.concat; ap.làm_phẳng = ap.flat;
+  ap.ánh_xạ_phẳng = ap.flatMap; ap.lấp_đầy = ap.fill; ap.vị_trí = ap.indexOf; ap.vị_trí_cuối = ap.lastIndexOf;
+}
+if (typeof String !== 'undefined') {
+  const sp = String.prototype;
+  sp.viết_hoa = sp.toUpperCase; sp.viết_thường = sp.toLowerCase; sp.cắt_khoảng_trắng = sp.trim;
+  sp.cắt_đầu = sp.trimStart; sp.cắt_đuôi = sp.trimEnd; sp.bắt_đầu_bằng = sp.startsWith; sp.kết_thúc_bằng = sp.endsWith;
+  sp.chứa = sp.includes; sp.thay_thế = sp.replace; sp.thay_thế_tất_cả = sp.replaceAll; sp.tách = sp.split;
+  sp.cắt = sp.substring; sp.khớp_mẫu = function(pattern) { return new RegExp(pattern).test(this); };
+}
+// --- End Runtime ---
+
+`;
+}
+
+function transpilePureJS(source, isTs = false) {
+  const runtimeHeader = getRuntimeHeader(isTs);
+  let code = source;
+
+  // 1. Chuyển đổi Interface / Kiểu & Enum
+  if (isTs) {
+    code = code.replace(/\b(?:kiểu|mẫu|giao_diện)\s+([a-zA-Z_À-ỹ][a-zA-Z0-9_À-ỹ]*)\s*\{/g, 'interface $1 {');
+    code = code.replace(/\bchỉ_đọc\s+/g, 'readonly ');
+    code = code.replace(/:\s*chuỗi\b/g, ': string');
+    code = code.replace(/:\s*số\b/g, ': number');
+    code = code.replace(/:\s*(?:logic|đúng_sai)\b/g, ': boolean');
+    code = code.replace(/:\s*mọi\b/g, ': any');
+    code = code.replace(/:\s*rỗng\b/g, ': void');
+    code = code.replace(/:\s*đối_tượng\b/g, ': Record<string, any>');
+    code = code.replace(/:\s*mảng<([^>]+)>/g, ': $1[]');
+    code = code.replace(/:\s*mảng\b/g, ': any[]');
+  } else {
+    // Xóa interface ở chế độ JavaScript thuần
+    code = code.replace(/\b(?:kiểu|mẫu|giao_diện)\s+[a-zA-Z_À-ỹ][a-zA-Z0-9_À-ỹ]*\s*\{[^}]*\}/g, '');
+    code = code.replace(/\bchỉ_đọc\s+/g, '');
+    // Xóa kiểu trả về của hàm và kiểu tham số/biến
+    code = code.replace(/\)\s*:\s*(?:mảng<[^>]+>|[a-zA-Z_À-ỹ][a-zA-Z0-9_À-ỹ]*(?:\s*\[\s*\])*)/g, ')');
+    code = code.replace(/([a-zA-Z_À-ỹ0-9]+)\s*:\s*(?:mảng<[^>]+>|[a-zA-Z_À-ỹ][a-zA-Z0-9_À-ỹ]*(?:\s*\[\s*\])*)(?=[,\)=;\r\n])/g, '$1');
+  }
+
+  // Liệt kê (Enum)
+  if (isTs) {
+    code = code.replace(/(^|[\r\n\s;{}()])liệt_kê\s+([a-zA-Z_À-ỹ][a-zA-Z0-9_À-ỹ]*)\s*\{/g, (_, p1, p2) => p1 + 'enum ' + p2 + ' {');
+  } else {
+    code = code.replace(/(^|[\r\n\s;{}()])liệt_kê\s+([a-zA-Z_À-ỹ][a-zA-Z0-9_À-ỹ]*)\s*\{([^}]*)\}/g, (_, p1, p2, p3) => {
+      const entries = p3.split(',').map(item => item.trim()).filter(Boolean);
+      const objEntries = entries.map((e, idx) => {
+        if (e.includes('=')) {
+          const [k, v] = e.split('=').map(s => s.trim());
+          return `  ${k}: ${v}`;
+        }
+        return `  ${e}: ${idx}`;
+      }).join(',\n');
+      return `${p1}const ${p2} = Object.freeze({\n${objEntries}\n});`;
+    });
+  }
+
+  // Xuất khẩu (Export)
+  code = code.replace(/(^|[\r\n\s;{}()])xuất_mặc_định\s+/g, (_, p1) => p1 + 'export default ');
+  code = code.replace(/(^|[\r\n\s;{}()])xuất\s+/g, (_, p1) => p1 + 'export ');
+
+  // 2. Chuyển đổi từ khóa cốt lõi
+  code = code.replace(/(^|[\r\n\s;{}()])lớp\s+([^\s;{}()]+)\s+kế_thừa\s+([^\s;{}()]+)\s+hiện_thực\s+([^\s;{}()]+)\s*\{/g, (_, p1, p2, p3, p4) => p1 + 'class ' + p2 + ' extends ' + p3 + (isTs ? ' implements ' + p4 : '') + ' {');
+  code = code.replace(/(^|[\r\n\s;{}()])lớp\s+([^\s;{}()]+)\s+kế_thừa\s+([^\s;{}()]+)\s*\{/g, (_, p1, p2, p3) => p1 + 'class ' + p2 + ' extends ' + p3 + ' {');
+  code = code.replace(/(^|[\r\n\s;{}()])lớp\s+([^\s;{}()]+)\s+hiện_thực\s+([^\s;{}()]+)\s*\{/g, (_, p1, p2, p3) => p1 + 'class ' + p2 + (isTs ? ' implements ' + p3 : '') + ' {');
+  code = code.replace(/(^|[\r\n\s;{}()])lớp\s+([^\s;{}()]+)\s*\{/g, (_, p1, p2) => p1 + 'class ' + p2 + ' {');
+
+  code = code.replace(/\btĩnh\s+(?:hàm\s+)?/g, 'static ');
+  code = code.replace(/\blấy\s+([a-zA-Z_À-ỹ][a-zA-Z0-9_À-ỹ]*)\s*\(/g, 'get $1(');
+  code = code.replace(/\bgán\s+([a-zA-Z_À-ỹ][a-zA-Z0-9_À-ỹ]*)\s*\(/g, 'set $1(');
+
+  code = code.replace(/khởi_tạo\s*\(/g, 'constructor(');
+  code = code.replace(/gốc\s*\(/g, 'super(');
+  code = code.replace(/(^|[\r\n\s;{}()])mới\s+/g, (_, p1) => p1 + 'new ');
+  code = code.replace(/này\./g, 'this.');
+  code = code.replace(/(^|[\r\n\s;{}()])này(?=[\s;,):])/g, (_, p1) => p1 + 'this');
+  code = code.replace(/(^|[\r\n\s;{}()])(?:biến|đặt)\s+/g, (_, p1) => p1 + 'let ');
+  code = code.replace(/(^|[\r\n\s;{}()])hằng\s+/g, (_, p1) => p1 + 'const ');
+  code = code.replace(/(^|[\r\n\s;{}()])(?:bất_đồng_bộ|bất_đồng)\s+hàm\b/g, (_, p1) => p1 + 'async function');
+  code = code.replace(/(^|[\r\n\s;{}()])hàm\b/g, (_, p1) => p1 + 'function');
+  code = code.replace(/(^|[\r\n\s;{}()])(?:trả_về|trả)\s+/g, (_, p1) => p1 + 'return ');
+
+  // Switch - Case
+  code = code.replace(/(^|[\r\n\s;{}()])chọn\s*\(/g, (_, p1) => p1 + 'switch (');
+  code = code.replace(/(^|[\r\n\s;{}()])trường_hợp\s+/g, (_, p1) => p1 + 'case ');
+  code = code.replace(/(^|[\r\n\s;{}()])mặc_định\s*:/g, (_, p1) => p1 + 'default:');
+
+  // Control Flow & Loops
+  code = code.replace(/(^|[\r\n\s;{}()])nếu\s*\(/g, (_, p1) => p1 + 'if (');
+  code = code.replace(/(^|[\r\n\s;{}()])khác_nếu\s*\(/g, (_, p1) => p1 + 'else if (');
+  code = code.replace(/(^|[\r\n\s;{}()])(?:ngược_lại|khác)\s*\{/g, (_, p1) => p1 + 'else {');
+
+  code = code.replace(/(^|[\r\n\s;{}()])làm\s*\{/g, (_, p1) => p1 + 'do {');
+  code = code.replace(/(^|[\r\n\s;{}()])(?:trong_khi|khi)\s*\(/g, (_, p1) => p1 + 'while (');
+  code = code.replace(/(^|[\r\n\s;{}()])(?:cho_mỗi|mỗi)\s*\(\s*([^\s]+)\s+trong\s+([^)]+)\)/g, (_, p1, p2, p3) => p1 + 'for (const ' + p2 + ' of ' + p3 + ')');
+  code = code.replace(/(^|[\r\n\s;{}()])lặp\s*\(/g, (_, p1) => p1 + 'for (');
+  code = code.replace(/(^|[\r\n\s;{}()])(?:tiếp_tục|tiếp)\s*;/g, (_, p1) => p1 + 'continue;');
+  code = code.replace(/(^|[\r\n\s;{}()])dừng\s*;/g, (_, p1) => p1 + 'break;');
+
+  // Error Handling
+  code = code.replace(/(^|[\r\n\s;{}()])ném\s+/g, (_, p1) => p1 + 'throw ');
+  code = code.replace(/(^|[\r\n\s;{}()])thử\s*\{/g, (_, p1) => p1 + 'try {');
+  code = code.replace(/(^|[\r\n\s;{}()])(?:bắt_lỗi|bắt)\s*\(\s*([^\s)]+)\s*\)\s*\{/g, (_, p1, p2) => p1 + 'catch (' + p2 + ') {');
+  code = code.replace(/(^|[\r\n\s;{}()])cuối_cùng\s*\{/g, (_, p1) => p1 + 'finally {');
+
+  // Yield & Await
+  code = code.replace(/(^|[\r\n\s;{}()])nhượng\s+/g, (_, p1) => p1 + 'yield ');
+  code = code.replace(/(^|[\r\n\s;{}()])(?:chờ|đợi)\s+/g, (_, p1) => p1 + 'await ');
+
+  // Module imports
+  code = code.replace(/(^|[\r\n\s;{}()])dùng\s+"([^"]+)"\s+là\s+([^\s;]+)\s*;/g, (_, p1, p2, p3) => p1 + 'const ' + p3 + ' = require("' + p2 + '");');
+  code = code.replace(/(^|[\r\n\s;{}()])dùng\s+"([^"]+)"\s*;/g, (_, p1, p2) => p1 + 'require("' + p2 + '");');
+
+  // 3. Giá trị hằng ngữ nghĩa
+  code = code.replace(/(^|[\r\n\s;{}()])đúng(?=[\s;,):])/g, (_, p1) => p1 + 'true');
+  code = code.replace(/(^|[\r\n\s;{}()])sai(?=[\s;,):])/g, (_, p1) => p1 + 'false');
+  code = code.replace(/(^|[\r\n\s;{}()])rỗng(?=[\s;,):])/g, (_, p1) => p1 + 'null');
+
+  // 4. Hàm in
+  code = code.replace(/\b(?:in_dòng|in)\s*\(/g, 'in_songma(');
+
+  return runtimeHeader + code;
+}
+
+module.exports = {
+  transpilePureJS,
+};