nattoppet 4.0.1 → 4.1.0

package/package.json

@@ -1,50 +1,32 @@
 {
   "name": "nattoppet",
-  "version": "4.0.1",
+  "version": "4.1.0",
   "description": "A tiny macro-based markup language for blogging",
   "author": "ylxdzsw <ylxdzsw@gmail.com>",
   "license": "MIT",
   "type": "module",
   "files": [
-    "nattoppet.ts",
-    "nattoppet-dev.ts",
-    "nattoppet-init.ts",
-    "nattoppet-native.ts",
-    "compiler.ts",
-    "stdlib.ts",
-    "common.ymd",
-    "vue.ymd",
-    "form.ymd",
-    "katex.ymd",
-    "koa.ymd",
-    "ppt.ymd",
-    "tml.ymd",
-    "vue.css",
-    "form.css",
-    "form.js",
-    "koa.css",
-    "ppt.css",
-    "ppt.js",
-    "tml.css",
-    "tml.js",
-    "katex.css",
+    "dist",
     "GUIDE.md",
-    "README.md"
+    "readme.md"
   ],
   "bin": {
-    "nattoppet": "./nattoppet.ts",
-    "nattoppet-dev": "./nattoppet-dev.ts",
-    "nattoppet-init": "./nattoppet-init.ts",
-    "nattoppet-native": "./nattoppet-native.ts"
+    "nattoppet": "./dist/nattoppet.js",
+    "nattoppet-dev": "./dist/nattoppet-dev.js",
+    "nattoppet-init": "./dist/nattoppet-init.js",
+    "nattoppet-native": "./dist/nattoppet-native.js"
   },
   "scripts": {
-    "build": "bun build ./nattoppet.ts --outdir=./dist --target=bun",
-    "dev": "bun run --watch ./nattoppet-dev.ts",
-    "test": "bun test",
-    "test:watch": "bun test --watch",
-    "compile": "bun run ./nattoppet.ts",
-    "init": "bun run ./nattoppet-init.ts",
-    "native": "bun run ./nattoppet-native.ts"
+    "build": "node scripts/build-package.mjs",
+    "build:binary": "bun build ./nattoppet.ts --compile --outfile=./binary-dist/nattoppet",
+    "prepack": "npm run build",
+    "dev": "node nattoppet-dev.ts",
+    "test": "node --test",
+    "test:bun": "bun test",
+    "test:watch": "node --test --watch",
+    "compile": "node nattoppet.ts",
+    "init": "node nattoppet-init.ts",
+    "native": "node nattoppet-native.ts"
   },
   "dependencies": {
     "coffeescript": "^2.7.0",
@@ -53,8 +35,10 @@
     "less": "^4.2.0",
     "marked": "^9.1.6"
   },
-  "devDependencies": { },
+  "devDependencies": {
+    "esbuild": "^0.25.0"
+  },
   "engines": {
-    "bun": ">=1.0.0"
+    "node": ">=22.18.0"
   }
 }

package/readme.md

@@ -5,36 +5,42 @@ A tiny markup language and themes for making documents, slides, or web apps as s
 
 ### Usage
 
+Install Nattoppet with Node.js 22.18 or newer:
+
+```bash
+npm install -g nattoppet
+```
+
 Compile a nattoppet file:
 
 ```bash
-bun run nattoppet.ts in.ymd > out.html
+nattoppet in.ymd > out.html
 ```
 
 Compile a nattoppet file but don't minimize (for debugging):
 
 ```bash
-bun run nattoppet.ts in.ymd --dev > out.html
+nattoppet in.ymd --dev > out.html
 ```
 
 Open a browser to preview a nattoppet file; rebuild every time the page is refreshed:
 
 ```bash
-bun run nattoppet-dev.ts in.ymd
+nattoppet-dev in.ymd
 ```
 
 Initialize a new project:
 
 ```bash
-bun run nattoppet-init.ts form
+nattoppet-init form
 ```
 
 Build a double-clickable executable for the page:
 
 ```bash
-bun run nattoppet-native.ts init
+nattoppet-native init
 # (edit the metadata as needed)
-bun run nattoppet-native.ts build in.ymd
+nattoppet-native build in.ymd
 ```
 
 

package/compiler.ts

