@mikrojs/quickjs 0.0.7

package/deps/quickjs/unicode_gen_def.h

@@ -0,0 +1,310 @@
+#ifdef UNICODE_GENERAL_CATEGORY
+DEF(Cn, "Unassigned") /* must be zero */
+DEF(Lu, "Uppercase_Letter")
+DEF(Ll, "Lowercase_Letter")
+DEF(Lt, "Titlecase_Letter")
+DEF(Lm, "Modifier_Letter")
+DEF(Lo, "Other_Letter")
+DEF(Mn, "Nonspacing_Mark")
+DEF(Mc, "Spacing_Mark")
+DEF(Me, "Enclosing_Mark")
+DEF(Nd, "Decimal_Number,digit")
+DEF(Nl, "Letter_Number")
+DEF(No, "Other_Number")
+DEF(Sm, "Math_Symbol")
+DEF(Sc, "Currency_Symbol")
+DEF(Sk, "Modifier_Symbol")
+DEF(So, "Other_Symbol")
+DEF(Pc, "Connector_Punctuation")
+DEF(Pd, "Dash_Punctuation")
+DEF(Ps, "Open_Punctuation")
+DEF(Pe, "Close_Punctuation")
+DEF(Pi, "Initial_Punctuation")
+DEF(Pf, "Final_Punctuation")
+DEF(Po, "Other_Punctuation")
+DEF(Zs, "Space_Separator")
+DEF(Zl, "Line_Separator")
+DEF(Zp, "Paragraph_Separator")
+DEF(Cc, "Control,cntrl")
+DEF(Cf, "Format")
+DEF(Cs, "Surrogate")
+DEF(Co, "Private_Use")
+/* synthetic properties */
+DEF(LC, "Cased_Letter")
+DEF(L, "Letter")
+DEF(M, "Mark,Combining_Mark")
+DEF(N, "Number")
+DEF(S, "Symbol")
+DEF(P, "Punctuation,punct")
+DEF(Z, "Separator")
+DEF(C, "Other")
+#endif
+
+#ifdef UNICODE_SCRIPT
+/* scripts aliases names in PropertyValueAliases.txt */
+DEF(Unknown, "Zzzz")
+DEF(Adlam, "Adlm")
+DEF(Ahom, "Ahom")
+DEF(Anatolian_Hieroglyphs, "Hluw")
+DEF(Arabic, "Arab")
+DEF(Armenian, "Armn")
+DEF(Avestan, "Avst")
+DEF(Balinese, "Bali")
+DEF(Bamum, "Bamu")
+DEF(Bassa_Vah, "Bass")
+DEF(Batak, "Batk")
+DEF(Bengali, "Beng")
+DEF(Beria_Erfe, "Berf")
+DEF(Bhaiksuki, "Bhks")
+DEF(Bopomofo, "Bopo")
+DEF(Brahmi, "Brah")
+DEF(Braille, "Brai")
+DEF(Buginese, "Bugi")
+DEF(Buhid, "Buhd")
+DEF(Canadian_Aboriginal, "Cans")
+DEF(Carian, "Cari")
+DEF(Caucasian_Albanian, "Aghb")
+DEF(Chakma, "Cakm")
+DEF(Cham, "Cham")
+DEF(Cherokee, "Cher")
+DEF(Chorasmian, "Chrs")
+DEF(Common, "Zyyy")
+DEF(Coptic, "Copt,Qaac")
+DEF(Cuneiform, "Xsux")
+DEF(Cypriot, "Cprt")
+DEF(Cyrillic, "Cyrl")
+DEF(Cypro_Minoan, "Cpmn")
+DEF(Deseret, "Dsrt")
+DEF(Devanagari, "Deva")
+DEF(Dives_Akuru, "Diak")
+DEF(Dogra, "Dogr")
+DEF(Duployan, "Dupl")
+DEF(Egyptian_Hieroglyphs, "Egyp")
+DEF(Elbasan, "Elba")
+DEF(Elymaic, "Elym")
+DEF(Ethiopic, "Ethi")
+DEF(Georgian, "Geor")
+DEF(Glagolitic, "Glag")
+DEF(Gothic, "Goth")
+DEF(Garay, "Gara")
+DEF(Grantha, "Gran")
+DEF(Greek, "Grek")
+DEF(Gujarati, "Gujr")
+DEF(Gunjala_Gondi, "Gong")
+DEF(Gurmukhi, "Guru")
+DEF(Gurung_Khema, "Gukh")
+DEF(Han, "Hani")
+DEF(Hangul, "Hang")
+DEF(Hanifi_Rohingya, "Rohg")
+DEF(Hanunoo, "Hano")
+DEF(Hatran, "Hatr")
+DEF(Hebrew, "Hebr")
+DEF(Hiragana, "Hira")
+DEF(Imperial_Aramaic, "Armi")
+DEF(Inherited, "Zinh,Qaai")
+DEF(Inscriptional_Pahlavi, "Phli")
+DEF(Inscriptional_Parthian, "Prti")
+DEF(Javanese, "Java")
+DEF(Kaithi, "Kthi")
+DEF(Kannada, "Knda")
+DEF(Katakana, "Kana")
+DEF(Katakana_Or_Hiragana, "Hrkt")
+DEF(Kawi, "Kawi")
+DEF(Kayah_Li, "Kali")
+DEF(Kharoshthi, "Khar")
+DEF(Khmer, "Khmr")
+DEF(Khojki, "Khoj")
+DEF(Khitan_Small_Script, "Kits")
+DEF(Khudawadi, "Sind")
+DEF(Kirat_Rai, "Krai")
+DEF(Lao, "Laoo")
+DEF(Latin, "Latn")
+DEF(Lepcha, "Lepc")
+DEF(Limbu, "Limb")
+DEF(Linear_A, "Lina")
+DEF(Linear_B, "Linb")
+DEF(Lisu, "Lisu")
+DEF(Lycian, "Lyci")
+DEF(Lydian, "Lydi")
+DEF(Makasar, "Maka")
+DEF(Mahajani, "Mahj")
+DEF(Malayalam, "Mlym")
+DEF(Mandaic, "Mand")
+DEF(Manichaean, "Mani")
+DEF(Marchen, "Marc")
+DEF(Masaram_Gondi, "Gonm")
+DEF(Medefaidrin, "Medf")
+DEF(Meetei_Mayek, "Mtei")
+DEF(Mende_Kikakui, "Mend")
+DEF(Meroitic_Cursive, "Merc")
+DEF(Meroitic_Hieroglyphs, "Mero")
+DEF(Miao, "Plrd")
+DEF(Modi, "Modi")
+DEF(Mongolian, "Mong")
+DEF(Mro, "Mroo")
+DEF(Multani, "Mult")
+DEF(Myanmar, "Mymr")
+DEF(Nabataean, "Nbat")
+DEF(Nag_Mundari, "Nagm")
+DEF(Nandinagari, "Nand")
+DEF(New_Tai_Lue, "Talu")
+DEF(Newa, "Newa")
+DEF(Nko, "Nkoo")
+DEF(Nushu, "Nshu")
+DEF(Nyiakeng_Puachue_Hmong, "Hmnp")
+DEF(Ogham, "Ogam")
+DEF(Ol_Chiki, "Olck")
+DEF(Ol_Onal, "Onao")
+DEF(Old_Hungarian, "Hung")
+DEF(Old_Italic, "Ital")
+DEF(Old_North_Arabian, "Narb")
+DEF(Old_Permic, "Perm")
+DEF(Old_Persian, "Xpeo")
+DEF(Old_Sogdian, "Sogo")
+DEF(Old_South_Arabian, "Sarb")
+DEF(Old_Turkic, "Orkh")
+DEF(Old_Uyghur, "Ougr")
+DEF(Oriya, "Orya")
+DEF(Osage, "Osge")
+DEF(Osmanya, "Osma")
+DEF(Pahawh_Hmong, "Hmng")
+DEF(Palmyrene, "Palm")
+DEF(Pau_Cin_Hau, "Pauc")
+DEF(Phags_Pa, "Phag")
+DEF(Phoenician, "Phnx")
+DEF(Psalter_Pahlavi, "Phlp")
+DEF(Rejang, "Rjng")
+DEF(Runic, "Runr")
+DEF(Samaritan, "Samr")
+DEF(Saurashtra, "Saur")
+DEF(Sharada, "Shrd")
+DEF(Shavian, "Shaw")
+DEF(Siddham, "Sidd")
+DEF(Sidetic, "Sidt")
+DEF(SignWriting, "Sgnw")
+DEF(Sinhala, "Sinh")
+DEF(Sogdian, "Sogd")
+DEF(Sora_Sompeng, "Sora")
+DEF(Soyombo, "Soyo")
+DEF(Sundanese, "Sund")
+DEF(Sunuwar, "Sunu")
+DEF(Syloti_Nagri, "Sylo")
+DEF(Syriac, "Syrc")
+DEF(Tagalog, "Tglg")
+DEF(Tagbanwa, "Tagb")
+DEF(Tai_Le, "Tale")
+DEF(Tai_Tham, "Lana")
+DEF(Tai_Viet, "Tavt")
+DEF(Tai_Yo, "Tayo")
+DEF(Takri, "Takr")
+DEF(Tamil, "Taml")
+DEF(Tangut, "Tang")
+DEF(Telugu, "Telu")
+DEF(Thaana, "Thaa")
+DEF(Thai, "Thai")
+DEF(Tibetan, "Tibt")
+DEF(Tifinagh, "Tfng")
+DEF(Tirhuta, "Tirh")
+DEF(Tangsa, "Tnsa")
+DEF(Todhri, "Todr")
+DEF(Tolong_Siki, "Tols")
+DEF(Toto, "Toto")
+DEF(Tulu_Tigalari, "Tutg")
+DEF(Ugaritic, "Ugar")
+DEF(Vai, "Vaii")
+DEF(Vithkuqi, "Vith")
+DEF(Wancho, "Wcho")
+DEF(Warang_Citi, "Wara")
+DEF(Yezidi, "Yezi")
+DEF(Yi, "Yiii")
+DEF(Zanabazar_Square, "Zanb")
+#endif
+
+#ifdef UNICODE_PROP_LIST
+/* Prop list not exported to regexp */
+DEF(Hyphen, "")
+DEF(Other_Math, "")
+DEF(Other_Alphabetic, "")
+DEF(Other_Lowercase, "")
+DEF(Other_Uppercase, "")
+DEF(Other_Grapheme_Extend, "")
+DEF(Other_Default_Ignorable_Code_Point, "")
+DEF(Other_ID_Start, "")
+DEF(Other_ID_Continue, "")
+DEF(Prepended_Concatenation_Mark, "")
+/* additional computed properties for smaller tables */
+DEF(ID_Continue1, "")
+DEF(XID_Start1, "")
+DEF(XID_Continue1, "")
+DEF(Changes_When_Titlecased1, "")
+DEF(Changes_When_Casefolded1, "")
+DEF(Changes_When_NFKC_Casefolded1, "")
+
+/* Prop list exported to JS */
+DEF(ASCII_Hex_Digit, "AHex")
+DEF(Bidi_Control, "Bidi_C")
+DEF(Dash, "")
+DEF(Deprecated, "Dep")
+DEF(Diacritic, "Dia")
+DEF(Extender, "Ext")
+DEF(Hex_Digit, "Hex")
+DEF(IDS_Unary_Operator, "IDSU")
+DEF(IDS_Binary_Operator, "IDSB")
+DEF(IDS_Trinary_Operator, "IDST")
+DEF(Ideographic, "Ideo")
+DEF(Join_Control, "Join_C")
+DEF(Logical_Order_Exception, "LOE")
+DEF(Modifier_Combining_Mark, "MCM")
+DEF(Noncharacter_Code_Point, "NChar")
+DEF(Pattern_Syntax, "Pat_Syn")
+DEF(Pattern_White_Space, "Pat_WS")
+DEF(Quotation_Mark, "QMark")
+DEF(Radical, "")
+DEF(Regional_Indicator, "RI")
+DEF(Sentence_Terminal, "STerm")
+DEF(Soft_Dotted, "SD")
+DEF(Terminal_Punctuation, "Term")
+DEF(Unified_Ideograph, "UIdeo")
+DEF(Variation_Selector, "VS")
+DEF(White_Space, "space")
+DEF(Bidi_Mirrored, "Bidi_M")
+DEF(Emoji, "")
+DEF(Emoji_Component, "EComp")
+DEF(Emoji_Modifier, "EMod")
+DEF(Emoji_Modifier_Base, "EBase")
+DEF(Emoji_Presentation, "EPres")
+DEF(Extended_Pictographic, "ExtPict")
+DEF(Default_Ignorable_Code_Point, "DI")
+DEF(ID_Start, "IDS")
+DEF(Case_Ignorable, "CI")
+
+/* other binary properties */
+DEF(ASCII,"")
+DEF(Alphabetic, "Alpha")
+DEF(Any, "")
+DEF(Assigned,"")
+DEF(Cased, "")
+DEF(Changes_When_Casefolded, "CWCF")
+DEF(Changes_When_Casemapped, "CWCM")
+DEF(Changes_When_Lowercased, "CWL")
+DEF(Changes_When_NFKC_Casefolded, "CWKCF")
+DEF(Changes_When_Titlecased, "CWT")
+DEF(Changes_When_Uppercased, "CWU")
+DEF(Grapheme_Base, "Gr_Base")
+DEF(Grapheme_Extend, "Gr_Ext")
+DEF(ID_Continue, "IDC")
+DEF(ID_Compat_Math_Start, "")
+DEF(ID_Compat_Math_Continue, "")
+DEF(Lowercase, "Lower")
+DEF(Math, "")
+DEF(Uppercase, "Upper")
+DEF(XID_Continue, "XIDC")
+DEF(XID_Start, "XIDS")
+
+/* internal tables with index */
+DEF(Cased1, "")
+
+/* unused by us */
+DEF(InCB, "")
+
+#endif

