npm - devabhasha - Versions diffs - 1.0.0 - Mend

devabhasha 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (22) hide show

package/src/server-node.js ADDED Viewed

@@ -0,0 +1,120 @@
+// server-node.js — the सेवक HTTP-server host primitive (Node backend).
+//
+// Mirrors io-node.js: a live `__SRV` object for `devabhasha run`, and an
+// inlined `SRV_NODE_SOURCE` string for `devabhasha build` (self-contained).
+//
+// सेवक(handler, port) starts an http.createServer. The handler receives a
+// request and a response object, both keyed in Devanagari (member access emits
+// raw Devanagari, so the runtime object must expose those exact keys):
+//
+//   अनुरोधः (request):  मार्गः (url/path), रीतिः (method), शीर्षाणि (headers),
+//                       प्रश्नाः (query params object), देहम्() → Promise<body text>,
+//                       देहम्_जेसन() → Promise<Result<parsed JSON>>
+//   प्रत्युत्तरम् (response): स्थिति(code), शीर्षम्(k,v), लेखय(text), प्रेषय_जेसन(value)
+//
+// The handler may be async (return a Promise); errors are caught and become 500.
+import { createServer } from 'http';
+// Build the Devanagari-keyed request wrapper around a Node IncomingMessage.
+function makeRequest(req) {
+  const url = new URL(req.url, 'http://localhost');
+  const query = {};
+  for (const [k, v] of url.searchParams) query[k] = v;
+  let bodyText = null;
+  const readBody = () => new Promise((resolve) => {
+    if (bodyText != null) return resolve(bodyText);
+    let data = '';
+    req.on('data', (c) => { data += c; });
+    req.on('end', () => { bodyText = data; resolve(data); });
+    req.on('error', () => resolve(''));
+  });
+  return {
+    'मार्गः': decodeURIComponent(url.pathname),
+    'रीतिः': req.method,
+    'शीर्षाणि': req.headers,
+    'प्रश्नाः': query,
+    async 'देहम्'() { return readBody(); },
+    async 'देहम्_जेसन'() {
+      const t = await readBody();
+      try { return { 'सफल': true, 'मूल्यम्': JSON.parse(t), 'दोषः': null }; }
+      catch (e) { return { 'सफल': false, 'मूल्यम्': null, 'दोषः': 'JSON: ' + (e && e.message || e) }; }
+    },
+  };
+}
+// Build the Devanagari-keyed response wrapper around a Node ServerResponse.
+function makeResponse(res) {
+  const api = {
+    'स्थिति'(code) { res.statusCode = code; return api; },          // set status, chainable
+    'शीर्षम्'(k, v) { res.setHeader(k, v); return api; },            // set header, chainable
+    'लेखय'(text) {                                                  // send text and end
+      if (!res.hasHeader('Content-Type')) res.setHeader('Content-Type', 'text/html; charset=utf-8');
+      res.end(text == null ? '' : String(text));
+      return api;
+    },
+    'प्रेषय_जेसन'(value) {                                          // send JSON and end
+      res.setHeader('Content-Type', 'application/json; charset=utf-8');
+      res.end(JSON.stringify(value));
+      return api;
+    },
+  };
+  return api;
+}
+export const __SRV = {
+  serve(handler, port) {
+    const server = createServer(async (req, res) => {
+      try {
+        await handler(makeRequest(req), makeResponse(res));
+        if (!res.writableEnded) res.end();            // handler forgot to respond
+      } catch (e) {
+        if (!res.headersSent) res.statusCode = 500;
+        if (!res.writableEnded) res.end('सर्वर-दोषः (500): ' + (e && e.message || e));
+      }
+    });
+    server.listen(port || 3000);
+    return server;
+  },
+};
+export const SRV_NODE_SOURCE = `// --- देवभाषा HTTP server (Node backend) ---
+const __SRV = (() => {
+  const { createServer } = require('http');
+  function makeRequest(req) {
+    const url = new URL(req.url, 'http://localhost');
+    const query = {}; for (const [k, v] of url.searchParams) query[k] = v;
+    let bodyText = null;
+    const readBody = () => new Promise((resolve) => {
+      if (bodyText != null) return resolve(bodyText);
+      let data = ''; req.on('data', c => { data += c; });
+      req.on('end', () => { bodyText = data; resolve(data); });
+      req.on('error', () => resolve(''));
+    });
+    return {
+      "मार्गः": decodeURIComponent(url.pathname), "रीतिः": req.method, "शीर्षाणि": req.headers, "प्रश्नाः": query,
+      async "देहम्"() { return readBody(); },
+      async "देहम्_जेसन"() { const t = await readBody(); try { return { "सफल": true, "मूल्यम्": JSON.parse(t), "दोषः": null }; } catch (e) { return { "सफल": false, "मूल्यम्": null, "दोषः": 'JSON: ' + (e && e.message || e) }; } },
+    };
+  }
+  function makeResponse(res) {
+    const api = {
+      "स्थिति"(code){ res.statusCode = code; return api; },
+      "शीर्षम्"(k, v){ res.setHeader(k, v); return api; },
+      "लेखय"(text){ if (!res.hasHeader('Content-Type')) res.setHeader('Content-Type','text/html; charset=utf-8'); res.end(text == null ? '' : String(text)); return api; },
+      "प्रेषय_जेसन"(value){ res.setHeader('Content-Type','application/json; charset=utf-8'); res.end(JSON.stringify(value)); return api; },
+    };
+    return api;
+  }
+  return {
+    serve(handler, port) {
+      const server = createServer(async (req, res) => {
+        try { await handler(makeRequest(req), makeResponse(res)); if (!res.writableEnded) res.end(); }
+        catch (e) { if (!res.headersSent) res.statusCode = 500; if (!res.writableEnded) res.end('सर्वर-दोषः (500): ' + (e && e.message || e)); }
+      });
+      server.listen(port || 3000);
+      return server;
+    },
+  };
+})();
+`;

