mutorjs 1.3.0 → 1.3.1

package/dist/index.js

@@ -1,13 +1,1327 @@
-function J(e,n){return`${" ".repeat(e+n+1)}^`}var g=class e extends Error{constructor(t){super(t);this.name="MutorError";Object.setPrototypeOf(this,e.prototype)}},I=class e extends g{constructor(t,a,o,p,f){let m=a.toString().length+2,i=`${t}
-
-`;i+=`at ${f}:${a}:${p+1}
-`,a>1&&(i+=`${(a-1).toString().padStart(m-2)} | ...
-`),i+=`${a} | ${o}
-`,i+=J(p,m);super(i);this.name="MutorCompilerError";Object.setPrototypeOf(this,e.prototype)}};var X=new Set(["for","if","else","true","false","null","undefined","end","in","of"]),F=new Set(["::","||","??","&&","**","^","|","&","!","-","%","+","*","/",">","<",">=","<=","==","!=",">>","<<",".","?.","(",")","[","]",",",":","?"]);var k=new Set(["==","!="]),q=new Set([">","<",">=","<="]);var ee=new Set(["+","-"]),te=new Set(["*","/","%"]),re=new Set([".","?.","[","::"]),ne=new Set(["-","+","!"]),oe={"&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;"},P={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}},se={JSON:{stringify(e){try{return JSON.stringify(e)}catch{throw new g("JSON.stringify failed: invalid value")}},parse(e){if(typeof e!="string")throw new g("JSON.parse expects a string");try{return JSON.parse(e)}catch{throw new g("JSON.parse failed: invalid JSON string")}}},Object:{keys(e){if(!e||typeof e!="object")throw new g("Object.keys expects an object");return Object.keys(e)},values(e){if(!e||typeof e!="object")throw new g("Object.values expects an object");return Object.values(e)},entries(e){if(!e||typeof e!="object")throw new g("Object.entries expects an object");return Object.entries(e)},hasOwn(e,n){if(!e||typeof e!="object")throw new g("Object.hasOwn expects an object");return Object.hasOwn(e,n)},freeze(e){if(!e||typeof e!="object")throw new g("Object.freeze expects an object");return Object.freeze(e)},seal(e){if(!e||typeof e!="object")throw new g("Object.seal expects an object");return Object.seal(e)},fromEntries(e){if(!Array.isArray(e))throw new g("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,n=10){return Number.parseInt(e,n)},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 g("Date.parse expects a string");return Date.parse(e)}},Boolean:{valueOf(e){return!!e}}};function W(e){return typeof e!="string"?e:/[&<>"']/.test(e)?e.replace(/[&<>"']/g,n=>oe[n]):e}function Y(e,n,t){if(t.has(e)&&!n.has(e))throw new g(`Forbidden property access. Access to this computed property "${e}" is forbidden.`);return e}var D="object",ie=Symbol("__mutor_safe_context");function G(e){if(!e||typeof e!==D||ie in e)return e;let n=new WeakSet;function t(o,p=""){if(!o||typeof o!==D||n.has(o))return o;n.add(o);let f=Object.getPrototypeOf(o);if(f&&f!==Object.prototype&&f!==Array.prototype)throw new g(`Unsafe prototype detected at ${p||"root"}`);if(Array.isArray(o)){for(let i=0;i<o.length;i++)o[i]=t(o[i],`${p}[${i}]`);return o}if(o instanceof Map){for(let[i,u]of o.entries())typeof i===D&&t(i,`${p}.mapKey`),o.set(i,t(u,`${p}.mapValue`));return o}if(o instanceof Set){let i=new Set;for(let u of o.values())i.add(t(u,p));o.clear();for(let u of i)o.add(u);return o}let m=Object.getOwnPropertyDescriptors(o);for(let i of Object.keys(m)){let u=m[i];if(u.get||u.set)throw new g(`Getter/setter not allowed: ${p}.${i}`);let E=o[i];E&&typeof E===D&&(o[i]=t(E,`${p}.${i}`))}return o}let a=t(e);return a&&typeof a===D&&Object.defineProperty(a,ie,{value:!0,enumerable:!1,writable:!1,configurable:!1}),a}function j(e){return e.replace(/\\/g,"\\\\").replace(/`/g,"\\`").replace(/\$/g,"\\$")}function L(e,n){let a=e.slice(0,n).split(`
-`).length,o=e.lastIndexOf(`
-`,n-1)+1;return{line:a,lineIndex:o}}function B(e,n,t){let a=e.indexOf(`
-`,n);return{line:e.slice(n,a===-1?void 0:a),pos:t-n}}function M(e,n){let{scope:t,forbiddenProps:a,allowedProps:o}=n;function p(s){return t.includes(s)?s:`ctx.${s}`}function f(s){switch(s.type){case 17:return"}";case 5:return s.value;case 4:return`\`${/\$/.test(s.value)?s.value.replaceAll("$","\\$"):s.value}\``;case 10:return s.true?"true":"false";case 12:return"null";case 11:return"undefined";case 7:return p(s.value);case 9:return`(${f(s.expr)})`;case 2:return`${s.operator}${f(s.expr)}`;case 0:return`${f(s.left)} ${s.operator} ${f(s.right)}`;case 1:return`${f(s.condition)} ? ${f(s.left)} : ${f(s.right)}`;case 8:return i(s);case 3:return u(s);case 6:return m(s);case 13:return E(s);case 16:return"} else {";case 14:return _(s);case 15:return b(s);default:throw new g(`Unsupported expression type: ${s.type}`)}}function m(s){if(s.left.type!==7)throw{message:"Invalid usage of namespace operator.",pos:s.pos};return`namespaces.${s.left.value}.${s.right.value}`}function i(s){let O=f(s.left);if(s.bracketNotation){let h=f(s.right),y=s.optional?"?.":"";return s.right.type===4||s.right.type===5?`${O}${y}[${h}]`:`${O}${y}[validateComputedProps(${h}, allowedProps, forbiddenProps)]`}else{let h=s.right.value,y=s.optional?"?.":".";if(a.has(h)&&!o.has(h))throw{message:"Forbidden property access.",pos:s.right.pos};return`${O}${y}${h}`}}function u(s){let O=f(s.expr),h=s.optional?"?.":"",y=s.args.map(N=>f(N)).join(", ");return`${O}${h}(${y})`}function E(s){let{iterable:O,loopType:h,variable:y}=s;return`for(const ${y} ${h===1?"in":"of"} ${M(O,n)}){`}function _(s){let{condition:O}=s;return`if(${M(O,n)}){`}function b(s){let{condition:O}=s;return`}else if(${M(O,n)}){`}return f(e)}function U(e){switch(e){case 0:return"identifier";case 1:return"keyword";case 2:return"number";case 4:return"operator";case 3:return"string"}}function Z(e,n){let t=0,a=!1;function o(r,c){let l=e[t],C=e[e.length-1];if(!l)throw{message:`Unexpected end of expression. Expected ${c?`'${c}'`:`${r===0?"an":"a"} ${U(r)}`}.`,pos:C.pos+C.value.length-1};if(l.type!==r)throw{message:`Unexpected token type. Expected ${c?`'${c}'`:U(r)} but got ${U(l.type)} instead.`,pos:l.pos};if(c!==void 0&&l.value!==c)throw{message:`Unexpected token '${l?.value}'. Expected ${r===0?"an":"a"} ${U(r)} instead.`,pos:l.pos};return e[t++]}function p(){let r=e[t-1].pos,c=o(0).value,l;try{l=o(1,"in")}catch{l=o(1,"of")}let C=l.value==="in"?1:0,$=w();return{type:13,loopType:C,iterable:$,variable:c,pos:r}}function f(){let r=w();return{condition:r,pos:r.pos,type:14}}function m(){let r=e[t-1].pos;try{return o(1,"if"),{...f(),type:15,pos:r}}catch{return{type:16,pos:r}}}function i(){let r=[];if(e[t]?.type===4&&e[t]?.value===")")return r;for(r.push(w());e[t]?.type===4&&e[t]?.value===","&&e[t]?.value!==")";)t++,r.push(w());return r}function u(){let r=e[t++];if(r?.type===2)return{type:5,value:r.value,pos:r.pos};if(r?.type===3)return{type:4,value:r.value,pos:r.pos};if(r?.type===1){if(r.value==="for"&&t===1)return p();if(r.value==="true"||r.value==="false")return{type:10,true:r.value==="true",pos:r.pos};if(r.value==="undefined")return{type:11,pos:r.pos};if(r.value==="null")return{type:12,pos:r.pos};if(r.value==="end"&&e.length===1)return{type:17,pos:r.pos};if(r.value==="if"&&t===1)return f();if(r.value==="else"&&t===1)return m()}if(r?.type===0)return{type:7,value:r.value,pos:r.pos};if(r?.type===4&&r.value==="("){let c=w();return o(4,")"),{type:9,expr:c,pos:r.pos}}if(r?.type===4&&ne.has(r.value)){let c=r.value,l=w();return{type:2,operator:c,expr:l,pos:r.pos}}throw t>e.length?{message:"Unexpected end of expression.",pos:e[e.length-1].pos}:{message:`Unexpected token '${r?.value}'.`,pos:r.pos}}function E(){let r=u();for(;e[t];){let c=e[t];if(c?.type===4&&c?.value==="("){if(t++,!a&&!n.allowFnCalls)throw{message:"Function calls are not allowed.",pos:e[t-1].pos};let l=i();o(4,")"),r={type:3,expr:r,args:l,pos:e[t-1].pos}}else if(c?.type===4&&c?.value==="?."&&e[t+1]?.type===4&&e[t+1]?.value==="("){if(t++,t++,!a&&!n.allowFnCalls)throw{message:"Function calls are not allowed.",pos:e[t-1].pos};let l=i();o(4,")"),r={type:3,expr:r,args:l,optional:!0,pos:e[t-1].pos}}else if(c?.type===4&&re.has(c?.value)){let l=c?.value==="::",C=c?.value==="[",$=c?.value==="?.";if(t++,l&&(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(l){a=!0;let R=u();r={type:6,left:r,right:R,pos:e[t-1].pos}}else if(C){let R=w();o(4,"]"),r={type:8,right:R,left:r,bracketNotation:!0,pos:e[t-1].pos}}else if($)if(e[t]?.type===4&&e[t]?.value==="["){t++;let R=w();o(4,"]"),r={type:8,left:r,right:R,bracketNotation:!0,optional:!0,pos:e[t-1].pos}}else{let R=u();r={type:8,left:r,right:R,optional:!0,pos:e[t-1].pos}}else{let R=u();r={type:8,left:r,right:R,pos:e[t-1].pos}}}else break}return a=!1,r}function _(){let r=E();for(;e[t]?.type===4&&te.has(e[t]?.value);){let c=e[t++].value,l=E();r={type:0,left:r,right:l,operator:c,pos:e[t-1].pos}}return r}function b(){let r=_();for(;e[t]?.type===4&&ee.has(e[t]?.value);){let c=e[t++].value,l=_();r={type:0,left:r,right:l,operator:c,pos:e[t-1].pos}}return r}function s(){let r=b();for(;e[t]?.type===4&&q.has(e[t]?.value);){let c=e[t++].value,l=b();r={type:0,left:r,right:l,operator:c,pos:e[t-1].pos}}return r}function O(){let r=s();for(;e[t]?.type===4&&q.has(e[t]?.value);){let c=e[t++].value,l=s();r={type:0,left:r,right:l,operator:c,pos:e[t-1].pos}}return r}function h(){let r=O();for(;e[t]?.type===4&&k.has(e[t]?.value);){let c=e[t++].value,l=O();r={type:0,left:r,right:l,operator:c,pos:e[t-1].pos}}return r}function y(){let r=N();for(;e[t]?.type===4&&e[t]?.value==="||";){let c=e[t++].value,l=N();r={type:0,left:r,right:l,operator:c,pos:e[t-1].pos}}return r}function N(){let r=T();for(;e[t]?.type===4&&e[t]?.value==="&&";){let c=e[t++].value,l=T();r={type:0,left:r,right:l,operator:c,pos:e[t-1].pos}}return r}function T(){let r=h();for(;e[t]?.type===4&&e[t]?.value==="??";){let c=e[t++].value,l=h();r={type:0,left:r,right:l,operator:c,pos:e[t-1].pos}}return r}function w(){let r=y();if(e[t]?.type!==4||e[t]?.value!=="?")return r;t++;let c=w();o(4,":");let l=w();return{type:1,left:c,right:l,condition:r,pos:e[t-1].pos}}return w()}function V(e,{delimiters:n}){let t=`${n.openingTag}${n.whitespaceTrim}`,a=`${n.whitespaceTrim}${n.closingTag}`,o=e.startsWith(t),p=e.endsWith(a),f=e.startsWith(o?t+n.commentTag:n.openingTag+n.commentTag);if(f)return{isComment:f,leftTrim:o,rightTrim:p};let m=e.slice(o?t.length:n.openingTag.length,e.length-(p?a.length:n.closingTag.length)),i=m.trim(),u=i.startsWith("for")||i.startsWith("if")||i.startsWith("else"),E=i.startsWith("for")||i.startsWith("if"),_=i==="end",b=i.startsWith("for");return{leftTrim:o,rightTrim:p,inner:m,isBlock:u,isBlockEnd:_,hasContext:b,requiresBlockClose:E}}function H(e){let n=0,t="",a=[];function o(){let i="";if(/[a-zA-Z$_]/.test(t)){let u=n;for(;/[a-zA-Z$_0-9]/.test(e[u])&&u<e.length;)i+=e[u],u++;a.push({type:X.has(i)?1:0,value:i,pos:n}),n=u,t=e[n]}}function p(){let i="";if(t==='"'||t==="'"||t==="`"){let u=n+1;for(;e[u]!==t&&u<e.length;)i+=e[u],u++;if(u>e.length)throw{pos:n,message:"Found string without closing quote."};a.push({type:3,value:i,pos:n}),n=u}}function f(){if(/[0-9]/.test(t)){let i=n,u="";for(;/[0-9.oxe]/.test(e[i])&&i<e.length;)u+=e[i],i++;let E=Number(u);if(Number.isNaN(E))throw{pos:n,message:"Found invalid number literal."};a.push({type:2,value:`${E}`,pos:n}),n=i-1,t=e[n]}}function m(){let i=`${t}${e[n+1]}`;if(F.has(i)){a.push({type:4,value:i,pos:n}),n++;return}if(F.has(t)){a.push({type:4,value:t,pos:n});return}}for(;n<e.length;){if(t=e[n],f(),o(),p(),m(),!/[a-zA-Z$_0-9\s\t\r\n'"`]/.test(t)&&!F.has(t)&&!F.has(e[n-1]+t))throw{message:`Unexpected token '${t}' in expression.`,pos:n};n++}return a}function Q(e,n,t){let a=[],o=[],{delimiters:p,keepOpeningTagEscapeDelimiter:f,allowFnCalls:m,allowedProps:i,forbiddenProps:u,autoEscape:E}=n,_=!1,b=0,s='let acc="";';for(;b<e.length;){let y=function(){let d=h,S=0;for(;d>=p.openingTagEscape.length&&e.slice(d-p.openingTagEscape.length,d)===p.openingTagEscape;)S++,d-=p.openingTagEscape.length;return S%2===1};var O=y;let h=e.indexOf(p.openingTag,b);if(h===-1){let d=e.slice(b);_&&(d=d.trimStart()),d&&(s+=`acc+=\`${j(d)}\`;`);break}if(y()){let d=e.slice(b,f?h+p.openingTagEscape.length+1:h-p.openingTag.length+1);_&&(d=d.trimStart(),_=!1),s+=`acc+=\`${j(d)}\`;`,f||(s+=`acc+=\`${p.openingTag}\`;`),b=h+p.openingTag.length;continue}let N=e.indexOf(p.closingTag,h);if(N===-1){let{line:d,lineIndex:S}=L(e,h),{line:A,pos:v}=B(e,S,h);throw new I("No closing tag found.",d,A,v,t.path)}let T=e.slice(h,N+p.closingTag.length),{inner:w,leftTrim:K,rightTrim:r,isBlock:c,isBlockEnd:l,hasContext:C,requiresBlockClose:$,isComment:R}=V(T,{delimiters:p}),x=e.slice(b,h);x&&(_&&(x=x.trimStart()),K&&(x=x.trimEnd()),x&&(s+=`acc+=\`${j(x)}\`;`)),_=!1,b=N+p.closingTag.length;try{if(!R){let d=H(w),S=Z(d,{allowFnCalls:m});if(c&&$&&C?(a.push(S.variable),o.push({type:0,pos:h})):c&&$&&!C&&o.push({type:1,pos:h}),l){let v=o.pop();if(v?.type===0&&a.pop(),v===void 0)throw{message:"Unexpected end of block",pos:h}}let A=M(S,{allowedProps:i,forbiddenProps:u,scope:a});c||l?s+=A:s+=E&&!A.startsWith("namespaces.Mutor.include")?`acc+=escapeFn(${A});`:`acc+=${A};`}r&&(_=!0)}catch(d){let{message:S,pos:A}=d,{line:v,lineIndex:ce}=L(e,h),{line:pe,pos:le}=B(e,ce,h);throw new I(S,v,pe,le+A+(K?p.openingTag.length+p.whitespaceTrim.length:p.openingTag.length),t.path)}}if(o.length){let h=o.pop()?.pos,{line:y,lineIndex:N}=L(e,h),{line:T,pos:w}=B(e,N,h);throw new I("Unclosed block detected.",y,T,w+p.openingTag.length,t.path)}return s+="return acc;",new Function("ctx","namespaces","allowedProps","forbiddenProps","escapeFn","validateComputedProps",s)}var z=class{constructor(n={}){this.__currentRenderedPath="";this.__includeStack=new Set;this.__cacheSize=0;this.__config={...P};this.__compiledTemplatesMap=new Map;this.__currentContext=null;this.__namespaces={...se,Mutor:{include:(n,t)=>{if(this.__includeStack.has(n))throw new g(`Circular include detected:
-${Array.from(this.__includeStack).join(`
-`)}
-${n}`);try{return this.__includeStack.add(n),this.renderComponent(n,t??this.__currentContext)}finally{this.__includeStack.delete(n)}}}};this.addConfig(n),Object.defineProperty(this.__namespaces.Mutor,"$$context",{get:()=>this.__currentContext})}addConfig(n){let{autoEscape:t,delimiters:a,allowedProps:o,forbiddenProps:p,keepOpeningTagEscapeDelimiter:f,allowFnCalls:m,cache:i,build:u}=n;return this.__config={build:{include:new Set([...u?.include||P.build.include]),exclude:new Set([...P.build.exclude,...u?.exclude||[]])},autoEscape:t===!0?!0:t!==!1,allowedProps:o||P.allowedProps,allowFnCalls:!!m,cache:{...P.cache,...i||{}},forbiddenProps:new Set([...P.forbiddenProps,...p||[]]),keepOpeningTagEscapeDelimiter:f===!0?!0:f!==!1,delimiters:{...P.delimiters,...a||{}}},this.__config}restoreDefaultConfig(){this.__config={...P}}compile(n){return Q(n,this.__config,{path:this.__currentRenderedPath||"anonymous"})}render(n,t){let a=this.__currentContext;a!==t&&(this.__currentContext=t);let o=this.compile(n)(G(t),this.__namespaces,this.__config.allowedProps,this.__config.forbiddenProps,W,Y);return this.__currentContext=a,o}renderComponent(n,t){if(!this.__compiledTemplatesMap.has(n))throw new g(`No template exists with the identifier '${n}'`);let a=this.__currentRenderedPath,o=this.__currentContext,p=this.__compiledTemplatesMap.get(n);this.__currentContext=t,this.__currentRenderedPath=n;let f=p.fn(G(t),this.__namespaces,this.__config.allowedProps,this.__config.forbiddenProps,W,Y);return this.__currentContext=o,this.__currentRenderedPath=a,f}registerComponent(n,t){let a=t.length*2+500;if(this.__cacheSize+a>this.__config.cache.maxSize&&!this.createEntrySpaceForTemplate(a))throw new g(`The template for the component '${n}' is too large. Consider increasing 'cache.maxSize' in the config`);this.__cacheSize+=t.length*2+500,this.__compiledTemplatesMap.set(n,{fn:this.compile(t),size:a})}reset(){this.__config={...P},this.__compiledTemplatesMap.clear(),this.__currentContext=null,this.__cacheSize=0}createEntrySpaceForTemplate(n){if(this.__cacheSize+n<this.__config.cache.maxSize)return!0;if(n>this.__config.cache.maxSize)return!1;let t=this.__compiledTemplatesMap.entries().next().value;if(t){let[a,o]=t;this.__compiledTemplatesMap.delete(a),this.__cacheSize-=o.size}return this.createEntrySpaceForTemplate(n)}getDiagnostics(){let n=this.__config.cache.maxSize;return{bytesUsed:this.__cacheSize,bytesMax:n,readableUsed:`${(this.__cacheSize/1024/1024).toFixed(2)} MB`,readableMax:`${(n/1024/1024).toFixed(2)} MB`,totalEntries:this.__compiledTemplatesMap.size,percentFull:n>0?Math.min(100,Math.round(this.__cacheSize/n*100)):0,avgTemplateSize:this.__compiledTemplatesMap.size>0?Math.round(this.__cacheSize/this.__compiledTemplatesMap.size):0}}};var it=z;export{it as default};
+// 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/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/index.ts
+var index_default = Mutor;
+export {
+  index_default as default
+};
 //# sourceMappingURL=index.js.map