package/index.js

@@ -0,0 +1,13 @@
+import {dirname, join} from 'node:path'
+import {fileURLToPath} from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+/** Path to quickjs.cmake shared module */
+export const cmakePath = join(__dirname, 'quickjs.cmake')
+
+/** Path to QuickJS include directory */
+export const includePath = join(__dirname, 'deps', 'quickjs')
+
+/** Path to the qjsc bytecode compiler binary */
+export const qjscPath = join(__dirname, 'bin', process.platform === 'win32' ? 'qjsc.exe' : 'qjsc')

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@mikrojs/quickjs",
+  "version": "0.0.7",
+  "description": "QuickJS-NG engine source, shared CMake module, and qjsc bytecode compiler",
+  "keywords": [
+    "bytecode",
+    "compiler",
+    "mikrojs",
+    "quickjs"
+  ],
+  "homepage": "https://github.com/mikrojs/mikrojs#readme",
+  "bugs": {
+    "url": "https://github.com/mikrojs/mikrojs/issues"
+  },
+  "license": "MIT",
+  "author": "Bjørge Næss <bjoerge@gmail.com>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mikrojs/mikrojs.git"
+  },
+  "files": [
+    "deps/quickjs/*.c",
+    "deps/quickjs/*.h",
+    "deps/quickjs/LICENSE",
+    "index.js",
+    "postinstall.js",
+    "quickjs.cmake"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./index.js",
+    "./package.json": "./package.json"
+  },
+  "engines": {
+    "node": ">=24.0.0"
+  },
+  "scripts": {
+    "postinstall": "node postinstall.js"
+  }
+}