package/src/server.js ADDED Viewed

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+// server.js — a Language Server (LSP) for Devabhāṣā, over stdio.
+//
+// Speaks the Language Server Protocol: Content-Length framed JSON-RPC on
+// stdin/stdout. Supports:
+//   • textDocument/publishDiagnostics  — compile errors as you type
+//   • textDocument/completion          — keywords, stdlib, style vocab, tags
+//   • textDocument/hover               — what a Sanskrit word means
+//
+// Editor-agnostic: any LSP client (VS Code, Neovim, etc.) can connect by
+// running `node src/server.js`. The analysis itself lives in analyzer.js;
+// this file is purely the protocol.
+import { diagnostics, completions, hover, wordAt, definition, renameOccurrences } from './analyzer.js';
+// ---- LSP completion-item kinds (subset) ----
+const CIK = { keyword: 14, method: 2, property: 10, constant: 21, function: 3,
+              field: 5, value: 12, tag: 7, event: 23 };
+// open documents: uri → text
+const docs = new Map();
+// ---- JSON-RPC / LSP framing ----
+let buffer = Buffer.alloc(0);
+process.stdin.on('data', chunk => {
+  buffer = Buffer.concat([buffer, chunk]);
+  for (;;) {
+    const headerEnd = buffer.indexOf('\r\n\r\n');
+    if (headerEnd === -1) return;
+    const header = buffer.slice(0, headerEnd).toString('utf8');
+    const m = /Content-Length:\s*(\d+)/i.exec(header);
+    if (!m) { buffer = buffer.slice(headerEnd + 4); continue; }
+    const len = parseInt(m[1], 10);
+    const start = headerEnd + 4;
+    if (buffer.length < start + len) return; // wait for more
+    const body = buffer.slice(start, start + len).toString('utf8');
+    buffer = buffer.slice(start + len);
+    try { handle(JSON.parse(body)); } catch (e) { /* ignore malformed */ }
+  }
+});
+function send(msg) {
+  const json = JSON.stringify(msg);
+  const buf = Buffer.from(json, 'utf8');
+  process.stdout.write(`Content-Length: ${buf.length}\r\n\r\n`);
+  process.stdout.write(buf);
+}
+function reply(id, result) { send({ jsonrpc: '2.0', id, result }); }
+function notify(method, params) { send({ jsonrpc: '2.0', method, params }); }
+// ---- diagnostics: compute + publish for a document ----
+function publishDiagnostics(uri) {
+  const text = docs.get(uri) || '';
+  const diags = diagnostics(text).map(d => ({
+    range: {
+      start: { line: d.line - 1, character: d.col - 1 },
+      end:   { line: d.line - 1, character: (d.endCol || d.col + 1) - 1 },
+    },
+    severity: d.severity || 1,
+    source: 'devabhasha',
+    message: d.message,
+  }));
+  notify('textDocument/publishDiagnostics', { uri, diagnostics: diags });
+}
+// ---- get the word at an LSP position ----
+function wordAtPosition(uri, position) {
+  const text = docs.get(uri) || '';
+  const lines = text.split('\n');
+  const lineText = lines[position.line] || '';
+  return wordAt(lineText, position.character);
+}
+// ---- request/notification dispatch ----
+function handle(msg) {
+  const { id, method, params } = msg;
+  switch (method) {
+    case 'initialize':
+      reply(id, {
+        capabilities: {
+          textDocumentSync: 1,                 // full document sync
+          completionProvider: { triggerCharacters: [] },
+          hoverProvider: true,
+          definitionProvider: true,
+          renameProvider: true,
+        },
+        serverInfo: { name: 'devabhasha-language-server', version: '1.0.0' },
+      });
+      break;
+    case 'initialized':
+      break;
+    case 'textDocument/didOpen': {
+      const { uri, text } = params.textDocument;
+      docs.set(uri, text);
+      publishDiagnostics(uri);
+      break;
+    }
+    case 'textDocument/didChange': {
+      const uri = params.textDocument.uri;
+      // full sync: last change holds the whole document
+      const text = params.contentChanges[params.contentChanges.length - 1].text;
+      docs.set(uri, text);
+      publishDiagnostics(uri);
+      break;
+    }
+    case 'textDocument/didClose':
+      docs.delete(params.textDocument.uri);
+      notify('textDocument/publishDiagnostics', { uri: params.textDocument.uri, diagnostics: [] });
+      break;
+    case 'textDocument/completion': {
+      const { word, start } = wordAtPosition(params.textDocument.uri, params.position);
+      // complete on the prefix up to the cursor
+      const cursorInWord = Math.max(0, params.position.character - start);
+      const prefix = word.slice(0, cursorInWord);
+      const items = completions(prefix).map(it => ({
+        label: it.label,
+        kind: CIK[it.kind] || 1,
+        detail: it.detail,
+        documentation: it.doc,
+      }));
+      reply(id, { isIncomplete: false, items });
+      break;
+    }
+    case 'textDocument/hover': {
+      const { word } = wordAtPosition(params.textDocument.uri, params.position);
+      const h = hover(word);
+      if (!h) { reply(id, null); break; }
+      reply(id, {
+        contents: { kind: 'markdown', value: `**${h.label}** — ${h.detail}\n\n${h.doc}` },
+      });
+      break;
+    }
+    case 'textDocument/definition': {
+      const uri = params.textDocument.uri;
+      const text = docs.get(uri) || '';
+      // LSP positions are 0-based; the symbol table is 1-based
+      const def = definition(text, params.position.line + 1, params.position.character + 1);
+      if (!def) { reply(id, null); break; }
+      reply(id, {
+        uri,
+        range: {
+          start: { line: def.line - 1, character: def.col - 1 },
+          end:   { line: def.line - 1, character: def.col - 1 + def.name.length },
+        },
+      });
+      break;
+    }
+    case 'textDocument/rename': {
+      const uri = params.textDocument.uri;
+      const text = docs.get(uri) || '';
+      const newName = params.newName;
+      const occ = renameOccurrences(text, params.position.line + 1, params.position.character + 1);
+      if (!occ.length) { reply(id, null); break; }
+      const edits = occ.map(o => ({
+        range: {
+          start: { line: o.line - 1, character: o.col - 1 },
+          end:   { line: o.line - 1, character: o.col - 1 + o.name.length },
+        },
+        newText: newName,
+      }));
+      reply(id, { changes: { [uri]: edits } });
+      break;
+    }
+    case 'shutdown':
+      reply(id, null);
+      break;
+    case 'exit':
+      process.exit(0);
+      break;
+    default:
+      // unknown request → null result so clients don't hang
+      if (id !== undefined) reply(id, null);
+  }
+}

