fscss 1.1.20 → 1.1.22

package/lib/functions/all.js

@@ -18,26 +18,79 @@ function procCntInit(ntc,stc){
   })
   return text;
   }
-function procNum(css){
-const regex = /num\((.*?)\)/g;
-function evaluateExpression(expression) {
-  try {
-    // function instead 
-    return new Function(`return ${expression}`)();
-  } catch (e) {
-    console.error('Invalid expression:', expression);
-    return expression;
+function parseMath(expr) {
+  const str = expr.replace(/\s+/g, '');
+  let pos = 0;
+  
+  function parseExpr() {
+    let left = parseTerm();
+    while (pos < str.length && (str[pos] === '+' || str[pos] === '-')) {
+      const op = str[pos++];
+      const right = parseTerm();
+      left = op === '+' ? left + right : left - right;
+    }
+    return left;
+  }
+  
+  function parseTerm() {
+    let left = parsePower();
+    while (pos < str.length && (str[pos] === '*' || str[pos] === '/')) {
+      const op = str[pos++];
+      const right = parsePower();
+      left = op === '*' ? left * right : left / right;
+    }
+    return left;
   }
+  
+  function parsePower() {
+    let base = parseUnary();
+    if (pos < str.length && str[pos] === '*' && str[pos + 1] === '*') {
+      pos += 2;
+      const exp = parseUnary(); // right-associative
+      return Math.pow(base, exp);
+    }
+    return base;
+  }
+  
+  function parseUnary() {
+    if (str[pos] === '-') { pos++; return -parsePrimary(); }
+    if (str[pos] === '+') { pos++; return parsePrimary(); }
+    return parsePrimary();
+  }
+  
+  function parsePrimary() {
+    if (str[pos] === '(') {
+      pos++; // skip '('
+      const val = parseExpr();
+      if (str[pos] !== ')') throw new Error('Missing closing )');
+      pos++; // skip ')'
+      return val;
+    }
+    
+    const numMatch = str.slice(pos).match(/^[0-9]*\.?[0-9]+/);
+    if (!numMatch) throw new Error(`Unexpected token at pos ${pos}: "${str[pos]}"`);
+    pos += numMatch[0].length;
+    return parseFloat(numMatch[0]);
+  }
+  
+  const result = parseExpr();
+  if (pos !== str.length) throw new Error(`Unexpected token: "${str[pos]}"`);
+  return result;
 }
 
+function procNum(css) {
+  const regex = /num\((.*?)\)/g;
 
-const processedCSS = css.replace(regex, (match, expression) => {
-  
-  return evaluateExpression(expression);
-});
+  return css.replace(regex, (match, expression) => {
+    try {
+      return parseMath(expression);
+    } catch (e) {
+      console.error('Invalid math expression:', expression);
+      return expression;
+    }
+  });
+}
 
-return (processedCSS);
-  }
 const arraysExfscss = {}; //the global variable
 const orderedxFscssRandom = {};
 
@@ -70,42 +123,37 @@ function parseConditionBlocks(block) {
   }
   return blocks;
 }
+
 function procExC(css) {
   const regex = /exec\((_log|_error|_warn|_info),\s*(?:"([^"]*)"|'([^']*)'|([^)]*))\)/g;
-  let jsCode = '';
-  let match;
-  
-  // Replace exec(...) with nothing (remove from CSS) while collecting code
+
+  const methodMap = {
+    _log:   console.log,
+    _error: console.error,
+    _warn:  console.warn,
+    _info:  console.info,
+  };
+
   const cleanedCSS = css.replace(regex, (full, method, dQ, sQ, raw) => {
-    const arg = dQ || sQ || raw;
-    
-    if (!['_log', '_error', '_warn', '_info'].includes(method)) {
+    const arg = dQ ?? sQ ?? raw;
+
+    if (!methodMap[method]) {
       console.warn(`fscss[exec(console)]: Unsupported method: ${method}`);
-      return ''; // strip it from CSS
+      return '';
     }
-    
+
     if (!arg) {
       console.warn(`fscss[exec(console)]: Empty argument for method: ${method}`);
-      return ''; // strip it from CSS
+      return '';
     }
-    
-    jsCode += `console.${method.slice(1)}("${arg.replace(/"/g, '\\"')}");\n`;
-    return ''; // ensure CSS isn’t broken
+
+    methodMap[method](arg);
+    return '';
   });
-  
-  // Run console code safely
-  if (jsCode) {
-    try {
-      new Function(jsCode)();
-    } catch (e) {
-      console.error("fscss[exec(console)]: Error executing transformed code:", e);
-    }
-  }
-  
+
   return cleanedCSS;
 }
 
-
   function procEv(css) {
   const functionMap = {};
   const funcDefRegex = /@event\s+([\w-]+)\(([^)]*)\)\s*:?{/g;
@@ -1286,124 +1334,12 @@ function applyFscssTransformations(css) {
     .replace(/\$\(([^\:^\)]*)\)/gi, '[$1]');
   return css;
 }
-async function impSel(text) {
-  const validImpExt = [".fscss", ".css", ".txt", ".scss", ".less", "xfscss"]
-  const regex = /@import\(exec\(([^)]+)\)\s*\.\s*(?:pick|find)\(([^)]+)\)\)/g;
-  const matches = [...text.matchAll(regex)];
-  
-  let result = text;
-  
-  for (const match of matches) {
-    const [fullMatch, urlSrc, part] = match;
-    try {
-      const impUrl = urlSrc.replace(/["']/g, "");
-      const impExt = impUrl.slice(impUrl.lastIndexOf(".")).toLowerCase();
-      if (impUrl.trim().startsWith("_init") && impUrl.includes(" ")) {
-        console.warn(`fscss[@import] library not found for: ${impUrl}`);
-        return;
-      }
-      
-      if (!validImpExt.includes(impExt)) {
-        console.warn(`fscss[@import] invalid extension for: ${impUrl}`);
-        return;
-      }
-      
-      const response = await fetch(impUrl);
-      if (!response.ok) throw new Error(`fscss[@import] HTTP ${response.status} for ${urlSrc}`);
-      const resText = await response.text();
-      const extracted = extractOnlyBlock(resText, part.trim());
-      result = result.replace(fullMatch, extracted);
-    } catch (err) {
-      console.error(`fscss[@import]  Failed: ${urlSrc} `, err);
-      result = result.replace(fullMatch, `/* Failed import: ${urlSrc} */`);
-      
-    }
-  }
-  
-  return result;
-}
-
-function extractOnlyBlock(cssText, blockName) {
-  const regex = new RegExp(`${blockName}\\s*{[^}]*}`, "g");
-  const match = cssText.match(regex);
-  return match ? match.join("\n") : console.warn(`fscss[@import pick] No block matches: ${blockName} `);
-}
-
-const VALID_EXTENSIONS = ['.fscss', '.css', '.txt', '.scss', '.less', '.xfscss'];
-
-async function processImports(cssText, depth = 0, baseURL = window.location.href) {
-  if (depth > exfMAX_DEPTH) {
-    console.warn('fscss[@import]\n Maximum import depth exceeded. Skipping further imports.');
-    return cssText;
-  }
-
-  const importRegex = /@import\s*\(\s*exec\s*\(\s*((?:'[^']*'|"[^"]*"|[^'")]\S*)\s*)\)\s*\)/g;
-  const matches = Array.from(cssText.matchAll(importRegex));
-
-  if (matches.length === 0) return cssText;
-
-  const fetchedContents = await Promise.all(
-    matches.map(async (match) => {
-      const [fullMatch, urlSpec] = match;
-      try {
-        const cleanUrl = urlSpec.replace(/^['"](.*)['"]$/, '$1').trim();
-        const absoluteUrl = new URL(cleanUrl, baseURL).href;
-
-        // --- New code for extension validation ---
-        const urlPath = new URL(absoluteUrl).pathname;
-        const extension = urlPath.slice(urlPath.lastIndexOf('.')).toLowerCase();
-        
- if (absoluteUrl.trim().startsWith("_init") && absoluteUrl.includes(" ")){
-        console.warn(`fscss[@import] library not found for: ${absoluteUrl}`);
-        return;
-      }
       
-        if (!VALID_EXTENSIONS.includes(extension)) {
-          console.warn(`fscss[@import] \n Invalid import URL extension "${extension}" for "${absoluteUrl}". Only ${VALID_EXTENSIONS.join(', ')} are allowed.`);
-          return `/* Invalid extension for "${absoluteUrl}" */`;
-        }
-        // --- End of new code ---
-
-        const response = await fetch(absoluteUrl);
-        if (!response.ok) throw new Error(`HTTP ${response.status} for ${absoluteUrl}`);
-
-        const importedText = await response.text();
-        return processImports(importedText, depth + 1, absoluteUrl);
-      } catch (error) {
-        console.warn(`fscss[@import]\n Failed to import "${urlSpec}" from "${baseURL}":`, error);
-        return `/* Error importing "${urlSpec}": ${error.message} */`;
-      }
-    })
-  );
-
-  let lastIndex = 0;
-  let result = '';
-  matches.forEach((match, i) => {
-    result += cssText.slice(lastIndex, match.index);
-    result += fetchedContents[i];
-    lastIndex = match.index + match[0].length;
-  });
-  result += cssText.slice(lastIndex);
-
-  return result;
-}
-
-async function procImp(css) {
-  try {
-    const processedCSS = await processImports(css);
-    return processedCSS;
-  } catch (error) {
-    console.warn('fscss[]\n Processing failed:', error);
-    console.warn(`fscss[@import] Warning: can't resolve imports`);
-    return css; 
-  }
-}
-
 function execObj(css){
   return css.replace(/exec\.obj\.block\([^\)\n]*\)\;?/g, "");
 }
 
     export { initlibraries, 
-    impSel, procImp, replaceRe, procExt, procVar,procFun, procFunObj, procArr, procEv, procRan, transformCssValues, procNum, vfc, applyFscssTransformations,procExC, procCnt, procDef, procChe, execObj
+    replaceRe, procExt, procVar,procFun, procFunObj, procArr, procEv, procRan, transformCssValues, procNum, vfc, applyFscssTransformations,procExC, procCnt, procDef, procChe, execObj
     } 
     

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "fscss",
   "description": "Figured Shorthand Cascading Style Sheet",
-  "version": "1.1.20",
+  "version": "1.1.22",
   "type": "module",
   "main": "lib/index.js",
   "bin": {
@@ -29,14 +29,14 @@
   "bugs": {
     "url": "https://github.com/Figsh/xfscss/issues"
   },
-  "homepage": "https://github.com/Figsh/xfscss#readme",
+  "homepage": "https://fscss.devtem.org",
   "dependencies": {
-    "express": "^4.18.2",
-    "dotenv": "^16.0.3"
+    "dotenv": "^16.0.3",
+    "express": "^4.18.2"
   },
   "devDependencies": {
-    "mocha": "^10.0.0",
-    "chai": "^4.3.4"
+    "chai": "^4.3.4",
+    "mocha": "^10.0.0"
   },
   "directories": {
     "lib": "lib"