@nlabs/lex 1.51.3 → 1.51.5

package/lib/utils/postcss/postcss-for.js

@@ -69,7 +69,7 @@ const postcssFor = (opts = {})=>{
         };
     };
     const checkParams = (rule, params)=>{
-        if (!params[0]?.match(/(^|[^\w])\$([\w\d-_]+)/) || params[1] !== 'from' || params[3] !== 'to' || params[5] !== 'by' && params[5] !== undefined) {
+        if (!params[0]?.startsWith('$') || params[1] !== 'from' || params[3] !== 'to' || params[5] && params[5] !== 'by') {
             throw rule.error('Wrong loop syntax', {
                 plugin: 'postcss-for'
             });
@@ -92,9 +92,17 @@ const postcssFor = (opts = {})=>{
         for(let i = index; i * dir <= top * dir; i = i + by){
             const content = rule.clone();
             value[iterator] = i;
-            postcssSimpleVars({
+            const simpleVarsPlugin = postcssSimpleVars({
                 only: value
-            })(content);
+            });
+            if (simpleVarsPlugin.prepare) {
+                const prepared = simpleVarsPlugin.prepare({});
+                if (prepared.Once) {
+                    prepared.Once(content, {});
+                }
+            } else if (typeof simpleVarsPlugin === 'function') {
+                simpleVarsPlugin(content);
+            }
             if (options.nested) {
                 processLoops(content);
             }
@@ -133,4 +141,4 @@ const postcssFor = (opts = {})=>{
 postcssFor.postcss = true;
 export default postcssFor;
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/utils/postcss/postcss-for.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n *\n * PostCSS 8-compatible version of postcss-for plugin\n * Original: https://github.com/antyakushev/postcss-for\n */\nimport postcss from 'postcss';\nimport postcssSimpleVars from 'postcss-simple-vars';\n\ninterface PostcssForOptions {\n  nested?: boolean;\n}\n\nconst postcssFor = (opts: PostcssForOptions = {}) => {\n  const options = {\n    nested: opts.nested !== false\n  };\n\n  const iterStack: string[] = [];\n\n  const parentsHaveIterator = (rule: postcss.AtRule, param: string): boolean => {\n    if (rule.parent == null) {\n      return false;\n    }\n    if (rule.parent.type === 'root') {\n      return false;\n    }\n    if (rule.parent.type !== 'atrule' || !rule.parent.params) {\n      return false;\n    }\n\n    const parentIterVar = rule.parent.params.split(/\\s+/)[0];\n    if (!parentIterVar) {\n      return false;\n    }\n    if (parentIterVar === param) {\n      return true;\n    }\n    if (iterStack.indexOf(param) !== -1) {\n      return true;\n    }\n    return parentsHaveIterator(rule.parent as postcss.AtRule, param);\n  };\n\n  const manageIterStack = (rule: postcss.AtRule) => {\n    if (rule.parent && rule.parent.type !== 'root') {\n      const parentIterVar = rule.parent.type === 'atrule' && rule.parent.params\n        ? rule.parent.params.split(/\\s+/)[0]\n        : null;\n      if (parentIterVar && iterStack.indexOf(parentIterVar) === -1) {\n        iterStack.splice(0, iterStack.length);\n      } else if (parentIterVar) {\n        const parentIndex = iterStack.indexOf(parentIterVar);\n        if (parentIndex !== -1) {\n          iterStack.splice(parentIndex + 1, iterStack.length - parentIndex - 1);\n        }\n      }\n    } else {\n      iterStack.splice(0, iterStack.length);\n    }\n    const currentIterVar = rule.params.split(/\\s+/)[0];\n    if (currentIterVar) {\n      iterStack.push(currentIterVar);\n    }\n  };\n\n  const checkNumber = (rule: postcss.AtRule) => {\n    return (param: string) => {\n      if (isNaN(parseInt(param, 10)) || !param.match(/^-?\\d+\\.?\\d*$/)) {\n        if (param.indexOf('$') !== -1) {\n          if (!parentsHaveIterator(rule, param)) {\n            throw rule.error('External variable (not from a parent for loop) cannot be used as a range parameter', {\n              plugin: 'postcss-for'\n            });\n          }\n        } else {\n          throw rule.error('Range parameter should be a number', {\n            plugin: 'postcss-for'\n          });\n        }\n      }\n    };\n  };\n\n  const checkParams = (rule: postcss.AtRule, params: string[]) => {\n    if (\n      !params[0]?.match(/(^|[^\\w])\\$([\\w\\d-_]+)/) ||\n      params[1] !== 'from' ||\n      params[3] !== 'to' ||\n      (params[5] !== 'by' && params[5] !== undefined)\n    ) {\n      throw rule.error('Wrong loop syntax', {\n        plugin: 'postcss-for'\n      });\n    }\n\n    [params[2], params[4], params[6] || '0'].forEach(checkNumber(rule));\n  };\n\n  const unrollLoop = (rule: postcss.AtRule) => {\n    const params = rule.params.split(/\\s+/);\n\n    checkParams(rule, params);\n\n    const iterator = params[0].slice(1);\n    const index = +params[2];\n    const top = +params[4];\n    const dir = top < index ? -1 : 1;\n    const by = (+(params[6] || 1)) * dir;\n\n    const value: Record<string, number> = {};\n    for (let i = index; i * dir <= top * dir; i = i + by) {\n      const content = rule.clone();\n      value[iterator] = i;\n      postcssSimpleVars({only: value})(content);\n      if (options.nested) {\n        processLoops(content);\n      }\n      if (rule.parent) {\n        rule.parent.insertBefore(rule, content.nodes);\n      }\n    }\n    if (rule.parent) {\n      rule.remove();\n    }\n  };\n\n  const processLoops = (css: postcss.Container) => {\n    css.walkAtRules((rule) => {\n      if (rule.name === 'for') {\n        unrollLoop(rule);\n      }\n    });\n  };\n\n  const processOriginalLoops = (css: postcss.Root) => {\n    css.walkAtRules((rule) => {\n      if (rule.name === 'for') {\n        if (rule.parent) {\n          manageIterStack(rule);\n        }\n        unrollLoop(rule);\n      }\n    });\n  };\n\n  return {\n    postcssPlugin: 'postcss-for',\n    Once(root) {\n      processOriginalLoops(root);\n    }\n  };\n};\n\npostcssFor.postcss = true;\n\nexport default postcssFor;\n\n"],"names":["postcssSimpleVars","postcssFor","opts","options","nested","iterStack","parentsHaveIterator","rule","param","parent","type","params","parentIterVar","split","indexOf","manageIterStack","splice","length","parentIndex","currentIterVar","push","checkNumber","isNaN","parseInt","match","error","plugin","checkParams","undefined","forEach","unrollLoop","iterator","slice","index","top","dir","by","value","i","content","clone","only","processLoops","insertBefore","nodes","remove","css","walkAtRules","name","processOriginalLoops","postcssPlugin","Once","root","postcss"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/utils/postcss/postcss-for.ts"],"sourcesContent":["/**\n * Copyright (c) 2025-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n *\n * PostCSS 8-compatible version of postcss-for plugin\n * Original: https://github.com/antyakushev/postcss-for\n */\nimport postcss from 'postcss';\nimport postcssSimpleVars from 'postcss-simple-vars';\n\ninterface PostcssForOptions {\n  nested?: boolean;\n}\n\nconst postcssFor = (opts: PostcssForOptions = {}) => {\n  const options = {\n    nested: opts.nested !== false\n  };\n\n  const iterStack: string[] = [];\n\n  const parentsHaveIterator = (rule: postcss.AtRule, param: string): boolean => {\n    if (rule.parent == null) {\n      return false;\n    }\n    if (rule.parent.type === 'root') {\n      return false;\n    }\n    if (rule.parent.type !== 'atrule' || !rule.parent.params) {\n      return false;\n    }\n\n    const parentIterVar = rule.parent.params.split(/\\s+/)[0];\n    if (!parentIterVar) {\n      return false;\n    }\n    if (parentIterVar === param) {\n      return true;\n    }\n    if (iterStack.indexOf(param) !== -1) {\n      return true;\n    }\n    return parentsHaveIterator(rule.parent as postcss.AtRule, param);\n  };\n\n  const manageIterStack = (rule: postcss.AtRule) => {\n    if (rule.parent && rule.parent.type !== 'root') {\n      const parentIterVar = rule.parent.type === 'atrule' && rule.parent.params\n        ? rule.parent.params.split(/\\s+/)[0]\n        : null;\n      if (parentIterVar && iterStack.indexOf(parentIterVar) === -1) {\n        iterStack.splice(0, iterStack.length);\n      } else if (parentIterVar) {\n        const parentIndex = iterStack.indexOf(parentIterVar);\n        if (parentIndex !== -1) {\n          iterStack.splice(parentIndex + 1, iterStack.length - parentIndex - 1);\n        }\n      }\n    } else {\n      iterStack.splice(0, iterStack.length);\n    }\n    const currentIterVar = rule.params.split(/\\s+/)[0];\n    if (currentIterVar) {\n      iterStack.push(currentIterVar);\n    }\n  };\n\n  const checkNumber = (rule: postcss.AtRule) => {\n    return (param: string) => {\n      if (isNaN(parseInt(param, 10)) || !param.match(/^-?\\d+\\.?\\d*$/)) {\n        if (param.indexOf('$') !== -1) {\n          if (!parentsHaveIterator(rule, param)) {\n            throw rule.error('External variable (not from a parent for loop) cannot be used as a range parameter', {\n              plugin: 'postcss-for'\n            });\n          }\n        } else {\n          throw rule.error('Range parameter should be a number', {\n            plugin: 'postcss-for'\n          });\n        }\n      }\n    };\n  };\n\n  const checkParams = (rule: postcss.AtRule, params: string[]) => {\n    if (\n      !params[0]?.startsWith('$') ||\n      params[1] !== 'from' ||\n      params[3] !== 'to' ||\n      (params[5] && params[5] !== 'by')\n    ) {\n      throw rule.error('Wrong loop syntax', {\n        plugin: 'postcss-for'\n      });\n    }\n\n    [params[2], params[4], params[6] || '0'].forEach(checkNumber(rule));\n  };\n\n  const unrollLoop = (rule: postcss.AtRule) => {\n    const params = rule.params.split(/\\s+/);\n\n    checkParams(rule, params);\n\n    const iterator = params[0].slice(1);\n    const index = +params[2];\n    const top = +params[4];\n    const dir = top < index ? -1 : 1;\n    const by = (+(params[6] || 1)) * dir;\n\n    const value: Record<string, number> = {};\n    for (let i = index; i * dir <= top * dir; i = i + by) {\n      const content = rule.clone();\n      value[iterator] = i;\n      const simpleVarsPlugin = postcssSimpleVars({only: value});\n      if (simpleVarsPlugin.prepare) {\n        const prepared = simpleVarsPlugin.prepare({} as any);\n        if (prepared.Once) {\n          prepared.Once(content, {} as any);\n        }\n      } else if (typeof simpleVarsPlugin === 'function') {\n        simpleVarsPlugin(content);\n      }\n      if (options.nested) {\n        processLoops(content);\n      }\n      if (rule.parent) {\n        rule.parent.insertBefore(rule, content.nodes);\n      }\n    }\n    if (rule.parent) {\n      rule.remove();\n    }\n  };\n\n  const processLoops = (css: postcss.Container) => {\n    css.walkAtRules((rule) => {\n      if (rule.name === 'for') {\n        unrollLoop(rule);\n      }\n    });\n  };\n\n  const processOriginalLoops = (css: postcss.Root) => {\n    css.walkAtRules((rule) => {\n      if (rule.name === 'for') {\n        if (rule.parent) {\n          manageIterStack(rule);\n        }\n        unrollLoop(rule);\n      }\n    });\n  };\n\n  return {\n    postcssPlugin: 'postcss-for',\n    Once(root) {\n      processOriginalLoops(root);\n    }\n  };\n};\n\npostcssFor.postcss = true;\n\nexport default postcssFor;\n\n"],"names":["postcssSimpleVars","postcssFor","opts","options","nested","iterStack","parentsHaveIterator","rule","param","parent","type","params","parentIterVar","split","indexOf","manageIterStack","splice","length","parentIndex","currentIterVar","push","checkNumber","isNaN","parseInt","match","error","plugin","checkParams","startsWith","forEach","unrollLoop","iterator","slice","index","top","dir","by","value","i","content","clone","simpleVarsPlugin","only","prepare","prepared","Once","processLoops","insertBefore","nodes","remove","css","walkAtRules","name","processOriginalLoops","postcssPlugin","root","postcss"],"mappings":"AAAA;;;;;;CAMC,GAED,OAAOA,uBAAuB,sBAAsB;AAMpD,MAAMC,aAAa,CAACC,OAA0B,CAAC,CAAC;IAC9C,MAAMC,UAAU;QACdC,QAAQF,KAAKE,MAAM,KAAK;IAC1B;IAEA,MAAMC,YAAsB,EAAE;IAE9B,MAAMC,sBAAsB,CAACC,MAAsBC;QACjD,IAAID,KAAKE,MAAM,IAAI,MAAM;YACvB,OAAO;QACT;QACA,IAAIF,KAAKE,MAAM,CAACC,IAAI,KAAK,QAAQ;YAC/B,OAAO;QACT;QACA,IAAIH,KAAKE,MAAM,CAACC,IAAI,KAAK,YAAY,CAACH,KAAKE,MAAM,CAACE,MAAM,EAAE;YACxD,OAAO;QACT;QAEA,MAAMC,gBAAgBL,KAAKE,MAAM,CAACE,MAAM,CAACE,KAAK,CAAC,MAAM,CAAC,EAAE;QACxD,IAAI,CAACD,eAAe;YAClB,OAAO;QACT;QACA,IAAIA,kBAAkBJ,OAAO;YAC3B,OAAO;QACT;QACA,IAAIH,UAAUS,OAAO,CAACN,WAAW,CAAC,GAAG;YACnC,OAAO;QACT;QACA,OAAOF,oBAAoBC,KAAKE,MAAM,EAAoBD;IAC5D;IAEA,MAAMO,kBAAkB,CAACR;QACvB,IAAIA,KAAKE,MAAM,IAAIF,KAAKE,MAAM,CAACC,IAAI,KAAK,QAAQ;YAC9C,MAAME,gBAAgBL,KAAKE,MAAM,CAACC,IAAI,KAAK,YAAYH,KAAKE,MAAM,CAACE,MAAM,GACrEJ,KAAKE,MAAM,CAACE,MAAM,CAACE,KAAK,CAAC,MAAM,CAAC,EAAE,GAClC;YACJ,IAAID,iBAAiBP,UAAUS,OAAO,CAACF,mBAAmB,CAAC,GAAG;gBAC5DP,UAAUW,MAAM,CAAC,GAAGX,UAAUY,MAAM;YACtC,OAAO,IAAIL,eAAe;gBACxB,MAAMM,cAAcb,UAAUS,OAAO,CAACF;gBACtC,IAAIM,gBAAgB,CAAC,GAAG;oBACtBb,UAAUW,MAAM,CAACE,cAAc,GAAGb,UAAUY,MAAM,GAAGC,cAAc;gBACrE;YACF;QACF,OAAO;YACLb,UAAUW,MAAM,CAAC,GAAGX,UAAUY,MAAM;QACtC;QACA,MAAME,iBAAiBZ,KAAKI,MAAM,CAACE,KAAK,CAAC,MAAM,CAAC,EAAE;QAClD,IAAIM,gBAAgB;YAClBd,UAAUe,IAAI,CAACD;QACjB;IACF;IAEA,MAAME,cAAc,CAACd;QACnB,OAAO,CAACC;YACN,IAAIc,MAAMC,SAASf,OAAO,QAAQ,CAACA,MAAMgB,KAAK,CAAC,kBAAkB;gBAC/D,IAAIhB,MAAMM,OAAO,CAAC,SAAS,CAAC,GAAG;oBAC7B,IAAI,CAACR,oBAAoBC,MAAMC,QAAQ;wBACrC,MAAMD,KAAKkB,KAAK,CAAC,sFAAsF;4BACrGC,QAAQ;wBACV;oBACF;gBACF,OAAO;oBACL,MAAMnB,KAAKkB,KAAK,CAAC,sCAAsC;wBACrDC,QAAQ;oBACV;gBACF;YACF;QACF;IACF;IAEA,MAAMC,cAAc,CAACpB,MAAsBI;QACzC,IACE,CAACA,MAAM,CAAC,EAAE,EAAEiB,WAAW,QACvBjB,MAAM,CAAC,EAAE,KAAK,UACdA,MAAM,CAAC,EAAE,KAAK,QACbA,MAAM,CAAC,EAAE,IAAIA,MAAM,CAAC,EAAE,KAAK,MAC5B;YACA,MAAMJ,KAAKkB,KAAK,CAAC,qBAAqB;gBACpCC,QAAQ;YACV;QACF;QAEA;YAACf,MAAM,CAAC,EAAE;YAAEA,MAAM,CAAC,EAAE;YAAEA,MAAM,CAAC,EAAE,IAAI;SAAI,CAACkB,OAAO,CAACR,YAAYd;IAC/D;IAEA,MAAMuB,aAAa,CAACvB;QAClB,MAAMI,SAASJ,KAAKI,MAAM,CAACE,KAAK,CAAC;QAEjCc,YAAYpB,MAAMI;QAElB,MAAMoB,WAAWpB,MAAM,CAAC,EAAE,CAACqB,KAAK,CAAC;QACjC,MAAMC,QAAQ,CAACtB,MAAM,CAAC,EAAE;QACxB,MAAMuB,MAAM,CAACvB,MAAM,CAAC,EAAE;QACtB,MAAMwB,MAAMD,MAAMD,QAAQ,CAAC,IAAI;QAC/B,MAAMG,KAAK,AAAC,CAAEzB,CAAAA,MAAM,CAAC,EAAE,IAAI,CAAA,IAAMwB;QAEjC,MAAME,QAAgC,CAAC;QACvC,IAAK,IAAIC,IAAIL,OAAOK,IAAIH,OAAOD,MAAMC,KAAKG,IAAIA,IAAIF,GAAI;YACpD,MAAMG,UAAUhC,KAAKiC,KAAK;YAC1BH,KAAK,CAACN,SAAS,GAAGO;YAClB,MAAMG,mBAAmBzC,kBAAkB;gBAAC0C,MAAML;YAAK;YACvD,IAAII,iBAAiBE,OAAO,EAAE;gBAC5B,MAAMC,WAAWH,iBAAiBE,OAAO,CAAC,CAAC;gBAC3C,IAAIC,SAASC,IAAI,EAAE;oBACjBD,SAASC,IAAI,CAACN,SAAS,CAAC;gBAC1B;YACF,OAAO,IAAI,OAAOE,qBAAqB,YAAY;gBACjDA,iBAAiBF;YACnB;YACA,IAAIpC,QAAQC,MAAM,EAAE;gBAClB0C,aAAaP;YACf;YACA,IAAIhC,KAAKE,MAAM,EAAE;gBACfF,KAAKE,MAAM,CAACsC,YAAY,CAACxC,MAAMgC,QAAQS,KAAK;YAC9C;QACF;QACA,IAAIzC,KAAKE,MAAM,EAAE;YACfF,KAAK0C,MAAM;QACb;IACF;IAEA,MAAMH,eAAe,CAACI;QACpBA,IAAIC,WAAW,CAAC,CAAC5C;YACf,IAAIA,KAAK6C,IAAI,KAAK,OAAO;gBACvBtB,WAAWvB;YACb;QACF;IACF;IAEA,MAAM8C,uBAAuB,CAACH;QAC5BA,IAAIC,WAAW,CAAC,CAAC5C;YACf,IAAIA,KAAK6C,IAAI,KAAK,OAAO;gBACvB,IAAI7C,KAAKE,MAAM,EAAE;oBACfM,gBAAgBR;gBAClB;gBACAuB,WAAWvB;YACb;QACF;IACF;IAEA,OAAO;QACL+C,eAAe;QACfT,MAAKU,IAAI;YACPF,qBAAqBE;QACvB;IACF;AACF;AAEAtD,WAAWuD,OAAO,GAAG;AAErB,eAAevD,WAAW"}

package/lib/utils/postcss/postcss-percentage.js

@@ -4,8 +4,10 @@
  *
  * PostCSS 8-compatible version of postcss-percentage plugin
  * Original: https://github.com/antyakushev/postcss-percentage
- */ import parser from 'postcss-value-parser';
-// eslint-disable-next-line @typescript-eslint/no-require-imports
+ */ import { fileURLToPath } from 'url';
+import { createRequire } from 'module';
+import parser from 'postcss-value-parser';
+const require = createRequire(fileURLToPath(import.meta.url));
 const evaluator = require('math-expression-evaluator');
 const transformPercentage = (value, precision, floor, trimTrailingZero)=>{
     return parser(value).walk((node)=>{
@@ -62,4 +64,4 @@ const postcssPercentage = (opts = {})=>{
 postcssPercentage.postcss = true;
 export default postcssPercentage;
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nlabs/lex",
-  "version": "1.51.3",
+  "version": "1.51.5",
   "description": "Lex",
   "license": "MIT",
   "type": "module",
@@ -68,6 +68,7 @@
     "test:commands": "NODE_ENV=test && npm run test:cli && npm run test:integration",
     "test:coverage": "NODE_ENV=test && npx jest --coverage --coverageDirectory=coverage --coverageReporters=text --coverageReporters=lcov --coverageReporters=html",
     "test:coverage:upload": "codecov",
+    "test:webpack": "node scripts/test-webpack.js",
     "type-check": "tsc --noEmit --project tsconfig.lint.json",
     "type-check:build": "tsc --noEmit --project tsconfig.build.json",
     "type-check:test": "tsc --noEmit --project tsconfig.test.json",

package/scripts/test-webpack.js

@@ -0,0 +1,363 @@
+#!/usr/bin/env node
+/**
+ * Test script to verify webpack, PostCSS plugins, and static file serving
+ *
+ * Usage:
+ *   node scripts/test-webpack.js
+ *
+ * This script:
+ * 1. Creates a temporary test project
+ * 2. Builds it with webpack
+ * 3. Verifies PostCSS plugins work
+ * 4. Checks that static files are accessible
+ */
+
+import {execSync, spawn} from 'child_process';
+import {existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync} from 'fs';
+import {createConnection} from 'net';
+import {join} from 'path';
+import {tmpdir} from 'os';
+
+const testDir = join(tmpdir(), `lex-webpack-test-${Date.now()}`);
+
+console.log('🧪 Creating test project...');
+mkdirSync(testDir, {recursive: true});
+mkdirSync(join(testDir, 'src'), {recursive: true});
+mkdirSync(join(testDir, 'src', 'images'), {recursive: true});
+mkdirSync(join(testDir, 'src', 'static'), {recursive: true});
+
+writeFileSync(join(testDir, 'package.json'), JSON.stringify({
+  name: 'test-webpack-project',
+  version: '1.0.0',
+  type: 'module'
+}, null, 2));
+
+writeFileSync(join(testDir, 'src', 'index.html'), `<!DOCTYPE html>
+<html>
+<head>
+  <title>Test App</title>
+  <link rel="stylesheet" href="./styles.css">
+</head>
+<body>
+  <div class="container">
+    <h1>Test App</h1>
+    <div class="test-for-loop">PostCSS @for loop test</div>
+    <div class="test-percentage">PostCSS percentage() test</div>
+  </div>
+  <script src="./index.js"></script>
+</body>
+</html>`);
+
+writeFileSync(join(testDir, 'src', 'index.js'), `
+  console.log('Hello from test project');
+  import './styles.css';
+`);
+
+writeFileSync(join(testDir, 'src', 'styles.css'), `
+  /* Test PostCSS @for loop */
+  @for $i from 1 to 4 {
+    .test-for-loop:nth-child($i) {
+      width: calc($i * 25px);
+    }
+  }
+
+  /* Test PostCSS percentage() function */
+  .test-percentage {
+    width: percentage(1/3);
+    padding: percentage(0.05);
+  }
+
+  .container {
+    max-width: 1200px;
+    margin: 0 auto;
+  }
+`);
+
+writeFileSync(join(testDir, 'src', 'images', 'test.png'), 'fake-png-content');
+writeFileSync(join(testDir, 'src', 'images', 'logo-icon-64.png'), 'fake-png-content');
+writeFileSync(join(testDir, 'src', 'static', 'test.txt'), 'Static file content');
+writeFileSync(join(testDir, 'src', 'favicon.ico'), 'fake-ico-content');
+writeFileSync(join(testDir, 'src', 'manifest.json'), JSON.stringify({name: 'Test App'}, null, 2));
+
+writeFileSync(join(testDir, 'lex.config.js'), `
+export default {
+  entryJs: 'index.js',
+  entryHTML: 'index.html',
+  outputPath: './build',
+  sourcePath: './src',
+  webpack: {
+    staticPath: './src/static'
+  }
+};
+`);
+
+console.log('📦 Building with webpack...');
+try {
+  const lexPath = join(process.cwd(), 'lib', 'lex.js');
+  try {
+    const result = execSync(`node "${lexPath}" build --bundler webpack --outputPath ./build --sourcePath ./src`, {
+      cwd: testDir,
+      stdio: 'pipe',
+      encoding: 'utf8',
+      env: {
+        ...process.env,
+        NODE_ENV: 'production'
+      }
+    });
+    console.log(result.toString());
+  } catch (error) {
+    console.error('Build error output:', error.stdout || error.stderr || error.message);
+    throw error;
+  }
+
+  console.log('✅ Build completed successfully!\n');
+
+  const buildDir = join(testDir, 'build');
+
+  console.log('🔍 Verifying build output...');
+
+  const indexHtml = join(buildDir, 'index.html');
+  if (existsSync(indexHtml)) {
+    const htmlContent = readFileSync(indexHtml, 'utf8');
+    if (htmlContent.includes('Test App')) {
+      console.log('✅ HTML file generated correctly');
+    } else {
+      console.log('❌ HTML content incorrect');
+    }
+  } else {
+    console.log('❌ HTML file not found');
+  }
+
+  const cssFiles = ['index.css'];
+  const jsFiles = ['index.js', 'index.*.js'];
+  let cssFound = false;
+  let cssProcessed = false;
+
+  for (const cssFile of cssFiles) {
+    const cssPath = join(buildDir, cssFile);
+    if (existsSync(cssPath)) {
+      cssFound = true;
+      const cssContent = readFileSync(cssPath, 'utf8');
+      console.log('✅ CSS file generated');
+
+      if (cssContent.includes('test-for-loop')) {
+        const hasForLoop = /width:\s*calc\([^)]*25px\)/.test(cssContent);
+        if (hasForLoop) {
+          console.log('✅ PostCSS @for loop processed correctly');
+          cssProcessed = true;
+        }
+      }
+
+      if (cssContent.includes('test-percentage')) {
+        const hasPercentage = /width:\s*[\d.]+%/.test(cssContent);
+        if (hasPercentage) {
+          console.log('✅ PostCSS percentage() function processed correctly');
+          cssProcessed = true;
+        }
+      }
+      break;
+    }
+  }
+
+  if (!cssFound) {
+    const files = readdirSync(buildDir);
+    const jsFile = files.find(f => f.startsWith('index.') && f.endsWith('.js') && !f.includes('runtime') && !f.includes('vendors'));
+    if (jsFile) {
+      const jsContent = readFileSync(join(buildDir, jsFile), 'utf8');
+      if (jsContent.includes('calc') && jsContent.includes('25px')) {
+        console.log('✅ CSS processed and inlined in JS (PostCSS @for loop detected)');
+        cssProcessed = true;
+      }
+      if (jsContent.includes('%') && /[\d.]+%/.test(jsContent)) {
+        console.log('✅ CSS processed and inlined in JS (PostCSS percentage() detected)');
+        cssProcessed = true;
+      }
+    }
+    if (!cssProcessed) {
+      console.log('⚠️  CSS file not found (may be inlined or named differently)');
+    }
+  }
+
+  const staticFile = join(buildDir, 'test.txt');
+  if (existsSync(staticFile)) {
+    const staticContent = readFileSync(staticFile, 'utf8');
+    if (staticContent === 'Static file content') {
+      console.log('✅ Static file copied correctly');
+    } else {
+      console.log('❌ Static file content incorrect');
+    }
+  } else {
+    console.log('⚠️  Static file not found (may not be copied in this configuration)');
+  }
+
+  console.log('\n🌐 Testing dev server and static file access...');
+
+  const testPort = 3001;
+
+  if (!existsSync(buildDir)) {
+    console.log('⚠️  Build directory does not exist, creating it...');
+    mkdirSync(buildDir, {recursive: true});
+  }
+
+  let devServerProcess = null;
+  let serverReady = false;
+  let serverError = null;
+
+  try {
+    devServerProcess = spawn('node', [lexPath, 'dev', '--port', testPort.toString(), '--quiet'], {
+      cwd: testDir,
+      stdio: 'pipe',
+      env: {
+        ...process.env,
+        LEX_QUIET: 'true',
+        NODE_ENV: 'development'
+      }
+    });
+
+    let serverOutput = '';
+    devServerProcess.stdout.on('data', (data) => {
+      const output = data.toString();
+      serverOutput += output;
+    });
+
+    devServerProcess.stderr.on('data', (data) => {
+      const output = data.toString();
+      serverOutput += output;
+      if (output.includes('error') || output.includes('Error') || output.includes('ERROR')) {
+        serverError = output;
+      }
+    });
+
+    devServerProcess.on('error', (error) => {
+      serverError = error.message;
+    });
+
+    console.log(`⏳ Waiting for dev server to start on port ${testPort}...`);
+    console.log('   (This may take 30-60 seconds for initial compilation)');
+
+    const checkPort = (port) => {
+      return new Promise((resolve) => {
+        const socket = createConnection(port, 'localhost');
+        socket.on('connect', () => {
+          socket.destroy();
+          resolve(true);
+        });
+        socket.on('error', () => {
+          resolve(false);
+        });
+        socket.setTimeout(1000, () => {
+          socket.destroy();
+          resolve(false);
+        });
+      });
+    };
+
+    const waitForServer = async () => {
+      for (let i = 0; i < 60; i++) {
+        await new Promise(resolve => setTimeout(resolve, 1000));
+
+        const portOpen = await checkPort(testPort);
+        if (portOpen) {
+          await new Promise(resolve => setTimeout(resolve, 5000));
+          const testEndpoints = ['/test.txt', '/index.html', '/'];
+          for (const endpoint of testEndpoints) {
+            try {
+              const controller = new AbortController();
+              const timeoutId = setTimeout(() => controller.abort(), 5000);
+              const response = await fetch(`http://localhost:${testPort}${endpoint}`, {
+                signal: controller.signal
+              });
+              clearTimeout(timeoutId);
+              if (response.ok || response.status === 200) {
+                return true;
+              }
+            } catch (error) {
+              if (error.name !== 'AbortError') {
+              }
+            }
+          }
+        }
+
+        if (i % 10 === 9 && i > 0) {
+          console.log(`   Still waiting... (${i + 1}/60 seconds)`);
+        }
+      }
+      return false;
+    };
+
+    serverReady = await waitForServer();
+
+    if (serverError) {
+      console.log(`⚠️  Dev server error: ${serverError}`);
+      console.log('⚠️  Skipping HTTP tests due to server error');
+      console.log('💡 Note: Static files are copied to build directory and should be accessible via dev server');
+    } else if (!serverReady) {
+      console.log('⚠️  Dev server did not start within 60 seconds, skipping HTTP tests');
+      console.log('💡 Note: Static files are copied to build directory and should be accessible via dev server');
+      console.log('💡 To test manually, run: cd <test-dir> && lex dev --port 3001');
+      if (serverOutput) {
+        const lastOutput = serverOutput.slice(-1000);
+        console.log('\nServer output (last 1000 chars):');
+        console.log(lastOutput);
+      } else {
+        console.log('   (No server output captured - server may not have started)');
+      }
+    } else {
+      console.log(`✅ Dev server started on port ${testPort}`);
+
+      const testUrls = [
+        {url: '/test.txt', expectedContent: 'Static file content', description: 'Static file from staticPath'},
+        {url: '/index.html', expectedContent: 'Test App', description: 'HTML file'},
+        {url: '/images/test.png', expectedContent: 'fake-png-content', description: 'Image file'}
+      ];
+
+      for (const test of testUrls) {
+        try {
+          const response = await fetch(`http://localhost:${testPort}${test.url}`);
+          if (response.ok) {
+            const content = await response.text();
+            if (content.includes(test.expectedContent)) {
+              console.log(`✅ ${test.description} accessible via HTTP (${test.url})`);
+            } else {
+              console.log(`⚠️  ${test.description} accessible but content doesn't match (${test.url})`);
+            }
+          } else {
+            console.log(`❌ ${test.description} returned status ${response.status} (${test.url})`);
+          }
+        } catch (error) {
+          console.log(`❌ Failed to fetch ${test.description}: ${error.message}`);
+        }
+      }
+    }
+
+  } catch (error) {
+    console.log(`⚠️  Dev server test skipped: ${error.message}`);
+  } finally {
+    if (devServerProcess) {
+      console.log('🛑 Stopping dev server...');
+      devServerProcess.kill('SIGTERM');
+      await new Promise(resolve => setTimeout(resolve, 1000));
+      if (devServerProcess.killed === false) {
+        devServerProcess.kill('SIGKILL');
+      }
+      console.log('✅ Dev server stopped');
+    }
+  }
+
+  console.log('\n🎉 All tests passed!');
+  console.log(`\n📁 Test project location: ${testDir}`);
+  console.log('💡 You can inspect the build output in the build/ directory');
+
+} catch (error) {
+  console.error('❌ Build failed:', error.message);
+  process.exit(1);
+} finally {
+  console.log('\n🧹 Cleaning up...');
+  try {
+    rmSync(testDir, {recursive: true, force: true});
+    console.log('✅ Cleanup complete');
+  } catch {
+    console.log('⚠️  Could not clean up test directory:', testDir);
+  }
+}
+

package/webpack.config.js

@@ -56,7 +56,7 @@ const {
 
 const webpackStaticPath = webpackCustom?.staticPath || './src/static';
 
-const { publicPath: _, ...webpackConfigFiltered } = webpackCustom || {};
+const { publicPath: _, staticPath: __, ...webpackConfigFiltered } = webpackCustom || {};
 
 const plugins = [
   new ProgressPlugin({
@@ -731,5 +731,24 @@ export default (webpackEnv, webpackOptions) => {
     }
   }
 
-  return merge(webpackConfig, webpackConfigFiltered);
+  const mergedConfig = merge(webpackConfig, webpackConfigFiltered);
+
+  // Filter out PostCSS plugin objects from webpack plugins array
+  // PostCSS plugins have 'postcssPlugin' property and should only be in postcssOptions
+  if (Array.isArray(mergedConfig.plugins)) {
+    mergedConfig.plugins = mergedConfig.plugins.filter((plugin) => {
+      // Keep webpack plugins (have 'apply' method or are instances with constructor)
+      if (typeof plugin === 'function' || (plugin && typeof plugin.apply === 'function')) {
+        return true;
+      }
+      // Filter out PostCSS plugin objects (have 'postcssPlugin' property)
+      if (plugin && typeof plugin === 'object' && 'postcssPlugin' in plugin) {
+        return false;
+      }
+      // Keep other valid webpack plugins
+      return true;
+    });
+  }
+
+  return mergedConfig;
 };