package/src/stdlib.js ADDED Viewed

@@ -0,0 +1,137 @@
+// stdlib.js — the Sanskrit standard library surface.
+//
+// Maps Sanskrit method/property names to JavaScript operations on
+// strings, arrays, and objects. These are the primitives a self-hosting
+// compiler needs: index, slice, length, concat, push, field access.
+//
+// codegen consults these tables when emitting Member / Call nodes so that
+// `पद.दीर्घता` → `pada.length`, `सूची.योजय(x)` → `arr.push(x)`, etc.
+// Property accessors (no call): noun → JS property
+export const PROPERTIES = {
+  'दीर्घता':  'length',     // dīrghatā — "length"
+  'मानानि':  'values',     // (used as a marker; handled specially if needed)
+};
+// Methods (called): Sanskrit name → JS method name.
+// Works uniformly on strings and arrays where JS allows.
+export const METHODS = {
+  // --- string & array shared ---
+  'खण्ड':     'slice',       // khaṇḍa — "segment" → slice(start, end)
+  'अनुक्रमणिका':'indexOf',    // anukramaṇikā — "index" → indexOf(x)
+  'अस्ति':    'includes',    // asti — "exists" → includes(x)
+  'संयोजय':   'concat',      // saṃyojaya — "join together" → concat
+  // --- string specific ---
+  'अक्षरः':   'charAt',      // akṣaraḥ — "letter" → charAt(i)
+  'सङ्केतः':  'charCodeAt',  // saṅketaḥ — "code" → charCodeAt(i)
+  'विभज':     'split',       // vibhaja — "divide" → split(sep)
+  'उच्च':     'toUpperCase', // ucca — "high" → toUpperCase
+  'नीच':      'toLowerCase', // nīca — "low" → toLowerCase
+  'छिन्द्धि':  'trim',        // chinddhi — "cut" → trim
+  'आरभते':    'startsWith',  // ārabhate — "begins" → startsWith
+  'समाप्यते':  'endsWith',    // samāpyate — "ends" → endsWith
+  // --- array specific ---
+  'योजय':     'push',        // yojaya — "join/attach" → push(x)
+  'अपनय':     'pop',         // apanaya — "remove" → pop
+  'प्रतिचित्रय':'map',         // praticitraya — "map across" → map(fn)
+  'गालय':     'filter',      // gālaya — "filter" → filter(fn)
+  'प्रत्येकस्मिन्':'forEach',  // pratyekasmin — "in each" → forEach(fn)
+  'सम्मील':   'join',        // sammīla — "unite" → join(sep)  (array→string)
+  'विपर्यय':   'reverse',     // viparyaya — "reverse" → reverse
+  // --- promise (आश्वासन) methods for async chaining ---
+  'ततः':      'then',         // tataḥ — "thereupon" → .then(fn)
+  'दोषे':      'catch',        // doṣe — "on error" → .catch(fn)
+  'अन्ततः':    'finally',      // antataḥ — "finally" → .finally(fn)
+  // --- I/O methods (on सञ्चिका / जाल namespaces) ---
+  'पठ':       'read',         // paṭha — "read" → file.read(path)
+  'लिख':      'write',        // likha — "write" → file.write(path, data)
+  'विद्यते':   'exists',       // vidyate — "exists" → file.exists(path)
+  'निष्कासय':  'remove',       // niṣkāsaya — "remove" → file.remove(path)
+  'सूचीकृ':    'list',         // sūcīkṛ — "enumerate" → file.list(dir)
+  'आनय':      'fetch',        // ānaya — "bring/fetch" → net.fetch(url)
+  'पठप्रदत्त':  'readJson',     // paṭha-pradatta — read + parse JSON → Result
+  'लिखप्रदत्त': 'writeJson',    // likha-pradatta — serialize + write JSON
+  'आनयप्रदत्त': 'fetchJson',    // ānaya-pradatta — fetch + parse JSON → Result
+  // --- Object statics (on the सङ्ग्रह namespace) ---
+  'कुञ्जयः':    'keys',         // kuñjayaḥ — "keys" → Object.keys(o)
+  'मूल्यानि':   'values',       // mūlyāni — "values" → Object.values(o)
+  'प्रविष्टयः': 'entries',      // praviṣṭayaḥ — "entries" → Object.entries(o)
+  'समायोजय':   'assign',       // samāyojaya — "merge" → Object.assign(t, s)
+  // --- गणित (Math) methods: used as गणित.<name>(...) ---
+  // Mapped here so गणित.वर्गमूलम्(x) → Math.sqrt(x). These names are
+  // distinctive enough not to collide with user object methods.
+  'वर्गमूलम्':  'sqrt',       // vargamūlam — "square root"
+  'घनमूलम्':   'cbrt',        // ghanamūlam — "cube root"
+  'घातः':      'pow',         // ghātaḥ — "power" → pow(base, exp)
+  'निरपेक्षम्': 'abs',        // nirapekṣam — "absolute"
+  'अधःपातः':   'floor',       // adhaḥpātaḥ — "falling down" → floor
+  'ऊर्ध्वपातः': 'ceil',       // ūrdhvapātaḥ — "rising up" → ceil
+  'सन्निकर्षः': 'round',       // sannikarṣaḥ — "approximation" → round
+  'छेदनम्':    'trunc',        // chedanam — "cutting" → trunc
+  'धनर्णचिह्नम्':'sign',        // dhanarṇacihnam — "sign of a number" → Math.sign
+  'ज्या':      'sin',          // jyā — classical Sanskrit term for sine!
+  'कोटिज्या':  'cos',          // koṭijyā — classical term for cosine!
+  'स्पर्शज्या': 'tan',         // sparśajyā — "tangent"
+  'विलोमज्या': 'asin',         // vilomajyā — "inverse sine"
+  'विलोमकोटि': 'acos',         // → acos
+  'विलोमस्पर्श':'atan',         // → atan
+  'द्विकोणार्क':'atan2',        // → atan2(y, x)
+  'घातीयम्':   'exp',          // ghātīyam — "exponential" → exp
+  'लघुगणकः':   'log',          // laghugaṇakaḥ — "logarithm" → log (natural)
+  'दशलघुगणकः': 'log10',        // → log10
+  'द्विलघुगणकः':'log2',        // → log2
+  'अधिकतमः':   'max',          // adhikatamaḥ — "greatest" → max(a, b, …)
+  'न्यूनतमः':   'min',          // nyūnatamaḥ — "least" → min(a, b, …)
+  'यादृच्छिकम्':'random',       // yādṛcchikam — "random" → random()
+  'हिज्या':     'sinh',         // hijyā — hyperbolic sine
+  'कोटिहिज्या': 'cosh',         // → cosh
+  'स्पर्शहिज्या':'tanh',         // → tanh
+  'विलोमहिज्या':'asinh',        // → asinh
+  'घातमूलम्':   'hypot',        // ghātamūlam — "power-root" → hypot(a,b)
+};
+// गणित (Math) constants: accessed as गणित.पाई → Math.PI
+export const MATH_CONSTANTS = {
+  'पाई':       'PI',          // pāī → Math.PI
+  'यूलरांकः':   'E',           // yūlarāṅkaḥ — "Euler's number" → Math.E
+  'मूलद्वि':    'SQRT2',       // mūladvi — "root two" → Math.SQRT2
+  'लॉग२इ':     'LOG2E',       // → Math.LOG2E
+  'लॉग१०इ':    'LOG10E',      // → Math.LOG10E
+};
+// Global / constructor-ish helpers. Sanskrit name → emitted JS. Looked up
+// when an Identifier is emitted, so संकेताक्षर(९२) → String.fromCharCode(92).
+// NOTE: only names unlikely to be used as ordinary variables belong here —
+// common words like वस्तु ("thing") must NOT be globalized or they'd shadow
+// user variables.
+export const GLOBALS = {
+  'संकेताक्षर':  'String.fromCharCode', // saṅketākṣara — "code-letter"
+  'गणित':       'Math',                // gaṇita — "mathematics" → Math
+  'साधितम्':     '__RT.ok',             // sādhitam — "achieved" → Ok(value)
+  'विफलम्':      '__RT.err',            // viphalam — "failed" → Err(error)
+  'सञ्चिका':     '__IO.file',           // sañcikā — "file" → file I/O namespace
+  'जाल':        '__IO.net',            // jāla — "net/web" → network namespace
+  'सेवक':       '__SRV.serve',         // sevaka — "server" → start an HTTP server
+  'सङ्ग्रह':     'Object',              // saṅgraha — "collection" → Object (keys/values/entries)
+  'कालचक्र':     '__DB.interval',       // kālacakra — "wheel of time" → repeating timer
+  'कालनाशः':     '__DB.clearTimer',     // kālanāśa — "end of time" → stop a timer
+  'कुञ्जिश्रोता': '__DB.onKey',          // kuñjiśrotā — "key-listener" → keyboard handler
+  'स्वरूपम्':     '__RT.typeOf',         // svarūpam — "intrinsic form/type" → typeof (Sanskrit-named)
+  'सूचीवत्':      'Array.isArray',       // sūcīvat — "list-like" → Array.isArray
+  'प्रदत्त':      '__RT.json',           // pradatta — "data" → JSON parse/serialize (Result-returning)
+  'अङ्कय':       '__RT.toNumber',       // aṅkaya — "to number" → parse string→number (Result)
+  'प्रभाव':       '__DB.effect',         // prabhāva — "influence/effect" → fine-grained reactive effect
+  'बन्ध':        '__DB.bindText',       // bandha — "binding" → a text node bound to a reactive thunk
+  'आवली':        '__DB.keyedList',      // āvalī — "row/series" → keyed list reconciliation
+  'सफाई':        '__DB.onCleanup',      // saphāī — "cleanup" → teardown hook inside an effect
+  'आलस्यचित्रम्': '__DB.lazyImage',      // ālasya-citra — "lazy image" → load on scroll-into-view
+};
+// Object-construction keyword handled in parser: कोष (kośa, "treasury/dictionary")
+// produces an object literal:  कोष { कुञ्जी: मूल्यम्, ... }