package/postinstall.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+/**
+ * Build the qjsc bytecode compiler from QuickJS source at install time.
+ * Produces bin/qjsc in the package directory.
+ *
+ * Uses cc directly (no cmake dependency) since qjsc is just a few C files.
+ * Skips gracefully if cc or the submodule is not available.
+ */
+import {execFileSync} from 'node:child_process'
+import {existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync} from 'node:fs'
+import {dirname, join} from 'node:path'
+import {fileURLToPath} from 'node:url'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+const binDir = join(__dirname, 'bin')
+const qjsDir = join(__dirname, 'deps', 'quickjs')
+const patchesDir = join(__dirname, 'patches')
+const repoRoot = join(__dirname, '..', '..', '..')
+
+// Always sync submodule to the pinned commit
+try {
+  execFileSync('git', ['submodule', 'update', '--init', 'packages/@mikrojs/quickjs/deps/quickjs'], {
+    cwd: repoRoot,
+    stdio: 'inherit',
+  })
+} catch {
+  if (!existsSync(join(qjsDir, 'quickjs.c'))) {
+    console.error(
+      '@mikrojs/quickjs: Failed to initialize QuickJS submodule.\n' +
+        'Run manually: git submodule update --init packages/@mikrojs/quickjs/deps/quickjs',
+    )
+    process.exit(1)
+  }
+}
+
+// Apply mikrojs-local patches to the submodule tree. Patches live in
+// packages/@mikrojs/quickjs/patches/*.patch and are kept minimal.
+// Applied idempotently: if `git apply --reverse --check` succeeds, the
+// patch is already present, skip it.
+applyPatches()
+
+function applyPatches() {
+  if (!existsSync(patchesDir)) return
+  const files = readdirSync(patchesDir)
+    .filter((f) => f.endsWith('.patch'))
+    .sort()
+  for (const f of files) {
+    const patch = join(patchesDir, f)
+    // Probe: is the patch already applied?
+    try {
+      execFileSync('git', ['apply', '--reverse', '--check', patch], {
+        cwd: qjsDir,
+        stdio: 'pipe',
+      })
+      continue // already applied
+    } catch {
+      // not applied — fall through
+    }
+    try {
+      execFileSync('git', ['apply', patch], {cwd: qjsDir, stdio: 'inherit'})
+      console.log(`@mikrojs/quickjs: applied patch ${f}`)
+    } catch (err) {
+      console.error(`@mikrojs/quickjs: failed to apply ${f}`, err.message)
+      process.exit(1)
+    }
+  }
+}
+
+// Determine the current submodule commit to detect changes
+let currentCommit = ''
+try {
+  currentCommit = execFileSync('git', ['-C', qjsDir, 'rev-parse', 'HEAD'], {
+    encoding: 'utf8',
+  }).trim()
+} catch {
+  // Not a git repo (e.g. published package), skip commit tracking
+}
+
+// On Windows the C compiler appends .exe automatically.
+const exeSuffix = process.platform === 'win32' ? '.exe' : ''
+const qjscPath = join(binDir, `qjsc${exeSuffix}`)
+
+// Skip rebuild if qjsc exists and source hasn't changed
+const stampFile = join(binDir, '.commit')
+if (existsSync(qjscPath)) {
+  if (!currentCommit) {
+    // No git info (npm install): qjsc exists, sources are static, skip rebuild
+    process.exit(0)
+  }
+  const builtCommit = existsSync(stampFile) ? readFileSync(stampFile, 'utf8').trim() : ''
+  if (builtCommit === currentCommit) {
+    process.exit(0)
+  }
+}
+
+// Skip if cc is not available
+try {
+  execFileSync('cc', ['--version'], {stdio: 'ignore'})
+} catch {
+  console.log('@mikrojs/quickjs: C compiler not found, skipping qjsc build')
+  process.exit(0)
+}
+
+mkdirSync(binDir, {recursive: true})
+
+const output = qjscPath
+const sources = [
+  'quickjs.c',
+  'dtoa.c',
+  'libunicode.c',
+  'libregexp.c',
+  'quickjs-libc.c',
+  'qjsc.c',
+].map((f) => join(qjsDir, f))
+
+console.log('@mikrojs/quickjs: Building qjsc...')
+execFileSync('cc', ['-O2', '-D_GNU_SOURCE', '-I', qjsDir, '-o', output, ...sources, '-lm'], {
+  stdio: 'inherit',
+})
+
+if (currentCommit) {
+  writeFileSync(stampFile, currentCommit)
+}
+console.log('@mikrojs/quickjs: qjsc built successfully')

