mutorjs 1.3.0 → 1.3.1

package/dist/server.js

@@ -1,16 +1,1463 @@
-import{readFileSync as we}from"fs";import{copyFile as be,mkdir as Re,readdir as fe,readFile as Pe,writeFile as Se}from"fs/promises";import{extname as he,join as ee}from"path";function Z(e,r){return`${" ".repeat(e+r+1)}^`}var d=class e extends Error{constructor(t){super(t);this.name="MutorError";Object.setPrototypeOf(this,e.prototype)}},M=class e extends d{constructor(t,i,o,c,f){let m=i.toString().length+2,s=`${t}
-
-`;s+=`at ${f}:${i}:${c+1}
-`,i>1&&(s+=`${(i-1).toString().padStart(m-2)} | ...
-`),s+=`${i} | ${o}
-`,s+=Z(c,m);super(s);this.name="MutorCompilerError";Object.setPrototypeOf(this,e.prototype)}};var te=new Set(["for","if","else","true","false","null","undefined","end","in","of"]),B=new Set(["::","||","??","&&","**","^","|","&","!","-","%","+","*","/",">","<",">=","<=","==","!=",">>","<<",".","?.","(",")","[","]",",",":","?"]);var re=new Set(["==","!="]),V=new Set([">","<",">=","<="]);var ne=new Set(["+","-"]),oe=new Set(["*","/","%"]),se=new Set([".","?.","[","::"]),ie=new Set(["-","+","!"]),ae={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"},S={build:{include:new Set([".html",".txt"]),exclude:new Set(["node_modules",".git"])},autoEscape:!0,allowedProps:new Set,forbiddenProps:new Set(["__proto__","constructor","prototype"]),allowFnCalls:!1,delimiters:{closingTag:"}}",openingTag:"{{",openingTagEscape:"\\",whitespaceTrim:"~",commentTag:"#"},keepOpeningTagEscapeDelimiter:!1,cache:{active:!0,maxSize:50*1024*1024}},ce={JSON:{stringify(e){try{return JSON.stringify(e)}catch{throw new d("JSON.stringify failed: invalid value")}},parse(e){if(typeof e!="string")throw new d("JSON.parse expects a string");try{return JSON.parse(e)}catch{throw new d("JSON.parse failed: invalid JSON string")}}},Object:{keys(e){if(!e||typeof e!="object")throw new d("Object.keys expects an object");return Object.keys(e)},values(e){if(!e||typeof e!="object")throw new d("Object.values expects an object");return Object.values(e)},entries(e){if(!e||typeof e!="object")throw new d("Object.entries expects an object");return Object.entries(e)},hasOwn(e,r){if(!e||typeof e!="object")throw new d("Object.hasOwn expects an object");return Object.hasOwn(e,r)},freeze(e){if(!e||typeof e!="object")throw new d("Object.freeze expects an object");return Object.freeze(e)},seal(e){if(!e||typeof e!="object")throw new d("Object.seal expects an object");return Object.seal(e)},fromEntries(e){if(!Array.isArray(e))throw new d("Object.fromEntries expects an array");return Object.fromEntries(e)}},Array:{isArray(e){return Array.isArray(e)},from(e){return Array.from(e)}},Number:{isFinite(e){return Number.isFinite(e)},isNaN(e){return Number.isNaN(e)},parseInt(e,r=10){return Number.parseInt(e,r)},parseFloat(e){return Number.parseFloat(e)}},String:{fromCharCode(...e){return String.fromCharCode(...e)}},Math:{abs(e){return Math.abs(e)},floor(e){return Math.floor(e)},ceil(e){return Math.ceil(e)},round(e){return Math.round(e)},max(...e){return Math.max(...e)},min(...e){return Math.min(...e)},random(){return Math.random()}},Date:{now(){return Date.now()},parse(e){if(typeof e!="string")throw new d("Date.parse expects a string");return Date.parse(e)}},Boolean:{valueOf(e){return!!e}}};function F(e){return typeof e!="string"?e:/[&<>"']/.test(e)?e.replace(/[&<>"']/g,r=>ae[r]):e}import{dirname as _e,isAbsolute as ye,resolve as pe}from"path";function T(e,...r){let t=ye(e)?e:pe(process.cwd(),e);if(r.length){let i=_e(t);return pe(i,...r)}return t}function D(e,r,t){if(t.has(e)&&!r.has(e))throw new d(`Forbidden property access. Access to this computed property "${e}" is forbidden.`);return e}var L="object",le=Symbol("__mutor_safe_context");function j(e){if(!e||typeof e!==L||le in e)return e;let r=new WeakSet;function t(o,c=""){if(!o||typeof o!==L||r.has(o))return o;r.add(o);let f=Object.getPrototypeOf(o);if(f&&f!==Object.prototype&&f!==Array.prototype)throw new d(`Unsafe prototype detected at ${c||"root"}`);if(Array.isArray(o)){for(let s=0;s<o.length;s++)o[s]=t(o[s],`${c}[${s}]`);return o}if(o instanceof Map){for(let[s,p]of o.entries())typeof s===L&&t(s,`${c}.mapKey`),o.set(s,t(p,`${c}.mapValue`));return o}if(o instanceof Set){let s=new Set;for(let p of o.values())s.add(t(p,c));o.clear();for(let p of s)o.add(p);return o}let m=Object.getOwnPropertyDescriptors(o);for(let s of Object.keys(m)){let p=m[s];if(p.get||p.set)throw new d(`Getter/setter not allowed: ${c}.${s}`);let _=o[s];_&&typeof _===L&&(o[s]=t(_,`${c}.${s}`))}return o}let i=t(e);return i&&typeof i===L&&Object.defineProperty(i,le,{value:!0,enumerable:!1,writable:!1,configurable:!1}),i}function U(e){return e.replace(/\\/g,"\\\\").replace(/`/g,"\\`").replace(/\$/g,"\\$")}function W(e,r){let i=e.slice(0,r).split(`
-`).length,o=e.lastIndexOf(`
-`,r-1)+1;return{line:i,lineIndex:o}}function Y(e,r,t){let i=e.indexOf(`
-`,r);return{line:e.slice(r,i===-1?void 0:i),pos:t-r}}function z(e,r){let{scope:t,forbiddenProps:i,allowedProps:o}=r;function c(a){return t.includes(a)?a:`ctx.${a}`}function f(a){switch(a.type){case 17:return"}";case 5:return a.value;case 4:return`\`${/\$/.test(a.value)?a.value.replaceAll("$","\\$"):a.value}\``;case 10:return a.true?"true":"false";case 12:return"null";case 11:return"undefined";case 7:return c(a.value);case 9:return`(${f(a.expr)})`;case 2:return`${a.operator}${f(a.expr)}`;case 0:return`${f(a.left)} ${a.operator} ${f(a.right)}`;case 1:return`${f(a.condition)} ? ${f(a.left)} : ${f(a.right)}`;case 8:return s(a);case 3:return p(a);case 6:return m(a);case 13:return _(a);case 16:return"} else {";case 14:return y(a);case 15:return b(a);default:throw new d(`Unsupported expression type: ${a.type}`)}}function m(a){if(a.left.type!==7)throw{message:"Invalid usage of namespace operator.",pos:a.pos};return`namespaces.${a.left.value}.${a.right.value}`}function s(a){let E=f(a.left);if(a.bracketNotation){let h=f(a.right),O=a.optional?"?.":"";return a.right.type===4||a.right.type===5?`${E}${O}[${h}]`:`${E}${O}[validateComputedProps(${h}, allowedProps, forbiddenProps)]`}else{let h=a.right.value,O=a.optional?"?.":".";if(i.has(h)&&!o.has(h))throw{message:"Forbidden property access.",pos:a.right.pos};return`${E}${O}${h}`}}function p(a){let E=f(a.expr),h=a.optional?"?.":"",O=a.args.map(P=>f(P)).join(", ");return`${E}${h}(${O})`}function _(a){let{iterable:E,loopType:h,variable:O}=a;return`for(const ${O} ${h===1?"in":"of"} ${z(E,r)}){`}function y(a){let{condition:E}=a;return`if(${z(E,r)}){`}function b(a){let{condition:E}=a;return`}else if(${z(E,r)}){`}return f(e)}function G(e){switch(e){case 0:return"identifier";case 1:return"keyword";case 2:return"number";case 4:return"operator";case 3:return"string"}}function H(e,r){let t=0,i=!1;function o(n,l){let u=e[t],C=e[e.length-1];if(!u)throw{message:`Unexpected end of expression. Expected ${l?`'${l}'`:`${n===0?"an":"a"} ${G(n)}`}.`,pos:C.pos+C.value.length-1};if(u.type!==n)throw{message:`Unexpected token type. Expected ${l?`'${l}'`:G(n)} but got ${G(u.type)} instead.`,pos:u.pos};if(l!==void 0&&u.value!==l)throw{message:`Unexpected token '${u?.value}'. Expected ${n===0?"an":"a"} ${G(n)} instead.`,pos:u.pos};return e[t++]}function c(){let n=e[t-1].pos,l=o(0).value,u;try{u=o(1,"in")}catch{u=o(1,"of")}let C=u.value==="in"?1:0,v=w();return{type:13,loopType:C,iterable:v,variable:l,pos:n}}function f(){let n=w();return{condition:n,pos:n.pos,type:14}}function m(){let n=e[t-1].pos;try{return o(1,"if"),{...f(),type:15,pos:n}}catch{return{type:16,pos:n}}}function s(){let n=[];if(e[t]?.type===4&&e[t]?.value===")")return n;for(n.push(w());e[t]?.type===4&&e[t]?.value===","&&e[t]?.value!==")";)t++,n.push(w());return n}function p(){let n=e[t++];if(n?.type===2)return{type:5,value:n.value,pos:n.pos};if(n?.type===3)return{type:4,value:n.value,pos:n.pos};if(n?.type===1){if(n.value==="for"&&t===1)return c();if(n.value==="true"||n.value==="false")return{type:10,true:n.value==="true",pos:n.pos};if(n.value==="undefined")return{type:11,pos:n.pos};if(n.value==="null")return{type:12,pos:n.pos};if(n.value==="end"&&e.length===1)return{type:17,pos:n.pos};if(n.value==="if"&&t===1)return f();if(n.value==="else"&&t===1)return m()}if(n?.type===0)return{type:7,value:n.value,pos:n.pos};if(n?.type===4&&n.value==="("){let l=w();return o(4,")"),{type:9,expr:l,pos:n.pos}}if(n?.type===4&&ie.has(n.value)){let l=n.value,u=w();return{type:2,operator:l,expr:u,pos:n.pos}}throw t>e.length?{message:"Unexpected end of expression.",pos:e[e.length-1].pos}:{message:`Unexpected token '${n?.value}'.`,pos:n.pos}}function _(){let n=p();for(;e[t];){let l=e[t];if(l?.type===4&&l?.value==="("){if(t++,!i&&!r.allowFnCalls)throw{message:"Function calls are not allowed.",pos:e[t-1].pos};let u=s();o(4,")"),n={type:3,expr:n,args:u,pos:e[t-1].pos}}else if(l?.type===4&&l?.value==="?."&&e[t+1]?.type===4&&e[t+1]?.value==="("){if(t++,t++,!i&&!r.allowFnCalls)throw{message:"Function calls are not allowed.",pos:e[t-1].pos};let u=s();o(4,")"),n={type:3,expr:n,args:u,optional:!0,pos:e[t-1].pos}}else if(l?.type===4&&se.has(l?.value)){let u=l?.value==="::",C=l?.value==="[",v=l?.value==="?.";if(t++,u&&(e[t-2]?.type!==0||e[t]?.type!==0))throw{message:`Invalid namespaces access. Expected syntax <IDENTIFIER>::<IDENTIFIER>, but got '${e[t-2]?.value}::${e[t]?.value}' instead.`,pos:e[t]?.pos};if(u){i=!0;let R=p();n={type:6,left:n,right:R,pos:e[t-1].pos}}else if(C){let R=w();o(4,"]"),n={type:8,right:R,left:n,bracketNotation:!0,pos:e[t-1].pos}}else if(v)if(e[t]?.type===4&&e[t]?.value==="["){t++;let R=w();o(4,"]"),n={type:8,left:n,right:R,bracketNotation:!0,optional:!0,pos:e[t-1].pos}}else{let R=p();n={type:8,left:n,right:R,optional:!0,pos:e[t-1].pos}}else{let R=p();n={type:8,left:n,right:R,pos:e[t-1].pos}}}else break}return i=!1,n}function y(){let n=_();for(;e[t]?.type===4&&oe.has(e[t]?.value);){let l=e[t++].value,u=_();n={type:0,left:n,right:u,operator:l,pos:e[t-1].pos}}return n}function b(){let n=y();for(;e[t]?.type===4&&ne.has(e[t]?.value);){let l=e[t++].value,u=y();n={type:0,left:n,right:u,operator:l,pos:e[t-1].pos}}return n}function a(){let n=b();for(;e[t]?.type===4&&V.has(e[t]?.value);){let l=e[t++].value,u=b();n={type:0,left:n,right:u,operator:l,pos:e[t-1].pos}}return n}function E(){let n=a();for(;e[t]?.type===4&&V.has(e[t]?.value);){let l=e[t++].value,u=a();n={type:0,left:n,right:u,operator:l,pos:e[t-1].pos}}return n}function h(){let n=E();for(;e[t]?.type===4&&re.has(e[t]?.value);){let l=e[t++].value,u=E();n={type:0,left:n,right:u,operator:l,pos:e[t-1].pos}}return n}function O(){let n=P();for(;e[t]?.type===4&&e[t]?.value==="||";){let l=e[t++].value,u=P();n={type:0,left:n,right:u,operator:l,pos:e[t-1].pos}}return n}function P(){let n=$();for(;e[t]?.type===4&&e[t]?.value==="&&";){let l=e[t++].value,u=$();n={type:0,left:n,right:u,operator:l,pos:e[t-1].pos}}return n}function $(){let n=h();for(;e[t]?.type===4&&e[t]?.value==="??";){let l=e[t++].value,u=h();n={type:0,left:n,right:u,operator:l,pos:e[t-1].pos}}return n}function w(){let n=O();if(e[t]?.type!==4||e[t]?.value!=="?")return n;t++;let l=w();o(4,":");let u=w();return{type:1,left:l,right:u,condition:n,pos:e[t-1].pos}}return w()}function Q(e,{delimiters:r}){let t=`${r.openingTag}${r.whitespaceTrim}`,i=`${r.whitespaceTrim}${r.closingTag}`,o=e.startsWith(t),c=e.endsWith(i),f=e.startsWith(o?t+r.commentTag:r.openingTag+r.commentTag);if(f)return{isComment:f,leftTrim:o,rightTrim:c};let m=e.slice(o?t.length:r.openingTag.length,e.length-(c?i.length:r.closingTag.length)),s=m.trim(),p=s.startsWith("for")||s.startsWith("if")||s.startsWith("else"),_=s.startsWith("for")||s.startsWith("if"),y=s==="end",b=s.startsWith("for");return{leftTrim:o,rightTrim:c,inner:m,isBlock:p,isBlockEnd:y,hasContext:b,requiresBlockClose:_}}function X(e){let r=0,t="",i=[];function o(){let s="";if(/[a-zA-Z$_]/.test(t)){let p=r;for(;/[a-zA-Z$_0-9]/.test(e[p])&&p<e.length;)s+=e[p],p++;i.push({type:te.has(s)?1:0,value:s,pos:r}),r=p,t=e[r]}}function c(){let s="";if(t==='"'||t==="'"||t==="`"){let p=r+1;for(;e[p]!==t&&p<e.length;)s+=e[p],p++;if(p>e.length)throw{pos:r,message:"Found string without closing quote."};i.push({type:3,value:s,pos:r}),r=p}}function f(){if(/[0-9]/.test(t)){let s=r,p="";for(;/[0-9.oxe]/.test(e[s])&&s<e.length;)p+=e[s],s++;let _=Number(p);if(Number.isNaN(_))throw{pos:r,message:"Found invalid number literal."};i.push({type:2,value:`${_}`,pos:r}),r=s-1,t=e[r]}}function m(){let s=`${t}${e[r+1]}`;if(B.has(s)){i.push({type:4,value:s,pos:r}),r++;return}if(B.has(t)){i.push({type:4,value:t,pos:r});return}}for(;r<e.length;){if(t=e[r],f(),o(),c(),m(),!/[a-zA-Z$_0-9\s\t\r\n'"`]/.test(t)&&!B.has(t)&&!B.has(e[r-1]+t))throw{message:`Unexpected token '${t}' in expression.`,pos:r};r++}return i}function k(e,r,t){let i=[],o=[],{delimiters:c,keepOpeningTagEscapeDelimiter:f,allowFnCalls:m,allowedProps:s,forbiddenProps:p,autoEscape:_}=r,y=!1,b=0,a='let acc="";';for(;b<e.length;){let O=function(){let g=h,N=0;for(;g>=c.openingTagEscape.length&&e.slice(g-c.openingTagEscape.length,g)===c.openingTagEscape;)N++,g-=c.openingTagEscape.length;return N%2===1};var E=O;let h=e.indexOf(c.openingTag,b);if(h===-1){let g=e.slice(b);y&&(g=g.trimStart()),g&&(a+=`acc+=\`${U(g)}\`;`);break}if(O()){let g=e.slice(b,f?h+c.openingTagEscape.length+1:h-c.openingTag.length+1);y&&(g=g.trimStart(),y=!1),a+=`acc+=\`${U(g)}\`;`,f||(a+=`acc+=\`${c.openingTag}\`;`),b=h+c.openingTag.length;continue}let P=e.indexOf(c.closingTag,h);if(P===-1){let{line:g,lineIndex:N}=W(e,h),{line:x,pos:I}=Y(e,N,h);throw new M("No closing tag found.",g,x,I,t.path)}let $=e.slice(h,P+c.closingTag.length),{inner:w,leftTrim:q,rightTrim:n,isBlock:l,isBlockEnd:u,hasContext:C,requiresBlockClose:v,isComment:R}=Q($,{delimiters:c}),A=e.slice(b,h);A&&(y&&(A=A.trimStart()),q&&(A=A.trimEnd()),A&&(a+=`acc+=\`${U(A)}\`;`)),y=!1,b=P+c.closingTag.length;try{if(!R){let g=X(w),N=H(g,{allowFnCalls:m});if(l&&v&&C?(i.push(N.variable),o.push({type:0,pos:h})):l&&v&&!C&&o.push({type:1,pos:h}),u){let I=o.pop();if(I?.type===0&&i.pop(),I===void 0)throw{message:"Unexpected end of block",pos:h}}let x=z(N,{allowedProps:s,forbiddenProps:p,scope:i});l||u?a+=x:a+=_&&!x.startsWith("namespaces.Mutor.include")?`acc+=escapeFn(${x});`:`acc+=${x};`}n&&(y=!0)}catch(g){let{message:N,pos:x}=g,{line:I,lineIndex:de}=W(e,h),{line:me,pos:ge}=Y(e,de,h);throw new M(N,I,me,ge+x+(q?c.openingTag.length+c.whitespaceTrim.length:c.openingTag.length),t.path)}}if(o.length){let h=o.pop()?.pos,{line:O,lineIndex:P}=W(e,h),{line:$,pos:w}=Y(e,P,h);throw new M("Unclosed block detected.",O,$,w+c.openingTag.length,t.path)}return a+="return acc;",new Function("ctx","namespaces","allowedProps","forbiddenProps","escapeFn","validateComputedProps",a)}var K=class{constructor(r={}){this.__currentRenderedPath="";this.__includeStack=new Set;this.__cacheSize=0;this.__config={...S};this.__compiledTemplatesMap=new Map;this.__currentContext=null;this.__namespaces={...ce,Mutor:{include:(r,t)=>{if(this.__includeStack.has(r))throw new d(`Circular include detected:
-${Array.from(this.__includeStack).join(`
-`)}
-${r}`);try{return this.__includeStack.add(r),this.renderComponent(r,t??this.__currentContext)}finally{this.__includeStack.delete(r)}}}};this.addConfig(r),Object.defineProperty(this.__namespaces.Mutor,"$$context",{get:()=>this.__currentContext})}addConfig(r){let{autoEscape:t,delimiters:i,allowedProps:o,forbiddenProps:c,keepOpeningTagEscapeDelimiter:f,allowFnCalls:m,cache:s,build:p}=r;return this.__config={build:{include:new Set([...p?.include||S.build.include]),exclude:new Set([...S.build.exclude,...p?.exclude||[]])},autoEscape:t===!0?!0:t!==!1,allowedProps:o||S.allowedProps,allowFnCalls:!!m,cache:{...S.cache,...s||{}},forbiddenProps:new Set([...S.forbiddenProps,...c||[]]),keepOpeningTagEscapeDelimiter:f===!0?!0:f!==!1,delimiters:{...S.delimiters,...i||{}}},this.__config}restoreDefaultConfig(){this.__config={...S}}compile(r){return k(r,this.__config,{path:this.__currentRenderedPath||"anonymous"})}render(r,t){let i=this.__currentContext;i!==t&&(this.__currentContext=t);let o=this.compile(r)(j(t),this.__namespaces,this.__config.allowedProps,this.__config.forbiddenProps,F,D);return this.__currentContext=i,o}renderComponent(r,t){if(!this.__compiledTemplatesMap.has(r))throw new d(`No template exists with the identifier '${r}'`);let i=this.__currentRenderedPath,o=this.__currentContext,c=this.__compiledTemplatesMap.get(r);this.__currentContext=t,this.__currentRenderedPath=r;let f=c.fn(j(t),this.__namespaces,this.__config.allowedProps,this.__config.forbiddenProps,F,D);return this.__currentContext=o,this.__currentRenderedPath=i,f}registerComponent(r,t){let i=t.length*2+500;if(this.__cacheSize+i>this.__config.cache.maxSize&&!this.createEntrySpaceForTemplate(i))throw new d(`The template for the component '${r}' is too large. Consider increasing 'cache.maxSize' in the config`);this.__cacheSize+=t.length*2+500,this.__compiledTemplatesMap.set(r,{fn:this.compile(t),size:i})}reset(){this.__config={...S},this.__compiledTemplatesMap.clear(),this.__currentContext=null,this.__cacheSize=0}createEntrySpaceForTemplate(r){if(this.__cacheSize+r<this.__config.cache.maxSize)return!0;if(r>this.__config.cache.maxSize)return!1;let t=this.__compiledTemplatesMap.entries().next().value;if(t){let[i,o]=t;this.__compiledTemplatesMap.delete(i),this.__cacheSize-=o.size}return this.createEntrySpaceForTemplate(r)}getDiagnostics(){let r=this.__config.cache.maxSize;return{bytesUsed:this.__cacheSize,bytesMax:r,readableUsed:`${(this.__cacheSize/1024/1024).toFixed(2)} MB`,readableMax:`${(r/1024/1024).toFixed(2)} MB`,totalEntries:this.__compiledTemplatesMap.size,percentFull:r>0?Math.min(100,Math.round(this.__cacheSize/r*100)):0,avgTemplateSize:this.__compiledTemplatesMap.size>0?Math.round(this.__cacheSize/this.__compiledTemplatesMap.size):0}}};var J=class extends K{constructor(r={}){super(r),this.__namespaces.Mutor.include=(t,i)=>{let o=T(this.__currentRenderedPath,t);if(this.__includeStack.has(o))throw new d(`Circular include detected:
-${Array.from(this.__includeStack).join(`
-`)}
-${o}`);try{return this.__includeStack.add(o),this.renderFile(o,i??this.__currentContext)}finally{this.__includeStack.delete(o)}}}renderFile(r,t){let i=T(r),o,c=this.__currentContext,f=this.__currentRenderedPath;if(this.__currentContext=t,this.__currentRenderedPath=r,this.__config.cache.active&&this.__compiledTemplatesMap.has(i))o=this.__compiledTemplatesMap.get(i).fn;else{let s=we(i,"utf-8");if(o=this.compile(s),this.__config.cache.active){let p=s.length*2+500;this.__cacheSize+p>this.__config.cache.maxSize?this.createEntrySpaceForTemplate(p)&&(this.__compiledTemplatesMap.set(i,{fn:o,size:p}),this.__cacheSize+=p):(this.__compiledTemplatesMap.set(i,{fn:o,size:p}),this.__cacheSize+=p)}}let m=o(j(t),this.__namespaces,this.__config.allowedProps,this.__config.forbiddenProps,F,D);return this.__currentContext=c,this.__currentRenderedPath=f,m}async buildDir(r,t,i){let o=T(t),c=T(r);await Re(o,{recursive:!0});let f=await fe(c,{withFileTypes:!0});await Promise.all(f.map(async m=>{let s=ee(c,m.name),p=ee(o,m.name);if(this.__config.build.exclude.has(m.name))return;if(m.isDirectory())return this.buildDir(s,p,i);let _=he(s);if(this.__config.build.include.has(_)){let y=this.renderFile(s,i);await Se(p,y,"utf-8")}else return await be(s,p)}))}async compileDir(r){let t=T(r),i=await fe(t,{withFileTypes:!0});await Promise.all(i.map(async o=>{let c=ee(t,o.name);if(this.__config.build.exclude.has(o.name))return;if(o.isDirectory())return this.compileDir(c);let f=he(c);if(this.__config.build.include.has(f))try{let m=await Pe(c,"utf-8");this.registerComponent(c,m)}catch{}}))}};var $t=J;export{$t as default};
+// src/core/mutor.server.ts
+import { readFileSync } from "fs";
+import {
+  copyFile,
+  mkdir,
+  readdir,
+  readFile,
+  writeFile
+} from "fs/promises";
+import { extname, join } from "path";
+
+// src/utils/construct-pointer.ts
+function constructPointer(pos, offset) {
+  return `${" ".repeat(pos + offset + 1)}^`;
+}
+
+// src/core/error.ts
+var MutorError = class _MutorError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "MutorError";
+    Object.setPrototypeOf(this, _MutorError.prototype);
+  }
+};
+var MutorCompilerError = class _MutorCompilerError extends MutorError {
+  constructor(message, line, lineText, column, file) {
+    const gutterWidth = line.toString().length + 2;
+    let report = `${message}
+
+`;
+    report += `at ${file}:${line}:${column + 1}
+`;
+    if (line > 1) {
+      report += `${(line - 1).toString().padStart(gutterWidth - 2)} | ...
+`;
+    }
+    report += `${line} | ${lineText}
+`;
+    report += constructPointer(column, gutterWidth);
+    super(report);
+    this.name = "MutorCompilerError";
+    Object.setPrototypeOf(this, _MutorCompilerError.prototype);
+  }
+};
+
+// src/core/constants.ts
+var keywords = /* @__PURE__ */ new Set([
+  "for",
+  "if",
+  "else",
+  "true",
+  "false",
+  "null",
+  "undefined",
+  "end",
+  "in",
+  "of"
+]);
+var operators = /* @__PURE__ */ new Set([
+  "::",
+  // Namespace access
+  "||",
+  // Or
+  "??",
+  // Nullish coalesce
+  "&&",
+  // And
+  "**",
+  // Power
+  "^",
+  // Bitwise XOr
+  "|",
+  // Bitwise Or
+  "&",
+  // Bitwise And
+  "!",
+  // Not
+  "-",
+  // Minus
+  "%",
+  // Modulus
+  "+",
+  // Plus
+  "*",
+  // Times
+  "/",
+  // Divide
+  ">",
+  // Greater than
+  "<",
+  // Less than
+  ">=",
+  // Greater or equal
+  "<=",
+  // Less or equal
+  "==",
+  // Strict equal
+  "!=",
+  // Strict not equal
+  ">>",
+  // Bitwise right shift
+  "<<",
+  // Bitwise left shift
+  ".",
+  // Property acess
+  "?.",
+  // Optional property access
+  "(",
+  // Open parentheses
+  ")",
+  // Close parentheses
+  "[",
+  // Square open parentheses
+  "]",
+  // Square close parentheses
+  ",",
+  // Comma
+  ":",
+  // Column
+  "?"
+  // Ternary operator
+]);
+var equalityOperators = /* @__PURE__ */ new Set(["==", "!="]);
+var comparisonOperators = /* @__PURE__ */ new Set([">", "<", ">=", "<="]);
+var additiveOperators = /* @__PURE__ */ new Set(["+", "-"]);
+var multiplicativeOperators = /* @__PURE__ */ new Set(["*", "/", "%"]);
+var propertyAccessOperators = /* @__PURE__ */ new Set([".", "?.", "[", "::"]);
+var unaryOperators = /* @__PURE__ */ new Set(["-", "+", "!"]);
+var ESCAPE_MAP = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+var defaultConfig = {
+  build: {
+    include: /* @__PURE__ */ new Set([".html", ".txt"]),
+    exclude: /* @__PURE__ */ new Set(["node_modules", ".git"])
+  },
+  autoEscape: true,
+  allowedProps: /* @__PURE__ */ new Set(),
+  forbiddenProps: /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]),
+  allowFnCalls: false,
+  delimiters: {
+    closingTag: "}}",
+    openingTag: "{{",
+    openingTagEscape: "\\",
+    whitespaceTrim: "~",
+    commentTag: "#"
+  },
+  keepOpeningTagEscapeDelimiter: false,
+  cache: {
+    active: true,
+    maxSize: 50 * 1024 * 1024
+    // 50MB
+  }
+};
+var namespaces = {
+  JSON: {
+    stringify(value) {
+      try {
+        return JSON.stringify(value);
+      } catch {
+        throw new MutorError("JSON.stringify failed: invalid value");
+      }
+    },
+    parse(str) {
+      if (typeof str !== "string") {
+        throw new MutorError("JSON.parse expects a string");
+      }
+      try {
+        return JSON.parse(str);
+      } catch {
+        throw new MutorError("JSON.parse failed: invalid JSON string");
+      }
+    }
+  },
+  Object: {
+    keys(obj) {
+      if (!obj || typeof obj !== "object") {
+        throw new MutorError("Object.keys expects an object");
+      }
+      return Object.keys(obj);
+    },
+    values(obj) {
+      if (!obj || typeof obj !== "object") {
+        throw new MutorError("Object.values expects an object");
+      }
+      return Object.values(obj);
+    },
+    entries(obj) {
+      if (!obj || typeof obj !== "object") {
+        throw new MutorError("Object.entries expects an object");
+      }
+      return Object.entries(obj);
+    },
+    hasOwn(obj, key) {
+      if (!obj || typeof obj !== "object") {
+        throw new MutorError("Object.hasOwn expects an object");
+      }
+      return Object.hasOwn(obj, key);
+    },
+    freeze(obj) {
+      if (!obj || typeof obj !== "object") {
+        throw new MutorError("Object.freeze expects an object");
+      }
+      return Object.freeze(obj);
+    },
+    seal(obj) {
+      if (!obj || typeof obj !== "object") {
+        throw new MutorError("Object.seal expects an object");
+      }
+      return Object.seal(obj);
+    },
+    fromEntries(entries) {
+      if (!Array.isArray(entries)) {
+        throw new MutorError("Object.fromEntries expects an array");
+      }
+      return Object.fromEntries(entries);
+    }
+  },
+  Array: {
+    isArray(value) {
+      return Array.isArray(value);
+    },
+    from(value) {
+      return Array.from(value);
+    }
+  },
+  Number: {
+    isFinite(value) {
+      return Number.isFinite(value);
+    },
+    isNaN(value) {
+      return Number.isNaN(value);
+    },
+    parseInt(value, radix = 10) {
+      return Number.parseInt(value, radix);
+    },
+    parseFloat(value) {
+      return Number.parseFloat(value);
+    }
+  },
+  String: {
+    fromCharCode(...args) {
+      return String.fromCharCode(...args);
+    }
+  },
+  Math: {
+    abs(x) {
+      return Math.abs(x);
+    },
+    floor(x) {
+      return Math.floor(x);
+    },
+    ceil(x) {
+      return Math.ceil(x);
+    },
+    round(x) {
+      return Math.round(x);
+    },
+    max(...args) {
+      return Math.max(...args);
+    },
+    min(...args) {
+      return Math.min(...args);
+    },
+    random() {
+      return Math.random();
+    }
+  },
+  Date: {
+    now() {
+      return Date.now();
+    },
+    parse(str) {
+      if (typeof str !== "string") {
+        throw new MutorError("Date.parse expects a string");
+      }
+      return Date.parse(str);
+    }
+  },
+  Boolean: {
+    valueOf(value) {
+      return Boolean(value);
+    }
+  }
+};
+
+// src/utils/escape-fn.ts
+function escapeFn(e) {
+  if (typeof e !== "string") return e;
+  return /[&<>"']/.test(e) ? e.replace(/[&<>"']/g, (char) => ESCAPE_MAP[char]) : e;
+}
+
+// src/utils/to-absolute-path.ts
+import { dirname, isAbsolute, resolve } from "path";
+function toAbsolutePath(basePath, ...relativePaths) {
+  const absoluteBase = isAbsolute(basePath) ? basePath : resolve(process.cwd(), basePath);
+  if (relativePaths.length) {
+    const baseDir = dirname(absoluteBase);
+    return resolve(baseDir, ...relativePaths);
+  }
+  return absoluteBase;
+}
+
+// src/utils/validate-computed-prop.ts
+function validateComputedProp(r, allowedProps, forbiddenProps) {
+  if (forbiddenProps.has(r) && !allowedProps.has(r)) {
+    throw new MutorError(
+      `Forbidden property access. Access to this computed property "${r}" is forbidden.`
+    );
+  }
+  return r;
+}
+
+// src/utils/validate-context.ts
+var OBJECT = "object";
+var MUTOR_SAFE = /* @__PURE__ */ Symbol("__mutor_safe_context");
+function validateContext(ctx) {
+  if (!ctx || typeof ctx !== OBJECT) {
+    return ctx;
+  }
+  if (MUTOR_SAFE in ctx) {
+    return ctx;
+  }
+  const seen = /* @__PURE__ */ new WeakSet();
+  function walk(value, path = "") {
+    if (!value || typeof value !== OBJECT) return value;
+    if (seen.has(value)) return value;
+    seen.add(value);
+    const proto = Object.getPrototypeOf(value);
+    if (proto && proto !== Object.prototype && proto !== Array.prototype) {
+      throw new MutorError(`Unsafe prototype detected at ${path || "root"}`);
+    }
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        value[i] = walk(value[i], `${path}[${i}]`);
+      }
+      return value;
+    }
+    if (value instanceof Map) {
+      for (const [k, v] of value.entries()) {
+        if (typeof k === OBJECT) walk(k, `${path}.mapKey`);
+        value.set(k, walk(v, `${path}.mapValue`));
+      }
+      return value;
+    }
+    if (value instanceof Set) {
+      const next = /* @__PURE__ */ new Set();
+      for (const v of value.values()) {
+        next.add(walk(v, path));
+      }
+      value.clear();
+      for (const v of next) value.add(v);
+      return value;
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    for (const key of Object.keys(descriptors)) {
+      const desc = descriptors[key];
+      if (desc.get || desc.set) {
+        throw new MutorError(`Getter/setter not allowed: ${path}.${key}`);
+      }
+      const prop = value[key];
+      if (prop && typeof prop === OBJECT) {
+        value[key] = walk(prop, `${path}.${key}`);
+      }
+    }
+    return value;
+  }
+  const safeData = walk(ctx);
+  if (safeData && typeof safeData === OBJECT) {
+    Object.defineProperty(safeData, MUTOR_SAFE, {
+      value: true,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+  return safeData;
+}
+
+// src/utils/escape-raw-text.ts
+function escapeRawText(text) {
+  return text.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
+}
+
+// src/utils/get-line-and-column-nums.ts
+function getLineAndColumnNumbers(str, idx) {
+  const lines = str.slice(0, idx).split("\n");
+  const line = lines.length;
+  const lineIndex = str.lastIndexOf("\n", idx - 1) + 1;
+  return { line, lineIndex };
+}
+
+// src/utils/get-line-snapshot.ts
+function getLineSnapshot(str, lineIdx, idx) {
+  const nextNewlineIdx = str.indexOf("\n", lineIdx);
+  const line = str.slice(
+    lineIdx,
+    nextNewlineIdx === -1 ? void 0 : nextNewlineIdx
+  );
+  return { line, pos: idx - lineIdx };
+}
+
+// src/core/build.ts
+function build(ast, context) {
+  const { scope, forbiddenProps, allowedProps } = context;
+  function prefixWithCtx(ident) {
+    return scope.includes(ident) ? ident : `ctx.${ident}`;
+  }
+  function buildExpr(expr) {
+    switch (expr.type) {
+      case 17 /* END */:
+        return "}";
+      case 5 /* NUMBER */:
+        return expr.value;
+      case 4 /* STRING */:
+        return `\`${/\$/.test(expr.value) ? expr.value.replaceAll("$", "\\$") : expr.value}\``;
+      case 10 /* BOOLEAN */:
+        return expr.true ? "true" : "false";
+      case 12 /* NULL */:
+        return "null";
+      case 11 /* UNDEFINED */:
+        return "undefined";
+      case 7 /* IDENT */:
+        return prefixWithCtx(expr.value);
+      case 9 /* GROUP */:
+        return `(${buildExpr(expr.expr)})`;
+      case 2 /* UNARY */:
+        return `${expr.operator}${buildExpr(expr.expr)}`;
+      case 0 /* BINARY */:
+        return `${buildExpr(expr.left)} ${expr.operator} ${buildExpr(expr.right)}`;
+      case 1 /* TERNARY */:
+        return `${buildExpr(expr.condition)} ? ${buildExpr(expr.left)} : ${buildExpr(expr.right)}`;
+      case 8 /* PROP_ACCESS */:
+        return buildPropAccess(expr);
+      case 3 /* CALL */:
+        return buildCall(expr);
+      case 6 /* NAMESPACE */:
+        return buildNamespace(expr);
+      case 13 /* FOR */:
+        return buildForLoop(expr);
+      case 16 /* ELSE */:
+        return "} else {";
+      case 14 /* IF */:
+        return buildIfBlock(expr);
+      case 15 /* ELSE_IF */:
+        return buildElseIfBlock(expr);
+      default:
+        throw new MutorError(
+          `Unsupported expression type: ${expr.type}`
+        );
+    }
+  }
+  function buildNamespace(expr) {
+    if (expr.left.type !== 7 /* IDENT */) {
+      throw {
+        message: "Invalid usage of namespace operator.",
+        pos: expr.pos
+      };
+    }
+    return `namespaces.${expr.left.value}.${expr.right.value}`;
+  }
+  function buildPropAccess(expr) {
+    const left = buildExpr(expr.left);
+    if (expr.bracketNotation) {
+      const right = buildExpr(expr.right);
+      const optionalChain = expr.optional ? "?." : "";
+      return expr.right.type === 4 /* STRING */ || expr.right.type === 5 /* NUMBER */ ? `${left}${optionalChain}[${right}]` : `${left}${optionalChain}[validateComputedProps(${right}, allowedProps, forbiddenProps)]`;
+    } else {
+      const propName = expr.right.value;
+      const optionalChain = expr.optional ? "?." : ".";
+      if (forbiddenProps.has(propName) && !allowedProps.has(propName)) {
+        throw { message: "Forbidden property access.", pos: expr.right.pos };
+      }
+      return `${left}${optionalChain}${propName}`;
+    }
+  }
+  function buildCall(expr) {
+    const func = buildExpr(expr.expr);
+    const optionalChain = expr.optional ? "?." : "";
+    const args = expr.args.map((arg) => buildExpr(arg)).join(", ");
+    return `${func}${optionalChain}(${args})`;
+  }
+  function buildForLoop(expr) {
+    const { iterable, loopType, variable } = expr;
+    return `for(const ${variable} ${loopType === 1 /* IN */ ? "in" : "of"} ${build(iterable, context)}){`;
+  }
+  function buildIfBlock(expr) {
+    const { condition } = expr;
+    return `if(${build(condition, context)}){`;
+  }
+  function buildElseIfBlock(expr) {
+    const { condition } = expr;
+    return `}else if(${build(condition, context)}){`;
+  }
+  return buildExpr(ast);
+}
+
+// src/utils/get-token-type-words.ts
+function getTokenTypeWords(type) {
+  switch (type) {
+    case 0 /* IDENT */:
+      return "identifier";
+    case 1 /* KEYWORD */:
+      return "keyword";
+    case 2 /* NUMBER */:
+      return "number";
+    case 4 /* OPERATOR */:
+      return "operator";
+    case 3 /* STRING */:
+      return "string";
+  }
+}
+
+// src/core/generate-ast.ts
+function generateAst(tokens, config) {
+  let cursor = 0, generatingNamespace = false;
+  function expectOrThrow(type, value) {
+    const token = tokens[cursor];
+    const lastToken = tokens[tokens.length - 1];
+    if (!token) {
+      throw {
+        message: `Unexpected end of expression. Expected ${value ? `'${value}'` : `${type === 0 /* IDENT */ ? "an" : "a"} ${getTokenTypeWords(type)}`}.`,
+        pos: lastToken.pos + lastToken.value.length - 1
+      };
+    }
+    if (token.type !== type) {
+      throw {
+        message: `Unexpected token type. Expected ${value ? `'${value}'` : getTokenTypeWords(type)} but got ${getTokenTypeWords(token.type)} instead.`,
+        pos: token.pos
+      };
+    }
+    if (value !== void 0 && token.value !== value) {
+      throw {
+        message: `Unexpected token '${token?.value}'. Expected ${type === 0 /* IDENT */ ? "an" : "a"} ${getTokenTypeWords(type)} instead.`,
+        pos: token.pos
+      };
+    }
+    return tokens[cursor++];
+  }
+  function parseForLoop() {
+    const pos = tokens[cursor - 1].pos;
+    const variable = expectOrThrow(0 /* IDENT */).value;
+    let token;
+    try {
+      token = expectOrThrow(1 /* KEYWORD */, "in");
+    } catch {
+      token = expectOrThrow(1 /* KEYWORD */, "of");
+    }
+    const loopType = token.value === "in" ? 1 /* IN */ : 0 /* OF */;
+    const iterable = parseTernaryExpr();
+    return { type: 13 /* FOR */, loopType, iterable, variable, pos };
+  }
+  function parseIfExpression() {
+    const condition = parseTernaryExpr();
+    return { condition, pos: condition.pos, type: 14 /* IF */ };
+  }
+  function parseElseExpression() {
+    const pos = tokens[cursor - 1].pos;
+    try {
+      expectOrThrow(1 /* KEYWORD */, "if");
+      return { ...parseIfExpression(), type: 15 /* ELSE_IF */, pos };
+    } catch {
+      return { type: 16 /* ELSE */, pos };
+    }
+  }
+  function extractFnArgs() {
+    const args = [];
+    const emptyArgs = tokens[cursor]?.type === 4 /* OPERATOR */ && tokens[cursor]?.value === ")";
+    if (emptyArgs) {
+      return args;
+    }
+    args.push(parseTernaryExpr());
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && tokens[cursor]?.value === "," && tokens[cursor]?.value !== ")") {
+      cursor++;
+      args.push(parseTernaryExpr());
+    }
+    return args;
+  }
+  function parsePrimaryExpr() {
+    const token = tokens[cursor++];
+    if (token?.type === 2 /* NUMBER */) {
+      return { type: 5 /* NUMBER */, value: token.value, pos: token.pos };
+    }
+    if (token?.type === 3 /* STRING */) {
+      return { type: 4 /* STRING */, value: token.value, pos: token.pos };
+    }
+    if (token?.type === 1 /* KEYWORD */) {
+      if (token.value === "for" && cursor === 1) {
+        return parseForLoop();
+      }
+      if (token.value === "true" || token.value === "false") {
+        return {
+          type: 10 /* BOOLEAN */,
+          true: token.value === "true",
+          pos: token.pos
+        };
+      }
+      if (token.value === "undefined") {
+        return { type: 11 /* UNDEFINED */, pos: token.pos };
+      }
+      if (token.value === "null") {
+        return { type: 12 /* NULL */, pos: token.pos };
+      }
+      if (token.value === "end" && tokens.length === 1) {
+        return { type: 17 /* END */, pos: token.pos };
+      }
+      if (token.value === "if" && cursor === 1) {
+        return parseIfExpression();
+      }
+      if (token.value === "else" && cursor === 1) {
+        return parseElseExpression();
+      }
+    }
+    if (token?.type === 0 /* IDENT */) {
+      return { type: 7 /* IDENT */, value: token.value, pos: token.pos };
+    }
+    if (token?.type === 4 /* OPERATOR */ && token.value === "(") {
+      const expr = parseTernaryExpr();
+      expectOrThrow(4 /* OPERATOR */, ")");
+      return { type: 9 /* GROUP */, expr, pos: token.pos };
+    }
+    if (token?.type === 4 /* OPERATOR */ && unaryOperators.has(token.value)) {
+      const operator = token.value;
+      const expr = parseTernaryExpr();
+      return { type: 2 /* UNARY */, operator, expr, pos: token.pos };
+    }
+    if (cursor > tokens.length) {
+      throw {
+        message: `Unexpected end of expression.`,
+        pos: tokens[tokens.length - 1].pos
+      };
+    }
+    throw {
+      message: `Unexpected token '${token?.value}'.`,
+      pos: token.pos
+    };
+  }
+  function parsePropertyAccess() {
+    let left = parsePrimaryExpr();
+    while (tokens[cursor]) {
+      const token = tokens[cursor];
+      if (token?.type === 4 /* OPERATOR */ && token?.value === "(") {
+        cursor++;
+        if (!generatingNamespace && !config.allowFnCalls) {
+          throw {
+            message: "Function calls are not allowed.",
+            pos: tokens[cursor - 1].pos
+          };
+        }
+        const args = extractFnArgs();
+        expectOrThrow(4 /* OPERATOR */, ")");
+        left = {
+          type: 3 /* CALL */,
+          expr: left,
+          args,
+          pos: tokens[cursor - 1].pos
+        };
+      } else if (token?.type === 4 /* OPERATOR */ && token?.value === "?." && tokens[cursor + 1]?.type === 4 /* OPERATOR */ && tokens[cursor + 1]?.value === "(") {
+        cursor++;
+        cursor++;
+        if (!generatingNamespace && !config.allowFnCalls) {
+          throw {
+            message: "Function calls are not allowed.",
+            pos: tokens[cursor - 1].pos
+          };
+        }
+        const args = extractFnArgs();
+        expectOrThrow(4 /* OPERATOR */, ")");
+        left = {
+          type: 3 /* CALL */,
+          expr: left,
+          args,
+          optional: true,
+          pos: tokens[cursor - 1].pos
+        };
+      } else if (token?.type === 4 /* OPERATOR */ && propertyAccessOperators.has(token?.value)) {
+        const isNamespace = token?.value === "::";
+        const isBracketNotation = token?.value === "[";
+        const isOptional = token?.value === "?.";
+        cursor++;
+        if (isNamespace && (tokens[cursor - 2]?.type !== 0 /* IDENT */ || tokens[cursor]?.type !== 0 /* IDENT */)) {
+          throw {
+            message: `Invalid namespaces access. Expected syntax <IDENTIFIER>::<IDENTIFIER>, but got '${tokens[cursor - 2]?.value}::${tokens[cursor]?.value}' instead.`,
+            pos: tokens[cursor]?.pos
+          };
+        }
+        if (isNamespace) {
+          generatingNamespace = true;
+          const right = parsePrimaryExpr();
+          left = {
+            type: 6 /* NAMESPACE */,
+            left,
+            right,
+            pos: tokens[cursor - 1].pos
+          };
+        } else if (isBracketNotation) {
+          const right = parseTernaryExpr();
+          expectOrThrow(4 /* OPERATOR */, "]");
+          left = {
+            type: 8 /* PROP_ACCESS */,
+            right,
+            left,
+            bracketNotation: true,
+            pos: tokens[cursor - 1].pos
+          };
+        } else if (isOptional) {
+          if (tokens[cursor]?.type === 4 /* OPERATOR */ && tokens[cursor]?.value === "[") {
+            cursor++;
+            const right = parseTernaryExpr();
+            expectOrThrow(4 /* OPERATOR */, "]");
+            left = {
+              type: 8 /* PROP_ACCESS */,
+              left,
+              right,
+              bracketNotation: true,
+              optional: true,
+              pos: tokens[cursor - 1].pos
+            };
+          } else {
+            const right = parsePrimaryExpr();
+            left = {
+              type: 8 /* PROP_ACCESS */,
+              left,
+              right,
+              optional: true,
+              pos: tokens[cursor - 1].pos
+            };
+          }
+        } else {
+          const right = parsePrimaryExpr();
+          left = {
+            type: 8 /* PROP_ACCESS */,
+            left,
+            right,
+            pos: tokens[cursor - 1].pos
+          };
+        }
+      } else {
+        break;
+      }
+    }
+    generatingNamespace = false;
+    return left;
+  }
+  function parseMultiplicativeExpr() {
+    let left = parsePropertyAccess();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && multiplicativeOperators.has(tokens[cursor]?.value)) {
+      const operator = tokens[cursor++].value;
+      const right = parsePropertyAccess();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseAdditiveExpr() {
+    let left = parseMultiplicativeExpr();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && additiveOperators.has(tokens[cursor]?.value)) {
+      const operator = tokens[cursor++].value;
+      const right = parseMultiplicativeExpr();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseBitwiseExpr() {
+    let left = parseAdditiveExpr();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && comparisonOperators.has(tokens[cursor]?.value)) {
+      const operator = tokens[cursor++].value;
+      const right = parseAdditiveExpr();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseComparisonExpr() {
+    let left = parseBitwiseExpr();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && comparisonOperators.has(tokens[cursor]?.value)) {
+      const operator = tokens[cursor++].value;
+      const right = parseBitwiseExpr();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseEqualityExpr() {
+    let left = parseComparisonExpr();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && equalityOperators.has(tokens[cursor]?.value)) {
+      const operator = tokens[cursor++].value;
+      const right = parseComparisonExpr();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseLogicalOrExpr() {
+    let left = parseLogicalAndExpr();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && tokens[cursor]?.value === "||") {
+      const operator = tokens[cursor++].value;
+      const right = parseLogicalAndExpr();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseLogicalAndExpr() {
+    let left = parseNullishCoalesceExpr();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && tokens[cursor]?.value === "&&") {
+      const operator = tokens[cursor++].value;
+      const right = parseNullishCoalesceExpr();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseNullishCoalesceExpr() {
+    let left = parseEqualityExpr();
+    while (tokens[cursor]?.type === 4 /* OPERATOR */ && tokens[cursor]?.value === "??") {
+      const operator = tokens[cursor++].value;
+      const right = parseEqualityExpr();
+      left = {
+        type: 0 /* BINARY */,
+        left,
+        right,
+        operator,
+        pos: tokens[cursor - 1].pos
+      };
+    }
+    return left;
+  }
+  function parseTernaryExpr() {
+    const condition = parseLogicalOrExpr();
+    if (tokens[cursor]?.type !== 4 /* OPERATOR */ || tokens[cursor]?.value !== "?") {
+      return condition;
+    }
+    cursor++;
+    const left = parseTernaryExpr();
+    expectOrThrow(4 /* OPERATOR */, ":");
+    const right = parseTernaryExpr();
+    return {
+      type: 1 /* TERNARY */,
+      left,
+      right,
+      condition,
+      pos: tokens[cursor - 1].pos
+    };
+  }
+  const ast = parseTernaryExpr();
+  return ast;
+}
+
+// src/core/parse.ts
+function parse(templateBlock, { delimiters }) {
+  const openingTagWithWhitespaceCtrl = `${delimiters.openingTag}${delimiters.whitespaceTrim}`;
+  const closingTagWithWhitespaceCtrl = `${delimiters.whitespaceTrim}${delimiters.closingTag}`;
+  const leftTrim = templateBlock.startsWith(openingTagWithWhitespaceCtrl);
+  const rightTrim = templateBlock.endsWith(closingTagWithWhitespaceCtrl);
+  const isComment = templateBlock.startsWith(
+    leftTrim ? openingTagWithWhitespaceCtrl + delimiters.commentTag : delimiters.openingTag + delimiters.commentTag
+  );
+  if (isComment) {
+    return { isComment, leftTrim, rightTrim };
+  }
+  const inner = templateBlock.slice(
+    leftTrim ? openingTagWithWhitespaceCtrl.length : delimiters.openingTag.length,
+    templateBlock.length - (rightTrim ? closingTagWithWhitespaceCtrl.length : delimiters.closingTag.length)
+  );
+  const trimmed = inner.trim();
+  const isBlock = trimmed.startsWith("for") || trimmed.startsWith("if") || trimmed.startsWith("else");
+  const requiresBlockClose = trimmed.startsWith("for") || trimmed.startsWith("if");
+  const isBlockEnd = trimmed === "end";
+  const hasContext = trimmed.startsWith("for");
+  return {
+    leftTrim,
+    rightTrim,
+    inner,
+    isBlock,
+    isBlockEnd,
+    hasContext,
+    requiresBlockClose
+  };
+}
+
+// src/core/tokenize.ts
+function tokenize(expr) {
+  let cursor = 0, char = "";
+  const tokens = [];
+  function accumulateKeywordOrIdentifier() {
+    let buffer = "";
+    if (/[a-zA-Z$_]/.test(char)) {
+      let j = cursor;
+      while (/[a-zA-Z$_0-9]/.test(expr[j]) && j < expr.length) {
+        buffer += expr[j];
+        j++;
+      }
+      tokens.push({
+        type: keywords.has(buffer) ? 1 /* KEYWORD */ : 0 /* IDENT */,
+        value: buffer,
+        pos: cursor
+      });
+      cursor = j;
+      char = expr[cursor];
+    }
+  }
+  function accumulateStr() {
+    let buffer = "";
+    if (char === '"' || char === "'" || char === "`") {
+      let j = cursor + 1;
+      while (expr[j] !== char && j < expr.length) {
+        buffer += expr[j];
+        j++;
+      }
+      if (j > expr.length) {
+        throw { pos: cursor, message: `Found string without closing quote.` };
+      }
+      tokens.push({ type: 3 /* STRING */, value: buffer, pos: cursor });
+      cursor = j;
+    }
+  }
+  function accumulateNumber() {
+    if (/[0-9]/.test(char)) {
+      let j = cursor, buffer = "";
+      while (/[0-9.oxe]/.test(expr[j]) && j < expr.length) {
+        buffer += expr[j];
+        j++;
+      }
+      const numVal = Number(buffer);
+      const isNan = Number.isNaN(numVal);
+      if (isNan) {
+        throw { pos: cursor, message: "Found invalid number literal." };
+      }
+      tokens.push({ type: 2 /* NUMBER */, value: `${numVal}`, pos: cursor });
+      cursor = j - 1;
+      char = expr[cursor];
+    }
+  }
+  function accumulateOperator() {
+    const op = `${char}${expr[cursor + 1]}`;
+    if (operators.has(op)) {
+      tokens.push({ type: 4 /* OPERATOR */, value: op, pos: cursor });
+      cursor++;
+      return;
+    }
+    if (operators.has(char)) {
+      tokens.push({ type: 4 /* OPERATOR */, value: char, pos: cursor });
+      return;
+    }
+  }
+  while (cursor < expr.length) {
+    char = expr[cursor];
+    accumulateNumber();
+    accumulateKeywordOrIdentifier();
+    accumulateStr();
+    accumulateOperator();
+    if (!/[a-zA-Z$_0-9\s\t\r\n'"`]/.test(char) && !operators.has(char) && !operators.has(expr[cursor - 1] + char)) {
+      throw {
+        message: `Unexpected token '${char}' in expression.`,
+        pos: cursor
+      };
+    }
+    cursor++;
+  }
+  return tokens;
+}
+
+// src/core/compile.ts
+function compile(src, config, meta) {
+  const scope = [];
+  const blockOpeningStack = [];
+  const {
+    delimiters,
+    keepOpeningTagEscapeDelimiter,
+    allowFnCalls,
+    allowedProps,
+    forbiddenProps,
+    autoEscape
+  } = config;
+  let trimNext = false, cursor = 0, body = `let acc="";`;
+  while (cursor < src.length) {
+    let isEscaped2 = function() {
+      let j = templateOpenTagIdx, count = 0;
+      while (j >= delimiters.openingTagEscape.length && src.slice(j - delimiters.openingTagEscape.length, j) === delimiters.openingTagEscape) {
+        count++;
+        j -= delimiters.openingTagEscape.length;
+      }
+      return count % 2 === 1;
+    };
+    var isEscaped = isEscaped2;
+    const templateOpenTagIdx = src.indexOf(delimiters.openingTag, cursor);
+    if (templateOpenTagIdx === -1) {
+      let lastChunk = src.slice(cursor);
+      if (trimNext) lastChunk = lastChunk.trimStart();
+      if (lastChunk) body += `acc+=\`${escapeRawText(lastChunk)}\`;`;
+      break;
+    }
+    if (isEscaped2()) {
+      let escapedChunk = src.slice(
+        cursor,
+        keepOpeningTagEscapeDelimiter ? templateOpenTagIdx + delimiters.openingTagEscape.length + 1 : templateOpenTagIdx - delimiters.openingTag.length + 1
+      );
+      if (trimNext) {
+        escapedChunk = escapedChunk.trimStart();
+        trimNext = false;
+      }
+      body += `acc+=\`${escapeRawText(escapedChunk)}\`;`;
+      if (!keepOpeningTagEscapeDelimiter)
+        body += `acc+=\`${delimiters.openingTag}\`;`;
+      cursor = templateOpenTagIdx + delimiters.openingTag.length;
+      continue;
+    }
+    const templateEndTagIdx = src.indexOf(
+      delimiters.closingTag,
+      templateOpenTagIdx
+    );
+    if (templateEndTagIdx === -1) {
+      const { line, lineIndex } = getLineAndColumnNumbers(
+        src,
+        templateOpenTagIdx
+      );
+      const { line: lineText, pos } = getLineSnapshot(
+        src,
+        lineIndex,
+        templateOpenTagIdx
+      );
+      throw new MutorCompilerError(
+        "No closing tag found.",
+        line,
+        lineText,
+        pos,
+        meta.path
+      );
+    }
+    const template = src.slice(
+      templateOpenTagIdx,
+      templateEndTagIdx + delimiters.closingTag.length
+    );
+    const {
+      inner,
+      leftTrim,
+      rightTrim,
+      isBlock,
+      isBlockEnd,
+      hasContext,
+      requiresBlockClose,
+      isComment
+    } = parse(template, { delimiters });
+    let rawText = src.slice(cursor, templateOpenTagIdx);
+    if (rawText) {
+      if (trimNext) {
+        rawText = rawText.trimStart();
+      }
+      if (leftTrim) {
+        rawText = rawText.trimEnd();
+      }
+      if (rawText) {
+        body += `acc+=\`${escapeRawText(rawText)}\`;`;
+      }
+    }
+    trimNext = false;
+    cursor = templateEndTagIdx + delimiters.closingTag.length;
+    try {
+      if (!isComment) {
+        const tokens = tokenize(inner);
+        const ast = generateAst(tokens, { allowFnCalls });
+        if (isBlock && requiresBlockClose && hasContext) {
+          scope.push(ast.variable);
+          blockOpeningStack.push({
+            type: 0 /* LOOP */,
+            pos: templateOpenTagIdx
+          });
+        } else if (isBlock && requiresBlockClose && !hasContext) {
+          blockOpeningStack.push({
+            type: 1 /* NON_LOOP */,
+            pos: templateOpenTagIdx
+          });
+        }
+        if (isBlockEnd) {
+          const lastBlockOpened = blockOpeningStack.pop();
+          if (lastBlockOpened?.type === 0 /* LOOP */) scope.pop();
+          if (lastBlockOpened === void 0)
+            throw {
+              message: "Unexpected end of block",
+              pos: templateOpenTagIdx
+            };
+        }
+        const js = build(ast, { allowedProps, forbiddenProps, scope });
+        if (isBlock || isBlockEnd) {
+          body += js;
+        } else {
+          body += autoEscape && !js.startsWith("namespaces.Mutor.include") ? `acc+=escapeFn(${js});` : `acc+=${js};`;
+        }
+      }
+      if (rightTrim) trimNext = true;
+    } catch (e) {
+      const { message, pos: relPos } = e;
+      const { line, lineIndex } = getLineAndColumnNumbers(
+        src,
+        templateOpenTagIdx
+      );
+      const { line: lineText, pos } = getLineSnapshot(
+        src,
+        lineIndex,
+        templateOpenTagIdx
+      );
+      throw new MutorCompilerError(
+        message,
+        line,
+        lineText,
+        pos + relPos + (leftTrim ? delimiters.openingTag.length + delimiters.whitespaceTrim.length : delimiters.openingTag.length),
+        meta.path
+      );
+    }
+  }
+  if (blockOpeningStack.length) {
+    const lastPos = blockOpeningStack.pop()?.pos;
+    const { line, lineIndex } = getLineAndColumnNumbers(src, lastPos);
+    const { line: lineText, pos } = getLineSnapshot(src, lineIndex, lastPos);
+    throw new MutorCompilerError(
+      "Unclosed block detected.",
+      line,
+      lineText,
+      pos + delimiters.openingTag.length,
+      meta.path
+    );
+  }
+  body += `return acc;`;
+  return new Function(
+    "ctx",
+    "namespaces",
+    "allowedProps",
+    "forbiddenProps",
+    "escapeFn",
+    "validateComputedProps",
+    body
+  );
+}
+
+// src/core/mutor.ts
+var Mutor = class {
+  constructor(config = {}) {
+    this.__currentRenderedPath = "";
+    this.__includeStack = /* @__PURE__ */ new Set();
+    this.__cacheSize = 0;
+    this.__config = { ...defaultConfig };
+    this.__compiledTemplatesMap = /* @__PURE__ */ new Map();
+    this.__currentContext = null;
+    this.__namespaces = {
+      ...namespaces,
+      Mutor: {
+        include: (path, ctx) => {
+          if (this.__includeStack.has(path)) {
+            throw new MutorError(
+              `Circular include detected:
+${Array.from(this.__includeStack).join("\n")}
+${path}`
+            );
+          }
+          try {
+            this.__includeStack.add(path);
+            return this.renderComponent(path, ctx ?? this.__currentContext);
+          } finally {
+            this.__includeStack.delete(path);
+          }
+        }
+      }
+    };
+    this.addConfig(config);
+    Object.defineProperty(this.__namespaces.Mutor, "$$context", {
+      get: () => {
+        return this.__currentContext;
+      }
+    });
+  }
+  addConfig(conf) {
+    const {
+      autoEscape,
+      delimiters: overrideDelimeters,
+      allowedProps,
+      forbiddenProps,
+      keepOpeningTagEscapeDelimiter,
+      allowFnCalls,
+      cache,
+      build: build2
+    } = conf;
+    this.__config = {
+      build: {
+        include: /* @__PURE__ */ new Set([...build2?.include || defaultConfig.build.include]),
+        exclude: /* @__PURE__ */ new Set([
+          ...defaultConfig.build.exclude,
+          ...build2?.exclude || []
+        ])
+      },
+      autoEscape: autoEscape === true ? true : autoEscape !== false,
+      allowedProps: allowedProps || defaultConfig.allowedProps,
+      allowFnCalls: !!allowFnCalls,
+      cache: { ...defaultConfig.cache, ...cache || {} },
+      forbiddenProps: /* @__PURE__ */ new Set([
+        ...defaultConfig.forbiddenProps,
+        ...forbiddenProps || []
+      ]),
+      keepOpeningTagEscapeDelimiter: keepOpeningTagEscapeDelimiter === true ? true : keepOpeningTagEscapeDelimiter !== false,
+      delimiters: {
+        ...defaultConfig.delimiters,
+        ...overrideDelimeters || {}
+      }
+    };
+    return this.__config;
+  }
+  restoreDefaultConfig() {
+    this.__config = { ...defaultConfig };
+  }
+  compile(template) {
+    return compile(template, this.__config, {
+      path: this.__currentRenderedPath || "anonymous"
+    });
+  }
+  render(template, context) {
+    const prevContext = this.__currentContext;
+    if (prevContext !== context) {
+      this.__currentContext = context;
+    }
+    const result = this.compile(template)(
+      validateContext(context),
+      this.__namespaces,
+      this.__config.allowedProps,
+      this.__config.forbiddenProps,
+      escapeFn,
+      validateComputedProp
+    );
+    this.__currentContext = prevContext;
+    return result;
+  }
+  renderComponent(identifier, context) {
+    if (!this.__compiledTemplatesMap.has(identifier)) {
+      throw new MutorError(
+        `No template exists with the identifier '${identifier}'`
+      );
+    }
+    const prevRenderComponentIdentifier = this.__currentRenderedPath;
+    const prevContext = this.__currentContext;
+    const compiled = this.__compiledTemplatesMap.get(identifier);
+    this.__currentContext = context;
+    this.__currentRenderedPath = identifier;
+    const result = compiled.fn(
+      validateContext(context),
+      this.__namespaces,
+      this.__config.allowedProps,
+      this.__config.forbiddenProps,
+      escapeFn,
+      validateComputedProp
+    );
+    this.__currentContext = prevContext;
+    this.__currentRenderedPath = prevRenderComponentIdentifier;
+    return result;
+  }
+  registerComponent(identifier, template) {
+    const templateSize = template.length * 2 + 500;
+    if (this.__cacheSize + templateSize > this.__config.cache.maxSize) {
+      if (!this.createEntrySpaceForTemplate(templateSize)) {
+        throw new MutorError(
+          `The template for the component '${identifier}' is too large. Consider increasing 'cache.maxSize' in the config`
+        );
+      }
+    }
+    this.__cacheSize += template.length * 2 + 500;
+    this.__compiledTemplatesMap.set(identifier, {
+      fn: this.compile(template),
+      size: templateSize
+    });
+  }
+  reset() {
+    this.__config = { ...defaultConfig };
+    this.__compiledTemplatesMap.clear();
+    this.__currentContext = null;
+    this.__cacheSize = 0;
+  }
+  createEntrySpaceForTemplate(targetSize) {
+    if (this.__cacheSize + targetSize < this.__config.cache.maxSize) {
+      return true;
+    }
+    if (targetSize > this.__config.cache.maxSize) {
+      return false;
+    }
+    const firstEntry = this.__compiledTemplatesMap.entries().next().value;
+    if (firstEntry) {
+      const [oldestKey, oldestData] = firstEntry;
+      this.__compiledTemplatesMap.delete(oldestKey);
+      this.__cacheSize -= oldestData.size;
+    }
+    return this.createEntrySpaceForTemplate(targetSize);
+  }
+  getDiagnostics() {
+    const maxSize = this.__config.cache.maxSize;
+    return {
+      bytesUsed: this.__cacheSize,
+      bytesMax: maxSize,
+      readableUsed: `${(this.__cacheSize / 1024 / 1024).toFixed(2)} MB`,
+      readableMax: `${(maxSize / 1024 / 1024).toFixed(2)} MB`,
+      totalEntries: this.__compiledTemplatesMap.size,
+      percentFull: maxSize > 0 ? Math.min(100, Math.round(this.__cacheSize / maxSize * 100)) : 0,
+      avgTemplateSize: this.__compiledTemplatesMap.size > 0 ? Math.round(this.__cacheSize / this.__compiledTemplatesMap.size) : 0
+    };
+  }
+};
+
+// src/core/mutor.server.ts
+var Mutor2 = class extends Mutor {
+  constructor(config = {}) {
+    super(config);
+    this.__namespaces.Mutor.include = (path, context) => {
+      const resolvedPath = toAbsolutePath(this.__currentRenderedPath, path);
+      if (this.__includeStack.has(resolvedPath)) {
+        throw new MutorError(
+          `Circular include detected:
+${Array.from(this.__includeStack).join("\n")}
+${resolvedPath}`
+        );
+      }
+      try {
+        this.__includeStack.add(resolvedPath);
+        return this.renderFile(resolvedPath, context ?? this.__currentContext);
+      } finally {
+        this.__includeStack.delete(resolvedPath);
+      }
+    };
+  }
+  renderFile(path, context) {
+    const absolutePath = toAbsolutePath(path);
+    let compiled;
+    const prevContext = this.__currentContext;
+    const prevRenderComponentIdentifier = this.__currentRenderedPath;
+    this.__currentContext = context;
+    this.__currentRenderedPath = path;
+    if (this.__config.cache.active && this.__compiledTemplatesMap.has(absolutePath)) {
+      compiled = this.__compiledTemplatesMap.get(absolutePath).fn;
+    } else {
+      const template = readFileSync(absolutePath, "utf-8");
+      compiled = this.compile(template);
+      if (this.__config.cache.active) {
+        const templateSize = template.length * 2 + 500;
+        if (this.__cacheSize + templateSize > this.__config.cache.maxSize) {
+          if (this.createEntrySpaceForTemplate(templateSize)) {
+            this.__compiledTemplatesMap.set(absolutePath, {
+              fn: compiled,
+              size: templateSize
+            });
+            this.__cacheSize += templateSize;
+          }
+        } else {
+          this.__compiledTemplatesMap.set(absolutePath, {
+            fn: compiled,
+            size: templateSize
+          });
+          this.__cacheSize += templateSize;
+        }
+      }
+    }
+    const result = compiled(
+      validateContext(context),
+      this.__namespaces,
+      this.__config.allowedProps,
+      this.__config.forbiddenProps,
+      escapeFn,
+      validateComputedProp
+    );
+    this.__currentContext = prevContext;
+    this.__currentRenderedPath = prevRenderComponentIdentifier;
+    return result;
+  }
+  async buildDir(src, destination, context) {
+    const absoluteDestinationPath = toAbsolutePath(destination);
+    const absoluteSrcPath = toAbsolutePath(src);
+    await mkdir(absoluteDestinationPath, { recursive: true });
+    const entries = await readdir(absoluteSrcPath, { withFileTypes: true });
+    await Promise.all(
+      entries.map(async (entry) => {
+        const srcPath = join(absoluteSrcPath, entry.name);
+        const destinationPath = join(absoluteDestinationPath, entry.name);
+        if (this.__config.build.exclude.has(entry.name)) {
+          return;
+        }
+        if (entry.isDirectory()) {
+          return this.buildDir(srcPath, destinationPath, context);
+        }
+        const extension = extname(srcPath);
+        if (this.__config.build.include.has(extension)) {
+          const rendered = this.renderFile(srcPath, context);
+          await writeFile(destinationPath, rendered, "utf-8");
+        } else {
+          return await copyFile(srcPath, destinationPath);
+        }
+      })
+    );
+  }
+  async compileDir(src) {
+    const absolutePath = toAbsolutePath(src);
+    const entries = await readdir(absolutePath, { withFileTypes: true });
+    await Promise.all(
+      entries.map(async (entry) => {
+        const absoluteSrcPath = join(absolutePath, entry.name);
+        if (this.__config.build.exclude.has(entry.name)) {
+          return;
+        }
+        if (entry.isDirectory()) {
+          return this.compileDir(absoluteSrcPath);
+        }
+        const extension = extname(absoluteSrcPath);
+        if (this.__config.build.include.has(extension)) {
+          try {
+            const template = await readFile(absoluteSrcPath, "utf-8");
+            this.registerComponent(absoluteSrcPath, template);
+          } catch {
+          }
+        }
+      })
+    );
+  }
+};
+
+// src/server.ts
+var server_default = Mutor2;
+export {
+  server_default as default
+};
 //# sourceMappingURL=server.js.map