package/src/style.js ADDED Viewed

@@ -0,0 +1,103 @@
+// style.js — रूप: the Sanskrit→CSS vocabulary.
+//
+// Translates Sanskrit style-property names → CSS properties (camelCase, for
+// the JS `style` object) and Sanskrit value words → CSS values. Built up
+// step by step; this is the isolated styling surface (cf. karaka-web.js).
+// --- property names: Sanskrit → CSS (camelCase) ---
+export const STYLE_PROPS = {
+  // color & background
+  'वर्णः':        'color',           // varṇa — "color"
+  'पृष्ठभूमिः':   'backgroundColor', // pṛṣṭhabhūmi — "background"
+  'अपारदर्शिता':  'opacity',         // apāradarśitā — "opacity"
+  // typography
+  'अक्षरमानम्':   'fontSize',        // akṣaramāna — "letter-size"
+  'अक्षरभारः':    'fontWeight',      // akṣarabhāra — "letter-weight"
+  'पङ्क्तिमानम्': 'lineHeight',      // paṅktimāna — "line-height"
+  'संरेखणम्':     'textAlign',       // saṃrekhaṇa — "alignment"
+  'अक्षरकुलम्':   'fontFamily',      // akṣarakula — "font-family"
+  'अलङ्कारः':     'textDecoration',  // alaṅkāra — "decoration"
+  // box model
+  'चौडाई':        'width',           // — width
+  'अधिकतमचौडाई':   'maxWidth',        // adhikatama-cauḍāī — "maximum width" → max-width
+  'रेखोच्चता':     'lineHeight',      // rekhocchatā — "line height" → line-height
+  'पाठसंरेखणम्':   'textAlign',       // pāṭha-saṃrekhaṇam — "text alignment" → text-align
+  'उच्चता':       'height',          // uccatā — "height"
+  'अन्तरालः':     'padding',         // antarāla — "inner gap" → padding
+  'बाह्यान्तरः':  'margin',          // bāhyāntara — "outer gap" → margin
+  'सीमा':         'border',          // sīmā — "border"
+  'कोणवृत्तिः':   'borderRadius',    // koṇavṛtti — "corner-rounding"
+  // layout
+  'प्रदर्शनम्':    'display',         // pradarśana — "display"
+  'स्थितिः':      'position',        // sthiti — "position"
+  'शीर्षात्':      'top',             // śīrṣāt — "from the top" → top
+  'अधस्तात्':      'bottom',          // adhastāt — "from below" → bottom
+  'वामतः':        'left',            // vāmataḥ — "from the left" → left
+  'दक्षिणतः':      'right',           // dakṣiṇataḥ — "from the right" → right
+  'स्तरः':        'zIndex',          // stara — "layer" → z-index
+  'दिक्':         'flexDirection',   // dik — "direction"
+  'न्यायः':       'justifyContent',  // nyāya — "arrangement" → justify
+  'मेलनम्':       'alignItems',      // melana — "alignment" → align-items
+  'अन्तरम्':      'gap',             // antara — "gap"
+};
+// --- value words: Sanskrit → CSS value ---
+export const STYLE_VALUES = {
+  // colors (named)
+  'रक्तः':    'crimson',     // rakta — "red"
+  'नीलः':     'navy',        // nīla — "blue"
+  'हरितः':    'green',       // harita — "green"
+  'पीतः':     'gold',        // pīta — "yellow/gold"
+  'श्वेतः':   'white',       // śveta — "white"
+  'कृष्णः':   'black',       // kṛṣṇa — "black"
+  'धूसरः':    'gray',        // dhūsara — "gray"
+  'केसरः':    'saffron',     // kesara — "saffron" (→ #F4C430 via palette below)
+  'अरुणः':    'tomato',      // aruṇa — "reddish"
+  'श्यामः':   'slategray',   // śyāma — "dark"
+  // display / layout keywords
+  'प्रवाहः':   'flex',        // pravāha — "flow" → flex
+  'खण्डः':     'block',       // khaṇḍa — "block"
+  'रेखा':      'inline',      // rekhā — "line" → inline
+  'अदृश्यम्':  'none',        // adṛśya — "invisible" → none
+  'केन्द्रम्':  'center',      // kendra — "center"
+  'आदिः':     'flex-start',   // ādi — "beginning"
+  'अन्तः':     'flex-end',    // anta — "end"
+  'मध्ये':     'space-between',// madhye — "in between"
+  'पङ्क्तिः':  'row',         // paṅkti — "row"
+  'स्तम्भः':   'column',      // stambha — "column"
+  // font weights / alignment
+  'गुरुः':     'bold',        // guru — "heavy" → bold
+  'लघुः':      'normal',      // laghu — "light" → normal
+  'वामम्':     'left',        // vāma — "left"
+  'दक्षिणम्':   'right',       // dakṣiṇa — "right"
+  'रेखाङ्कनम्': 'underline',   // rekhāṅkana — "underline"
+};
+// A few named colors that aren't standard CSS keywords get hex values.
+const COLOR_HEX = {
+  saffron: '#F4C430',
+};
+// Translate one property name. Unknown names pass through unchanged
+// (so raw CSS like 'cursor' still works).
+export function styleProp(name) {
+  return STYLE_PROPS[name] || name;
+}
+// Translate one value WORD. Unknown words pass through unchanged.
+export function styleValue(word) {
+  const v = STYLE_VALUES[word];
+  if (v === undefined) return word;
+  return COLOR_HEX[v] || v;
+}
+// Is this bare word a known Sanskrit style value? (If not, codegen treats
+// it as a variable reference rather than a CSS literal.)
+export function isStyleWord(word) {
+  return Object.prototype.hasOwnProperty.call(STYLE_VALUES, word);
+}