@@ -1,169 +0,0 @@
-import vm from "node:vm"
-import { extname } from "node:path"
-import { fileURLToPath } from "node:url"
-import * as fs from "node:fs"
-
-const pattern = /^(?:\[(.+?)\]([:=])|\[(mixin|#slot)\] ?(.*?)\n)/m
-
-const fetch_text_file = async (path: string) => {
-    const filePath = new URL(path, import.meta.url)
-    return fs.readFileSync(fileURLToPath(filePath), 'utf-8')
-}
-
-const file_exists = (path: string) => {
-    try {
-        const filePath = new URL(path, import.meta.url)
-        fs.accessSync(fileURLToPath(filePath))
-        return true
-    } catch {
-        return false
-    }
-}
-
-const resolve_mixin_path = (path: string): string => {
-    if (extname(path)) return path
-    // Compatibility hack: bare name only resolves to .ymd if exact file doesn't exist
-    if (file_exists(path)) return path
-    const ymdPath = path + ".ymd"
-    if (file_exists(ymdPath)) return ymdPath
-    throw `mixin not found: ${path}`
-}
-
-// tokenize also process mixins
-// mixins are special direvatives
-// by default, they are relative to the root directory of nattoppet, unless they are prefixed with "./"
-export const tokenize = async (str: string) => {
-    const tokens: any[] = []
-
-    while (true) {
-        const m = str.match(pattern)
-        if (!m || m.index == null) {
-            if (str) tokens.push({ type: "code", content: str })
-            break
-        }
-
-        if (m.index && m.index > 0) {
-            tokens.push({ type: "code", content: str.substring(0, m.index) })
-        }
-
-        if (m[3]) {
-            if (m[3] === 'mixin') {
-                tokens.push({ type: 'mixin', path: m[4] })
-            } else if (m[3] === '#slot') {
-                tokens.push({ type: 'slot' })
-            }
-            str = str.substring(m.index + m[0].length)
-            continue
-        }
-
-        const name = m[1]
-        const type = m[2] == ':' ? 'ref' : 'fn'
-        str = str.substring(m.index + m[0].length)
-
-        const p1 = str.indexOf('\n\n')
-        const p2 = str.search(pattern)
-        const p = p1 >= 0 && p2 >= 0 ? Math.min(p1+2, p2) :
-                  p1 < 0 && p2 < 0 ? str.length : Math.max(p1+2, p2)
-
-        const content = str.substring(0, p).trim()
-        str = str.substring(p)
-
-        tokens.push({ type, name, content })
-    }
-
-    for (let i = 0; i < tokens.length; i++) if (tokens[i].type == 'mixin') {
-        const resolvedPath = resolve_mixin_path(tokens[i].path)
-        const ext = extname(resolvedPath)
-
-        if (ext === ".ymd") {
-            const text = await fetch_text_file(resolvedPath)
-            const inlineTokens = await tokenize(text)
-            const slotIndices = inlineTokens
-                .map((t: any, idx: number) => t.type === 'slot' ? idx : -1)
-                .filter((idx: number) => idx >= 0)
-
-            if (slotIndices.length > 1) {
-                throw `multiple [#slot] in mixin ${resolvedPath}`
-            } else if (slotIndices.length === 1) {
-                const slotIdx = slotIndices[0]
-                const head = inlineTokens.slice(0, slotIdx)
-                const tail = inlineTokens.slice(slotIdx + 1)
-                tokens.splice(i, 1, ...head)
-                tokens.push(...tail)
-            } else {
-                tokens.splice(i, 1, ...inlineTokens)
-            }
-        } else {
-            tokens[i] = { type: "raw", content: await fetch_text_file(resolvedPath) }
-        }
-
-        i -= 1 // revisit i since we replaced it
-    }
-
-    return tokens
-}
-
-const _interpret = (str: string, env: any, defs: any[]): any => {
-    const p1 = str.search(/^  /m)
-    const p2 = str.search(/\[(.+?)\]/)
-    if (p1 < 0 && p2 < 0) return str
-
-    if (p2 < 0 || (p1 >= 0 && p1 < p2)) {
-        const head = str.substring(0, p1)
-        str = str.substring(p1+2)
-        let p = str.indexOf('\n\n')
-        if (p < 0) p = str.length
-        return head + '<p>' + _interpret(str.substring(0, p), env, defs) + '</p>' + _interpret(str.substring(p+2), env, defs)
-    }
-
-    const name = str.match(/\[(.+?)\]/)![1]
-    const i = defs.findIndex(x => x.name == name)
-    if (i < 0) throw `definition ${name} not found`
-
-    const def = defs[i]
-    switch (def.type) {
-        case 'fn':
-            env.remaining = str.substring(p2 + name.length + 2)
-            env.interpret = (str: string) => { // a "scoped" interpret function capable for interpreting substrings. We preserve the "remaining" property outside.
-                const remaining = env.remaining
-                const result = _interpret(str, env, defs) // We gaved full defs available on the call site (dynamic scoping) as the text to be interpreted is part of the call site text.
-                env.remaining = remaining
-                return result
-            }
-            const result = vm.runInContext('{' + def.content + '}', env)
-            return str.substring(0, p2) + result + _interpret(env.remaining, env, defs)
-        case 'ref':
-            return str.substring(0, p2) +
-                _interpret(def.content, env, defs.slice(i+1)) + // Exclude self from scope to prevent infinite recursion, but allow forward references
-                _interpret(str.substring(p2 + name.length + 2), env, defs)
-        default: throw 'unknown defs type'
-    }
-}
-
-export const compile = async (str: string, locals: any = {}) => {
-    const env = vm.createContext(locals)
-    for (const k in env) if (typeof(env[k]) == 'function')
-        env[k] = env[k].bind(env)
-
-    let tokens = await tokenize(str)
-    let output = ''
-    while (true) {
-        const token = tokens.shift()
-        if (!token) return output
-        switch (token.type) {
-            case "code":
-                output += _interpret(token.content, env, tokens)
-                break
-            case "raw":
-                output += token.content
-                break
-        }
-    }
-}
-
-/*
-TODO:
-1. support first-class markdown-like nestable lists
-2. cleanup the spaces, carefully define when to trim
-3. require a newline before indent to open paragraph?
-*/

package/nattoppet-dev.ts

@@ -1,94 +0,0 @@
-import * as fs from "node:fs"
-import * as path from "node:path"
-import { fileURLToPath } from "node:url"
-
-const file = process.argv[2]
-
-if (process.argv.length < 3 || file == "--help") {
-    console.log("Usage: nattoppet-dev [file] [hook cmd]...")
-    process.exit(0)
-}
-
-const nattoppetPath = fileURLToPath(new URL("nattoppet.ts", import.meta.url))
-
-Bun.serve({
-    port: 3939,
-    async fetch(request) {
-        const url = new URL(request.url)
-        
-        // Static file serving
-        if (url.pathname !== '/') {
-            try {
-                const filePath = path.join(process.cwd(), decodeURIComponent(url.pathname))
-                const file = Bun.file(filePath)
-                if (await file.exists()) {
-                    return new Response(file)
-                }
-            } catch (e) {
-                console.error(e)
-            }
-            return new Response(null, { status: 404 })
-        }
-        
-        // Run build hooks if specified
-        if (process.argv.length > 3) {
-            const hookProc = Bun.spawn(process.argv.slice(3))
-            const exitCode = await hookProc.exited
-            
-            if (exitCode !== 0) {
-                console.warn("!!! hook command exit with non-0 status")
-                return new Response("Hook command failed", { status: 500 })
-            }
-        }
-        
-        // Compile the nattoppet file
-        const compileProc = Bun.spawn([
-            process.execPath,
-            "run",
-            nattoppetPath,
-            file,
-            "--dev"
-        ], {
-            stdout: 'pipe',
-            stderr: 'pipe'
-        })
-        
-        const [stdout, stderr] = await Promise.all([
-            new Response(compileProc.stdout).arrayBuffer(),
-            new Response(compileProc.stderr).text()
-        ])
-        
-        const exitCode = await compileProc.exited
-        
-        if (stderr) {
-            console.error(stderr)
-        }
-        
-        const content = exitCode === 0 ? new Uint8Array(stdout) : new TextEncoder().encode("Compilation failed")
-        
-        return new Response(content, {
-            headers: {
-                "Content-Type": "text/html"
-            },
-            status: 200
-        })
-    }
-})
-
-console.log("Server running at http://127.0.0.1:3939")
-
-// Open browser
-const platform = process.platform
-const browser = process.env.BROWSER ?? (
-    platform === 'darwin' ? 'open' :
-    platform === 'win32' ? 'start' :
-    'xdg-open'
-)
-
-const browserCmd = browser.includes('chrom')
-    ? [browser, "--app=http://127.0.0.1:3939"]
-    : [browser, "http://127.0.0.1:3939"]
-
-Bun.spawn(browserCmd, { 
-    stdio: ['ignore', 'ignore', 'ignore']
-})

package/nattoppet-native.ts

@@ -1,116 +0,0 @@
-import * as fs from "node:fs"
-import * as path from "node:path"
-import { fileURLToPath } from "node:url"
-
-const main_source = `\
-#![windows_subsystem = "windows"]
-
-use web_view::*;
-
-fn main() {
-    static HTML_CONTENT: &str = include_str!("../target/bundle.html");
-
-    web_view::builder()
-        .title("Nattoppet Native")
-        .content(Content::Html(HTML_CONTENT))
-        .size(600, 480)
-        .resizable(false)
-        .debug(cfg!(debug_assertions))
-        .user_data(())
-        .invoke_handler(handler)
-        .run()
-        .unwrap();
-}
-
-fn handler(webview: &mut WebView<()>, arg: &str) -> WVResult {
-    Ok(())
-}
-`
-
-const build_source = `\
-#[cfg(windows)]
-extern crate winres;
-
-#[cfg(windows)]
-fn main() {
-    let mut res = winres::WindowsResource::new();
-    res.set_icon("../icon.ico");
-    res.compile().unwrap();
-}
-
-#[cfg(not(windows))]
-fn main() {}
-`
-
-const cargo_source = `\
-[package]
-name = "nattoppet_native"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-web-view = { version = "0.7", features = ["edge"] }
-
-[target.'cfg(windows)'.build-dependencies]
-winres = "0.1"
-
-[package.metadata.winres]
-ProductName = "A nattoppet native app"
-`
-
-const init = () => {
-    fs.mkdirSync('native', { recursive: true })
-    fs.mkdirSync('native/src', { recursive: true })
-    fs.mkdirSync('native/target', { recursive: true })
-    fs.writeFileSync("native/src/main.rs", main_source)
-    fs.writeFileSync("native/build.rs", build_source)
-    fs.writeFileSync("native/Cargo.toml", cargo_source)
-}
-
-const bundle = async () => {
-    const nattoppetPath = fileURLToPath(new URL("nattoppet.ts", import.meta.url))
-    const proc = Bun.spawn([
-        process.execPath,
-        "run",
-        nattoppetPath,
-        process.argv[3]
-    ], {
-        stdout: 'pipe',
-        stderr: 'pipe'
-    })
-    
-    const [stdout, stderr] = await Promise.all([
-        new Response(proc.stdout).arrayBuffer(),
-        new Response(proc.stderr).text()
-    ])
-    
-    if (stderr)
-        console.error(stderr)
-    
-    await Bun.write('native/target/bundle.html', stdout)
-}
-
-const build = async () => {
-    await bundle()
-    const proc = Bun.spawn(['cargo', 'build', '--release'], {
-        cwd: 'native'
-    })
-    
-    const exitCode = await proc.exited
-    if (exitCode != 0) {
-        console.error("Cargo exit with code: " + exitCode)
-    } else {
-        console.log("building finished. Check native/target/release/")
-    }
-}
-
-const help = () => {
-    console.log("Usage: nattoppet-native [init|bundle|build] <file.ymd>")
-}
-
-switch (process.argv[2]) {
-    case 'init': init(); break
-    case 'bundle': bundle(); break
-    case 'build': build(); break
-    default: help(); break
-}

package/nattoppet.ts

@@ -1,35 +0,0 @@
-import * as path from "node:path"
-import * as fs from "node:fs"
-import minifier from "html-minifier-terser"
-
-import stdlib from "./stdlib.ts"
-import * as compiler from "./compiler.ts"
-
-const compiled = await (async () => {
-    const file = process.argv[2]
-    if (file) {
-        const dir = path.dirname(path.resolve(file))
-        const code = fs.readFileSync(file, 'utf-8')
-        return await compiler.compile(code, { ...stdlib, base_dir: dir })
-    } else {
-        const dir = process.cwd()
-        const chunks: Uint8Array[] = []
-        for await (const chunk of process.stdin) {
-            chunks.push(chunk)
-        }
-        const code = Buffer.concat(chunks).toString('utf-8')
-        return await compiler.compile(code, { ...stdlib, base_dir: dir })
-    }
-})()
-
-const minified = process.argv.includes('--dev') ? compiled : await minifier.minify(compiled, {
-    collapseWhitespace: true,
-    removeAttributeQuotes: true,
-    removeComments: true,
-    removeRedundantAttributes: true,
-    removeOptionalTags: true,
-    minifyCSS: true,
-    minifyJS: true,
-})
-
-process.stdout.write(minified)

package/stdlib.ts

@@ -1,120 +0,0 @@
-import * as path from "node:path"
-import * as fs from "node:fs"
-import * as zlib from "node:zlib"
-
-import { marked } from "marked"
-import coffee from "coffeescript"
-import katex from "katex"
-import less from "less"
-
-function compress_sync(data: ArrayBuffer) {
-    // Keep using zlib.deflateRawSync for browser compatibility
-    // Browser uses DecompressionStream("deflate-raw") which expects raw deflate
-    return zlib.deflateRawSync(new Uint8Array(data), {
-        flush: zlib.constants.Z_FINISH,
-        level: zlib.constants.Z_BEST_COMPRESSION
-    })
-}
-
-export default {
-    skip(n: number) {
-        this.remaining = this.remaining.substring(n)
-    },
-
-    capture_until(delimiter: string) {
-        const p = this.remaining.indexOf(delimiter)
-        if (p < 0) {
-            const result = this.remaining
-            this.remaining = ""
-            return result
-        }
-        const result = this.remaining.substring(0, p)
-        this.remaining = this.remaining.substring(p + delimiter.length)
-        return result
-    },
-
-    std_call(hascontent = false) {
-        const opts: string[] = [], args: string[] = []
-        const parse_option = () => {
-            const m = this.remaining.match(/^\.([\w\-]+)/)
-            this.skip(m[0].length)
-            opts.push(m[1])
-        }
-        const parse_argument = () => {
-            const m = this.remaining.match(/^\((.*?)\)|{(.*?)}/)
-            this.skip(m[0].length)
-            args.push(m[1] || m[2])
-        }
-        const parse_block = () => {
-            const m = this.remaining.match(/^(>+)\n?/)
-            this.skip(m[0].length)
-            return this.capture_until('<'.repeat(m[1].length))
-        }
-
-        while (true) {
-            switch (this.remaining[0]) {
-                case '.':
-                    parse_option()
-                    break
-                case '(':
-                case '{':
-                    parse_argument()
-                    break
-                case '>':
-                    return { opts, args, block: parse_block() }
-                case ' ':
-                    if (hascontent)
-                        return { opts, args, block: this.capture_until('\n').slice(1) }
-                default:
-                    return { opts, args }
-            }
-        }
-    },
-
-    rpath(file: string) {
-        if (!path.isAbsolute(file))
-            return path.join(this.base_dir, file)
-        return file
-    },
-
-    read(file: string, encoding = "utf-8") {
-        const filePath = this.rpath(file)
-        switch (encoding) {
-            case "utf8":
-            case "utf-8":
-                return fs.readFileSync(filePath, 'utf-8')
-            case "base64":
-                return Buffer.from(fs.readFileSync(filePath)).toString('base64')
-            case "compressed-base64":
-                return Buffer.from(compress_sync(fs.readFileSync(filePath))).toString('base64')
-            default:
-                throw "unknown encoding: " + encoding
-        }
-    },
-
-    extname(file: string) {
-        return path.extname(file).slice(1)
-    },
-
-    basename(file: string) {
-        return path.basename(file)
-    },
-
-    render_coffee(str: string, options: any) {
-        return coffee.compile(str, options)
-    },
-
-    render_less(str: string) {
-        let x: any; less.render(str, {}, (err: any, out: any) => !err && (x = out))
-        if (!x) throw "less failed to compile synchronously"
-        return x.css
-    },
-
-    render_markdown(str: string) {
-        return marked.parse(str)
-    },
-
-    render_katex(str: string, displayMode = false) {
-        return katex.renderToString(str, { displayMode, output: 'html' })
-    }
-} as any