package/quickjs.cmake

@@ -0,0 +1,83 @@
+# quickjs.cmake — shared CMake module for QuickJS-NG
+#
+# Provides:
+#   Target mode (normal CMake):
+#     - `quickjs` static library target
+#   Variable mode (ESP-IDF / source inclusion):
+#     - QUICKJS_SOURCES       — list of source files
+#     - QUICKJS_INCLUDE_DIR   — include directory
+#     - QUICKJS_COMPILE_OPTIONS — compiler flags for QuickJS sources
+#   Both modes:
+#     - QJSC_EXECUTABLE       — path to the qjsc bytecode compiler
+#
+# Usage in normal CMake:
+#   include(<path>/quickjs.cmake)
+#   target_link_libraries(mylib PUBLIC quickjs)
+#
+# Usage in ESP-IDF component:
+#   include(<path>/quickjs.cmake)
+#   idf_component_register(SRCS ${QUICKJS_SOURCES} ...)
+#   target_include_directories(${COMPONENT_LIB} SYSTEM PUBLIC ${QUICKJS_INCLUDE_DIR})
+
+# Include guard — safe for multiple includes
+if(TARGET quickjs)
+    return()
+endif()
+
+# Resolve paths relative to this file
+get_filename_component(_QUICKJS_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" DIRECTORY)
+set(QUICKJS_INCLUDE_DIR "${_QUICKJS_CMAKE_DIR}/deps/quickjs")
+
+# Source files
+set(QUICKJS_SOURCES
+    "${QUICKJS_INCLUDE_DIR}/quickjs.c"
+    "${QUICKJS_INCLUDE_DIR}/dtoa.c"
+    "${QUICKJS_INCLUDE_DIR}/libunicode.c"
+    "${QUICKJS_INCLUDE_DIR}/libregexp.c"
+)
+
+# Compiler flags for QuickJS sources.
+#
+# -fno-strict-aliasing defends against latent aliasing UB in the QuickJS
+# sources miscompiling on 32-bit embedded targets. One real instance of
+# this bit us: a `(int *)&uint32_t_var` cast in js_string_iterator_next
+# was silently optimized away when uint32_t was typedef'd as
+# `unsigned long` (as it is on riscv32-esp-elf), producing a String
+# Iterator that never advanced. With strict aliasing off, GCC can't
+# assume the pointer write through a differently-typed pointer misses
+# the storage, so it reloads from memory and the code behaves as
+# intended. Small codegen cost, predictable correctness — worth it for
+# third-party code we don't audit exhaustively.
+# MSVC understands neither GCC-style -W flags nor -fno-strict-aliasing; its
+# default codegen also doesn't strict-alias (no /Oa equivalent in cl), so
+# leaving the options empty for MSVC is the right call.
+if(MSVC)
+    set(QUICKJS_COMPILE_OPTIONS "")
+else()
+    set(QUICKJS_COMPILE_OPTIONS -Wno-implicit-fallthrough -Wno-sign-compare -fno-strict-aliasing)
+endif()
+
+# qjsc executable path (built by postinstall)
+if(WIN32)
+    set(QJSC_EXECUTABLE "${_QUICKJS_CMAKE_DIR}/bin/qjsc.exe")
+else()
+    set(QJSC_EXECUTABLE "${_QUICKJS_CMAKE_DIR}/bin/qjsc")
+endif()
+
+# ── Target mode: create a static library ────────────────────────────
+# Only create the target if not in ESP-IDF component context
+# (ESP-IDF uses idf_component_register with SRCS instead)
+if(NOT ESP_PLATFORM)
+    add_library(quickjs STATIC ${QUICKJS_SOURCES})
+    set_target_properties(quickjs PROPERTIES POSITION_INDEPENDENT_CODE ON)
+    target_include_directories(quickjs SYSTEM PUBLIC "${QUICKJS_INCLUDE_DIR}")
+    target_compile_options(quickjs PRIVATE ${QUICKJS_COMPILE_OPTIONS})
+
+    # cutils.h has inline functions with C-style void* implicit conversions that are
+    # errors in C++. -fpermissive (GCC) downgrades them to warnings, then SYSTEM suppresses.
+    # Clang doesn't need this since QuickJS headers are SYSTEM includes; MSVC doesn't
+    # ship the flag and is silent on these anyway.
+    if(CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+        target_compile_options(quickjs INTERFACE $<$<COMPILE_LANGUAGE:CXX>:-fpermissive>)
+    endif()
+endif()