@shd101wyy/yo 0.0.2

package/out/esm/index.mjs

@@ -0,0 +1,51 @@
+import{readFileSync as da}from"node:fs";import Ta from"path";var v=class{constructor({characterIndex:n,message:t}){this.characterIndex=n,this.message=t}},q=class{constructor(n,t){this.tokenAndErrorList=[];this.tokenAndErrorList=n,this.isAssertionError=t||!1}toString(){return this.tokenAndErrorList.map(({token:t,errorMessage:o})=>`Error: ${o}
+${be({token:t})}`).join(`
+
+`)}};function be({token:e}){let{position:n,modulePath:t,inputString:o}=e,{row:i,column:r}=n,l=o.split(`
+`)[i];return`${t}:${i+1}:${r+1}:
+${l}
+${" ".repeat(r+Math.floor(e.value.length/2))}^`}function y({token:e,errorMessage:n,cause:t,isAssertionError:o}){let i=`${n.trim()}
+
+${be({token:e})}`;return new q([{token:e,errorMessage:i+(t?.message?`
+`+t.message:"")}],o)}var z=(m=>(m.Operator="operator",m.Dot=".",m.LParen="(",m.RParen=")",m.LBracket="[",m.RBracket="]",m.LCurlyBracket="{",m.RCurlyBracket="}",m.Char="char",m.String="string",m.Identifier="identifier",m.Integer="integer",m.Float="float",m.Bool="bool",m.Semicolon=";",m.Comma=",",m.SingleLineComment="single_line_comment",m.MultiLineComment="multi_line_comment",m.Whitespace="whitespace",m.BacktickIdentifier="backtick_identifier",m))(z||{}),G={modulePath:"_",inputString:"_",type:"identifier",value:"_",position:{row:0,column:0,character:0}},ht={modulePath:"drop",inputString:"drop",type:"identifier",value:"drop",position:{row:0,column:0,character:0}},oe=["=","+","-","*","/","<",">","@","$","~","&","%","|","!","?","^",".",":","\\","#"];function P(e){return oe.includes(e)}function Ce(e){let n=!0;for(let t=0;t<e.length;t++){let o=e[t];if(!P(o)){n=!1;break}}return n}var j=/^[_a-zA-Z\xA0-\uFFFF][_a-zA-Z0-9\xA0-\uFFFF]*[!?]?$/;function Ve(e,n){let t=")";if(!e[n])return-1;let o=e[n].type;if(o==="{")t="}";else if(o==="(")t=")";else if(o==="[")t="]";else throw this.formatErrorMessage(e[n],"Expected '{', '(' or '['");n=n+1;let i=1,r=-1;for(;;){let p=e[n];if(!p)return-1;if(p.type===t){if(i=i-1,i===0){r=n;break}}else p.type===o&&(i=i+1);n=n+1}return r}function Fe(e,n){let t=[],o=0,i=0;for(let r=0;r<e.length;r++){let p=e[r],l=r-i,f=r,c="",u=r;if(e[u]===".")for(;e[u]===".";)c+=e[u],u=u+1;else for(;P(e[u])&&e[u]!==".";)c+=e[u],u=u+1;if(c&&!c.startsWith("//")&&!c.startsWith("/*")){t.push({type:c==="."?".":"operator",value:c,position:{row:o,column:l,character:f},modulePath:n,inputString:e}),r=u-1;continue}switch(p){case" ":case"	":case`
+`:case"\r":{let s="",a=r,d=o;for(;e[a]===" "||e[a]==="	"||e[a]===`
+`||e[a]==="\r";)s+=e[a],e[a]===`
+`&&(o++,i=a+1),a=a+1;t.push({type:"whitespace",value:s,position:{row:d,column:l,character:f},modulePath:n,inputString:e}),r=a-1;break}case"/":if(e[r+1]==="/"){let s="",a=r;for(;e[a]!==`
+`&&a<e.length;)s+=e[a],a=a+1;t.push({type:"single_line_comment",value:s,position:{row:o,column:l,character:f},modulePath:n,inputString:e}),r=a-1}else if(e[r+1]==="*"){let s=r,a="",d=o,V=1;for(a+=e[s],s++,a+=e[s],s++;V>0&&s<e.length;){if(e[s]===`
+`&&(i=s+1,o++),e[s]==="/"&&e[s+1]==="*"){V++,a+="/*",s+=2;continue}if(e[s]==="*"&&e[s+1]==="/"){V--,a+="*/",s+=2;continue}a+=e[s],s++}if(V>0)throw new v({message:"Unterminated multi-line comment",characterIndex:e.length-1});t.push({type:"multi_line_comment",value:a,position:{row:d,column:l,character:f},modulePath:n,inputString:e}),r=s-1}else throw new v({message:`Unexpected character ${p}`,characterIndex:r+1});break;case"(":t.push({type:"(",value:p,position:{row:o,column:l,character:f},modulePath:n,inputString:e});break;case")":t.push({type:")",value:p,position:{row:o,column:l,character:f},modulePath:n,inputString:e});break;case"[":t.push({type:"[",value:p,position:{row:o,column:l,character:f},modulePath:n,inputString:e});break;case"]":t.push({type:"]",value:p,position:{row:o,column:l,character:f},modulePath:n,inputString:e});break;case"{":t.push({type:"{",value:p,position:{row:o,column:l,character:f},modulePath:n,inputString:e});break;case"}":t.push({type:"}",value:p,position:{row:o,column:l,character:f},modulePath:n,inputString:e});break;case"'":{let s="";for(let a=r+1;a<e.length;a++){if(e[a]==="\\"){s+=e[a],a=a+1,s+=e[a];continue}if(e[a]==="'"){r=a;break}s+=e[a]}if(s.length===1||s.length===2&&s[0]==="\\")t.push({type:"char",value:`'${s}'`,position:{row:o,column:l,character:f},modulePath:n,inputString:e});else throw new v({message:`Invalid char '${s}', expected char to have length 1.`,characterIndex:r});break}case'"':{let s="";for(let a=r+1;a<e.length;a++){if(e[a]==="\\"){s+=e[a],a=a+1,s+=e[a];continue}if(e[a]==='"'){r=a;break}s+=e[a]}t.push({type:"string",value:`"${s}"`,position:{row:o,column:l,character:f},modulePath:n,inputString:e});break}case"`":{let s="";for(let a=r+1;a<e.length;a++){if(e[a]==="\\"){s+=e[a],a=a+1,s+=e[a];continue}if(e[a]==="`"){r=a;break}s+=e[a]}if(!j.test(s))throw new v({message:`Invalid backtick identifier \`${s}\``,characterIndex:r});t.push({type:"backtick_identifier",value:`\`${s}\``,position:{row:o,column:l,character:f},modulePath:n,inputString:e});break}case",":t.push({type:",",value:p,position:{row:o,column:l,character:f},modulePath:n,inputString:e});break;case";":t.push({type:";",value:p,position:{row:o,column:l,character:f},modulePath:n,inputString:e});break;default:if(/[0-9]/.test(p)){let s=r,a=p;r=r+1;let d=/[0-9_]/;for(e[r-1]==="0"&&typeof e[r]=="string"&&(e[r]==="x"||e[r]==="X"?(a+=e[r],r=r+1,d=/[0-9A-Fa-f]/):e[r]==="b"||e[r]==="B"?(a+=e[r],r=r+1,d=/[01]/):(e[r]==="o"||e[r]==="O")&&(a+=e[r],r=r+1,d=/[0-7]/));typeof e[r]=="string"&&d.test(e[r]);)a+=e[r],r=r+1;if(e[r]==="."&&e[s-1]!=="."&&(e[r+1]??"").match(/[0-9]/)){for(a+=e[r],r=r+1;typeof e[r]=="string"&&/[0-9_]/.test(e[r]);)a+=e[r],r=r+1;if((e[r]==="e"||e[r]==="E")&&typeof e[r+1]=="string"&&(e[r+1]==="+"||e[r+1]==="-"||/[0-9]/.test(e[r+1])))for(a+=e[r],r=r+1,(e[r]==="+"||e[r]==="-")&&(a+=e[r],r=r+1);typeof e[r]=="string"&&/[0-9_]/.test(e[r]);)a+=e[r],r=r+1;t.push({type:"float",value:a,position:{row:o,column:l,character:f},modulePath:n,inputString:e}),r=r-1}else{if((e[r]==="e"||e[r]==="E")&&typeof e[r+1]=="string"&&(e[r+1]==="+"||e[r+1]==="-"||/[0-9]/.test(e[r+1])))for(a+=e[r],r=r+1,(e[r]==="+"||e[r]==="-")&&(a+=e[r],r=r+1);typeof e[r]=="string"&&/[0-9_]/.test(e[r]);)a+=e[r],r=r+1;t.push({type:"integer",value:a,position:{row:o,column:l,character:f},modulePath:n,inputString:e}),r=r-1}}else if(/[_a-zA-Z\xA0-\uFFFF]/.test(p)){let s=p,a=r;for(r=r+1;typeof e[r]=="string"&&/[_a-zA-Z0-9\xA0-\uFFFF]/.test(e[r]);)s+=e[r],r=r+1;if(r=r-1,(e[r+1]==="!"||e[r+1]==="?")&&j.test(s+e[r+1])&&(r=r+1,s+=e[r]),j.test(s))switch(s){case"true":case"false":t.push({type:"bool",value:s,position:{row:o,column:l,character:f},modulePath:n,inputString:e});break;default:t.push({type:"identifier",value:s,position:{row:o,column:l,character:f},modulePath:n,inputString:e});break}else throw new v({message:`Invalid identifier ${s}`,characterIndex:a})}else throw new v({message:`Unexpected character ${p}`,characterIndex:r});break}}return t}var L=class{constructor({modulePath:n,inputString:t}){this.modulePath=n,this.inputString=t,this.tokens=Fe(t,n),this.program=[],this.parse(this.tokens)}skipWhitespace(n,t){for(;n[t]&&(n[t].type==="whitespace"||n[t].type==="single_line_comment"||n[t].type==="multi_line_comment");)t=t+1;return t}skipWhitespaceBackward(n,t){for(;n[t]&&(n[t].type==="whitespace"||n[t].type==="single_line_comment"||n[t].type==="multi_line_comment");)t=t-1;return t}isParenthesizedExpression(n,t,o){return t=this.skipWhitespace(n,t),o=this.skipWhitespaceBackward(n,o),!!n[t]&&n[t].type==="("&&!!n[o]&&n[o].type===")"&&Ve(n,t)===o}parseParenExpr({tokens:n,index:t}){let o=t;if(n[t].type!=="(")throw y({token:n[t],errorMessage:"Expected left paren"});if(n[t+1]?.type===")")return{expr:{tag:"FuncCall",func:{tag:"Atom",token:{type:"identifier",value:_.tuple,position:n[t].position,modulePath:this.modulePath,inputString:this.inputString}},args:[],token:n[t]},index:t+2};let i=this.parseExpression({tokens:n,index:t+1}),r=i.expr;if(t=i.index,n[t].type===")")return{expr:r,index:t+1};{let p,l=[r];for(;;){if(!n[t])throw y({token:n[t-1],errorMessage:"Expected ) or , for tuple"});if(n[t].type===","){if(!p||p===",")p=",";else throw y({token:n[t],errorMessage:'Cannot mix "," with ";" as separator in (...)'});t=t+1}else if(n[t].type===";"){if(!p||p===";")p=";";else throw y({token:n[t],errorMessage:'Cannot mix ";" with "," as separator in (...)'});t=t+1}if(t=this.skipWhitespace(n,t),n[t].type===")")break;let{expr:c,index:u}=this.parseExpression({tokens:n,index:t});l.push(c),t=u}let f=p===";"||!p;return{expr:{tag:"FuncCall",func:{tag:"Atom",token:{type:"identifier",value:f?_.Tuple[0]:_.tuple,position:n[o].position,modulePath:this.modulePath,inputString:this.inputString}},args:l,token:n[o]},index:t+1}}}parseArrayExpr({tokens:n,index:t}){let o=t;if(n[t].type!=="[")throw y({token:n[t],errorMessage:"Expected left bracket"});t=t+1;let i,r=[];for(;;){if(!n[t])throw y({token:n[t-1],errorMessage:"Expected ] or , for array"});if(n[t].type===","){if(!i||i===",")i=",";else throw y({token:n[t],errorMessage:'Cannot mix "," with ";" as separator in [...]'});t=t+1}else if(n[t].type===";"){if(!i||i===";")i=";";else throw y({token:n[t],errorMessage:'Cannot mix ";" with "," as separator in [...]'});t=t+1}if(n[t].type==="]")break;let{expr:c,index:u}=this.parseExpression({tokens:n,index:t});r.push(c),t=u}let p=i===";"||!i;if(p&&r.length>2)throw y({token:n[o],errorMessage:`Expected at 2 arguments for Array type, or 1 argument for Slice type, got ${r.length}`});let l=p&&r.length===2,f=p&&r.length===1;return{expr:{tag:"FuncCall",func:{tag:"Atom",token:{type:"identifier",value:l?_.Array[0]:f?_.Slice[0]:_.array,position:n[o].position,modulePath:this.modulePath,inputString:this.inputString}},args:r,token:n[o]},index:t+1}}parseCurlyBracketExpr({tokens:n,index:t}){let o=t;if(n[t].type!=="{")throw y({token:n[t],errorMessage:"Expected left curly bracket"});let i=[],r;for(t=t+1;;){if(t=this.skipWhitespace(n,t),!n[t])throw y({token:n[t-1],errorMessage:'Unexpected end of curly bracket. Expected "}" or "," or ";"'});if(n[t].type===","){if(!r||r===",")r=",";else throw y({token:n[t],errorMessage:'Cannot mix "," with ";" as separator in {...}'});t=t+1}else if(n[t].type===";"){if(!r||r===";")r=";";else throw y({token:n[t],errorMessage:'Cannot mix ";" with "," as separator in {...}'});t=t+1}if(t=this.skipWhitespace(n,t),n[t].type==="}"){let f=n[this.skipWhitespaceBackward(n,t-1)];if(r===";"&&f&&(f.type===";"||f.type==="{")){let c={type:"identifier",value:_.tuple,position:f.position,modulePath:this.modulePath,inputString:this.inputString};i.push({tag:"FuncCall",func:{tag:"Atom",token:c},args:[],token:c})}break}let{expr:p,index:l}=this.parseExpression({tokens:n,index:t});i.push(p),t=l}if(r===","||!r){for(let l=0;l<i.length;l++){let f=i[l];if(F(f)){let c={type:"operator",value:":",position:n[o].position,modulePath:this.modulePath,inputString:this.inputString},u={tag:"FuncCall",func:{tag:"Atom",token:c},isInfix:!0,args:[f,f],token:c};i[l]=u}}return{expr:{tag:"FuncCall",func:{tag:"Atom",token:{type:"identifier",value:"_",position:n[o].position,modulePath:this.modulePath,inputString:this.inputString}},args:i,token:n[o]},index:t+1}}else return{expr:{tag:"FuncCall",func:{tag:"Atom",token:{type:"identifier",value:_.begin[0],position:n[o].position,modulePath:this.modulePath,inputString:this.inputString}},args:i,token:n[o]},index:t+1}}parsePrimary({tokens:n,index:t}){t=this.skipWhitespace(n,t);let o=n[t];if(!o)throw y({token:G,errorMessage:"Unexpected end of input"});let i=null;switch(o.type){case"identifier":case"operator":case"bool":case"integer":case"float":case"string":case"char":{i={expr:{tag:"Atom",token:o},index:t+1};break}case"(":{i=this.parseParenExpr({tokens:n,index:t});break}case"[":{i=this.parseArrayExpr({tokens:n,index:t});break}case"{":{i=this.parseCurlyBracketExpr({tokens:n,index:t});break}case".":{i={expr:{tag:"Atom",token:o},index:t+1};break}default:throw y({token:o,errorMessage:`Unexpected token "${o.type}"`})}return i}isOperatorAtLineStart(n,t){for(let o=n.length-1;o>=0;o--){let i=n[o];if(i.type==="whitespace"&&i.value.includes(`
+`))return n.slice(o+1).every(l=>l.type==="whitespace");if(i.type!=="whitespace")return!1}return n.every(o=>o.type==="whitespace")}parseLeftAssociativeOperator({primaryExpr:n,operatorToken:t,rhs:o,tokens:i,index:r}){if(o.tag==="FuncCall"&&o.isInfix&&o.func.tag==="Atom"&&o.func.token.type!=="."){let p=o.args[0],l=o.args[1],f=o.func,c={tag:"FuncCall",func:{tag:"Atom",token:t},args:[n,p],isInfix:!0,token:t};return this.parsePrimaryEnd({primaryExpr:{tag:"FuncCall",func:f,args:[c,l],isInfix:!0,token:f.token},tokens:i,index:r})}else return this.parsePrimaryEnd({primaryExpr:{tag:"FuncCall",func:{tag:"Atom",token:t},args:[n,o],isInfix:!0,token:t},tokens:i,index:r})}getExprMinimumColumnNumber(n){return F(n)?n.token.position.column:Math.min(this.getExprMinimumColumnNumber(n.func),...n.args.map(t=>this.getExprMinimumColumnNumber(t)))}parsePrimaryEnd({primaryExpr:n,tokens:t,index:o}){let i=this.skipWhitespace(t,o),r=i!==o,p=t[o-1]?.type==="whitespace";o=i;let l=t[i];if(!l||l.type===";"||l.type===","||l.type===")"||l.type==="]"||l.type==="}")return{expr:n,index:o};let f=n.tag==="Atom"&&n.token.type===".";if(f||l.type==="."&&!r&&!p&&t[i+1]?.type!=="whitespace"){let{expr:c,index:u}=this.parsePrimary({tokens:t,index:f?o:o+1});o=u;let s={expr:{tag:"FuncCall",func:{tag:"Atom",token:f?n.token:l},args:f?[c]:[n,c],isInfix:!f,token:f?n.token:l},index:o};for(;t[o]&&t[o].type===".";){let{expr:a,index:d}=this.parsePrimary({tokens:t,index:o+1});s={expr:{tag:"FuncCall",func:{tag:"Atom",token:l},args:[s.expr,a],isInfix:!0,token:l},index:d},o=d}return this.parsePrimaryEnd({primaryExpr:s.expr,tokens:t,index:s.index})}else if((l.type==="operator"||l.type==="."&&!r||l.type==="backtick_identifier")&&t[o+1]?.type!=="("){let c=this.skipWhitespace(t,o+1),{expr:u,index:s}=this.parseExpression({tokens:t,index:c});if(u.tag==="FuncCall"&&u.isInfix&&u.func.tag==="Atom"&&u.func.token.type!=="."&&!this.isParenthesizedExpression(t,c,s-1)){let a=`Ambiguous operator precedence. 
+Please use parentheses to clarify:
+
+${g(n)} ${l.value} (${g(u)})
+// or
+(${g(n)} ${l.value} ${g(u.args[0])}) ${g(u.func)} ${g(u.args[1])}
+
+Or use newline after "${l.value}" to confirm the right-associativity.
+`,V=t.slice(o+1,c).some(Ee=>Ee.type==="whitespace"&&Ee.value.includes(`
+`)),re=t.slice(0,o),x=this.isOperatorAtLineStart(re,o),U=t.slice(o+1,c),De=x&&U.length>0&&U[0]?.type==="whitespace"&&U[0]?.value.includes(`
+`);if(!(V&&!x)){if(!De){if(x)return this.parseLeftAssociativeOperator({primaryExpr:n,operatorToken:l,rhs:u,tokens:t,index:s});throw y({token:l,errorMessage:a})}}}return this.parsePrimaryEnd({primaryExpr:{tag:"FuncCall",func:{tag:"Atom",token:l},args:[n,u],isInfix:!0,token:l},tokens:t,index:s})}else if(!r&&l.type==="("){let c=this.parseFunctionCall({func:n,tokens:t,index:o+1,hasWhitespace:!1});return this.parsePrimaryEnd({primaryExpr:c.expr,tokens:t,index:c.index})}else{let c=this.parseFunctionCall({func:n,tokens:t,index:o,hasWhitespace:!0});return this.parsePrimaryEnd({primaryExpr:c.expr,tokens:t,index:c.index})}}parseFunctionArguments({tokens:n,index:t,hasWhitespace:o}){let i=[];if(t=this.skipWhitespace(n,t),!o&&n[t]?.type===")")return{args:i,index:t+1};for(;;){let{expr:r,index:p}=this.parseExpression({tokens:n,index:t});i.push(r),t=p;let l=n[t];if(l?.type===",")t=t+1;else{if(!l||l.type===";"||l.type==="]"||l.type==="}")return{args:i,index:t};if(l.type===")")return{args:i,index:o?t:t+1};throw y({token:l,errorMessage:o?"Expected ; to end the function call":`Expected , to separate arguments
+or ) to end the function call`})}}}parseFunctionCall({func:n,tokens:t,index:o,hasWhitespace:i}){let{args:r,index:p}=this.parseFunctionArguments({tokens:t,index:o,hasWhitespace:i});return o=p,{expr:{tag:"FuncCall",func:n,args:r,token:n.token},index:o}}parseExpression({tokens:n,index:t}){t=this.skipWhitespace(n,t);let{expr:o,index:i}=this.parsePrimary({tokens:n,index:t});return this.parsePrimaryEnd({primaryExpr:o,tokens:n,index:i})}programToString(){return this.program.map(t=>g(t)).join(`;
+`)}parse(n){let t=0,o=[];for(;t<n.length;){switch(n[t].type){case"whitespace":case";":case"single_line_comment":case"multi_line_comment":{t=t+1;continue}}if(t>=n.length)break;try{let{expr:p,index:l}=this.parseExpression({tokens:n,index:t});o.push(p),t=l}catch(p){this.parserError=p;break}}let i=n[this.skipWhitespaceBackward(n,n.length-1)];if(i&&i.type===";"){let r={type:"identifier",value:_.tuple,position:i.position,modulePath:this.modulePath,inputString:this.inputString};o.push({tag:"FuncCall",func:{tag:"Atom",token:r},args:[],token:r})}this.program=o}getProgram(){return this.program}getParserError(){return this.parserError}getTokens(){return this.tokens}};function ie(e){let n=new L({modulePath:`auto-generated://
+// === START auto-generated code ===
+${e}
+// === END auto-generated code ===
+`,inputString:e});if(n.getParserError())throw n.getParserError();let t=n.getProgram();if(t.length!==1)throw new Error(`Expected exactly one expression from parsed code, got ${t.length}: "${e}"
+${t.map(o=>g(o)).join(`
+`)}      
+`);return t[0]}import{createHash as Ye}from"crypto";var Qe=0;function Ae(){return`id${Qe++}`}function Je(e){return"yo"+Ye("sha1").update(e).digest("hex").slice(0,8)}var Ie=new Map;function ce(e,n){let t="";for(let r=0;r<n.length;r++)if(P(n[r])){let p=oe.indexOf(n[r]);t+=`${p}`}else t+=n[r];let o=Je(e)+"_"+t,i=Ie.get(o);return i===void 0?i=0:i++,Ie.set(o,i),o+(i==0?"":`_${i}`)}var fe=null;function Ue(){if(fe)return fe;let e=Pe(),n=ze(e),t={id:"unit",tag:"unit",module:n};return n.receiverType=t,fe=t,t}function ze(e){return{id:`module_${Ae()}`,tag:"Module",fields:[],env:e,module:void 0}}function k(e){return e?.tag==="FuncCall"}function F(e){return e?.tag==="Atom"}function w(e){return e.tag==="Atom"&&e.token.type==="operator"}function A(e,n,t){if(e.tag!=="FuncCall"||e.func.tag!=="Atom")return!1;let o=e.func.token.value;return e.func.token.type==="backtick_identifier"&&(o=o.slice(1,-1)),e.tag==="FuncCall"&&e.func.tag==="Atom"&&(typeof n=="string"?o===n:n.includes(o))&&(t===void 0||e.args.length===t)}var _={compt:["compt"],ref:["ref"],forall:["forall","\u2200"],where:["where"],quote:["quote",":"],unquote:["unquote","#"],unquote_splicing:["unquote_splicing","...#"],return:["return"],recur:["recur"],fn:["fn"],unsafe_fn:["unsafe_fn"],extern:["extern"],cond:["cond"],type:["type"],match:["match"],test:["test"],struct:["struct"],object:["object"],newtype:["newtype"],enum:["enum"],union:["union"],module:["module"],impl:["impl"],Impl:["Impl"],begin:["begin"],module_begin:["module_begin"],import:["import"],export:["export"],open:["open"],clone:["clone","%"],break:["break"],continue:["continue"],while:["while"],if:["if"],op_and:["&&"],op_or:["||"],not:["not"],gensym:["gensym"],dyn:["dyn"],Dyn:["Dyn"],Fn:["Fn"],c_include:["c_include"],undefined:["undefined"],null:["null"],true:["true"],false:["false"],unique:["unique","^"],Ptr:["*"],Iso:["Iso"],Tuple:["Tuple"],Array:["Array"],Slice:["Slice"],Future:["Future"],Concrete:["Concrete"],Type:["Type"],Module:["Module"],ComptList:["ComptList"],tuple:"tuple",array:"array",compt_list:"compt_list"};function I(e){return!!(e.tag==="FuncCall"&&e.isInfix&&e.func.tag==="Atom"&&(e.func.token.type==="operator"||e.func.token.type==="backtick_identifier")&&e.args.length===2)}function g(e,n){let o={...{prettyPrint:!1,indentSize:2,maxLineLength:80,indentLevel:0},...n};return o.prettyPrint?T(e,o):h(e)}function h(e){let n="";switch(e.tag){case"Atom":{n=e.token.value;break}case"FuncCall":{if(e.func.tag==="Atom"&&(e.func.token.type==="operator"||e.func.token.type==="."||e.func.token.type==="backtick_identifier")){if(e.args.length===1){e.func.token.value==="."?n=`${e.func.token.value}${h(e.args[0])}`:n=`${e.func.token.value}(${h(e.args[0])})`;break}else if(e.args.length===2&&e.isInfix){let i=h(e.args[0]),r=h(e.args[1]);i=I(e.args[0])||w(e.args[0])?`(${i})`:i,r=I(e.args[1])||w(e.args[1])?`(${r})`:r,e.func.token.value==="."?n=`(${i}.${r})`:n=`${i} ${e.func.token.value} ${r}`;break}}if(e.func.tag==="Atom"&&e.func.token.type==="identifier"&&e.func.token.value===_.tuple){e.args.length===1?n=`(${h(e.args[0])},)`:n=`(${e.args.map(i=>h(i)).join(", ").trim()})`;break}let t=h(e.func);t=I(e.func)||w(e.func)?`(${t})`:t;let o=e.args.map(i=>h(i)).join(", ").trim();n=`${t}(${o})`;break}}return n}function T(e,n){let t=" ".repeat(n.indentLevel*n.indentSize),o={...n,indentLevel:n.indentLevel+1},i=" ".repeat(o.indentLevel*n.indentSize);switch(e.tag){case"Atom":return e.token.value;case"FuncCall":{if(e.func.tag==="Atom"&&(e.func.token.type==="operator"||e.func.token.type==="."||e.func.token.type==="backtick_identifier")){if(e.args.length===1){if(e.func.token.value===".")return`${e.func.token.value}${T(e.args[0],n)}`;{let c=T(e.args[0],n);return`${e.func.token.value}(${c})`}}else if(e.args.length===2&&e.isInfix){let c=T(e.args[0],n),u=T(e.args[1],n);return c=I(e.args[0])||w(e.args[0])?`(${c})`:c,u=I(e.args[1])||w(e.args[1])?`(${u})`:u,e.func.token.value==="."?`(${c}.${u})`:`${c} ${e.func.token.value} ${u}`}}if(e.func.tag==="Atom"&&e.func.token.type==="identifier"&&e.func.token.value===_.tuple){if(e.args.length===0)return"()";if(e.args.length===1)return`(${T(e.args[0],n)},)`;{let c=e.args.map(s=>T(s,n)),u=`(${c.join(", ")})`;return u.length<=n.maxLineLength?u:`(
+${i}${c.join(`,
+${i}`)}
+${t})`}}let r=e.func.tag==="Atom"?e.func.token.value:null,p=r&&[..._.begin,..._.cond,..._.match,..._.fn,..._.if,..._.while].includes(r),l=T(e.func,n);if(l=I(e.func)||w(e.func)?`(${l})`:l,e.args.length===0)return`${l}()`;if(!p){let c=e.args.map(s=>T(s,n)),u=`${l}(${c.join(", ")})`;if(u.length<=n.maxLineLength)return u}if(p){if(r===_.begin[0]){if(e.args.length===1){let u=T(e.args[0],n);if(u.length<=n.maxLineLength&&!u.includes(`
+`))return`${l}(${u})`}let c=e.args.map(u=>T(u,o));return`${l}(
+${i}${c.join(`,
+${i}`)}
+${t})`}else if(r===_.cond[0]){let c=e.args.map(u=>{if(k(u)&&u.isInfix&&A(u,"=>")){let s=u.args[0],a=T(u.args[1],o),d=T(s,n);if(k(s)&&s.isInfix&&!A(s,"=>")&&(d=`(${d})`),a.includes(`
+`)){let re=a.split(`
+`).map((x,U)=>U===0?x:`${i}${x}`).join(`
+`);return`${d} => ${re}`}else return`${d} => ${a}`}return T(u,o)});return`${l}(
+${i}${c.join(`,
+${i}`)}
+${t})`}}let f=e.args.map(c=>T(c,o));return`${l}(
+${i}${f.join(`,
+${i}`)}
+${t})`}}return h(e)}var lt={tag:"Unit",type:Ue()};var ve=new Map,ne=new Map,yt=new Map;function _t(e){for(let[n,t]of ne.entries()){let o=t.filter(i=>i.sourceModulePath!==e);o.length===0?ne.delete(n):ne.set(n,o)}}function mt(){ve.clear(),ne.clear(),yt.clear()}function dt(e){let n=ve.get(e);if(n){for(let t of n)t.fields=t.fields.filter(o=>o.sourceModulePath!==e);ve.delete(e)}}function Ne({modulePath:e,inputString:n}){return{functionDeclarationFrameLevel:-1,frames:[],freeVariables:[],modulePath:e,inputString:n}}function Pe(){let e=Ne({modulePath:"",inputString:""});return R(e)}function R(e,n={id:ce(e.modulePath,"frame"),variables:[],isBeginBlockFrame:!1},t){let o=t?{...n,isBeginBlockFrame:!0}:n;return{functionDeclarationFrameLevel:e.functionDeclarationFrameLevel,freeVariables:e.freeVariables,frames:[...e.frames,o],modulePath:e.modulePath,inputString:e.inputString}}var Fa=process.env.YO_SKIP_PRELUDE==="1"||process.env.YO_SKIP_PRELUDE==="true";export{j as IdentifierRegex,oe as Operators,G as PlaceholderToken,ht as RAIIToken,z as TokenType,P as charIsOperator,mt as clearAllGlobalImplState,_t as clearGenericImplsFromModule,dt as clearImplsFromModule,Ve as findMatchingBracketTokenIndex,ie as generateExprFromCode,Ce as stringIsOperator,Fe as tokenize};

package/out/types/src/codegen/async/runtime.d.ts

@@ -0,0 +1,2 @@
+import { Emitter } from "../../emitter";
+export declare function generateAsyncRuntime(emitter: Emitter, _debugAsyncAwait: boolean): void;

package/out/types/src/codegen/async/state-code-gen.d.ts

@@ -0,0 +1,10 @@
+import { AwaitPoint } from "../../evaluator/async/await-analysis";
+import { Expr } from "../../expr";
+import { FunctionGenerationContext } from "../functions/context";
+export interface StateSegment {
+    stateNumber: number;
+    expressions: Expr[];
+    awaitPoint: AwaitPoint | null;
+}
+export declare function splitIntoStateSegments(body: Expr, awaitPoints: AwaitPoint[]): StateSegment[];
+export declare function generateStateSegmentCode(segment: StateSegment, indent: string, context: FunctionGenerationContext, captureLastExprResult?: boolean): void;

package/out/types/src/codegen/async/state-machine.d.ts

@@ -0,0 +1,13 @@
+import { AwaitAnalysisResult, AwaitPoint } from "../../evaluator/async/await-analysis";
+import { Expr } from "../../expr";
+import { DynType, SomeType, StructType } from "../../types";
+import { FunctionGenerationContext } from "../functions/context";
+export declare function getFutureFieldName(awaitPoint: AwaitPoint, analysis: AwaitAnalysisResult): string;
+export interface StateMachineInfo {
+    structName: string;
+    resumeFunctionName: string;
+    analysis: AwaitAnalysisResult;
+}
+export declare function generateResumeFunctionDeclaration(info: StateMachineInfo, context: FunctionGenerationContext): void;
+export declare function getStateMachineFieldName(variableId: string, kind?: "outer" | "local"): string;
+export declare function generateAsyncBlockResumeFunction(bodyExpr: Expr, asyncBlockId: string, structName: string, resumeFunctionName: string, analysis: AwaitAnalysisResult, futureType: SomeType | DynType, captureType: StructType | undefined, context: FunctionGenerationContext): void;

package/out/types/src/codegen/c/collection.d.ts

@@ -0,0 +1,3 @@
+import { CodeGenContext } from "../utils";
+export declare function collectCIncludes(context: CodeGenContext): void;
+export declare function emitCIncludes(context: CodeGenContext): void;

package/out/types/src/codegen/codegen-c.d.ts

@@ -0,0 +1,12 @@
+import { ModuleValue } from "../value";
+export declare class CodeGeneratorC {
+    private emitter;
+    constructor();
+    compileModule(modulePath: string, moduleValue: ModuleValue, options?: {
+        debugGc?: boolean;
+        debugParallelism?: boolean;
+        debugAsyncAwait?: boolean;
+        allocator?: "mimalloc" | "libc";
+    }): void;
+    print(): string;
+}

package/out/types/src/codegen/constants.d.ts

@@ -0,0 +1,3 @@
+import { TypeTag } from "../types";
+export declare const BuiltinYoInlineFunctions: string[];
+export declare const PrimitiveTypeTags: Set<TypeTag>;

package/out/types/src/codegen/expressions/array.d.ts

@@ -0,0 +1,4 @@
+import { FuncCallExpr } from "../../expr";
+import { CodeGenContext } from "../utils";
+export declare function isArrayFillMethodCall(expr: FuncCallExpr): boolean;
+export declare function generateArrayFillCall(expr: FuncCallExpr, indent: string, context: CodeGenContext): string;

package/out/types/src/codegen/expressions/generation.d.ts

@@ -0,0 +1,11 @@
+import { Expr } from "../../expr";
+import { Type } from "../../types";
+import { FunctionGenerationContext } from "../functions/context";
+import { CodeGenContext } from "../utils";
+export declare function generateExpr(expr: Expr, indent: string, context: CodeGenContext): string;
+export declare function getDupFunctionForType(type: Type, context: CodeGenContext): string | undefined;
+export declare function generateReturnStatement(expr: Expr, indent: string, context: CodeGenContext): void;
+export declare function generateDeferredDropExpressions(expr: Expr, indent: string, context: FunctionGenerationContext): void;
+export declare function generateDeferredDupExpressions(expr: Expr, indent: string, context: FunctionGenerationContext): void;
+export declare function preRegisterAsyncBlockTypes(context: FunctionGenerationContext): void;
+export declare function generateDeferredAsyncBlocks(context: FunctionGenerationContext): void;

package/out/types/src/codegen/expressions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./array";
+export * from "./generation";

package/out/types/src/codegen/functions/collection.d.ts

@@ -0,0 +1,5 @@
+import { Expr } from "../../expr";
+import { ModuleValue } from "../../value";
+import { CodeGenContext } from "../utils";
+export declare function collectRequiredFunctions(moduleValue: ModuleValue, context: CodeGenContext): void;
+export declare function findFunctionCallsInExpr(expr: Expr, context: CodeGenContext): void;

package/out/types/src/codegen/functions/context.d.ts

@@ -0,0 +1,57 @@
+import { AwaitAnalysisResult, CapturedVariable } from "../../evaluator/async/await-analysis";
+import { Expr } from "../../expr";
+import { FunctionValue, FuncValueId } from "../../function-value";
+import { DynType, FunctionType, SomeType, StructType, Type, TypeId } from "../../types";
+import { CodeGenContext } from "../utils";
+export interface FunctionGenerationContext extends CodeGenContext {
+    functions: Record<FuncValueId, {
+        value: FunctionValue;
+        cName: string;
+    }>;
+    externFunctions: Record<TypeId, {
+        type: FunctionType;
+        cName: string;
+        cInclude?: string;
+    }>;
+    currentFunctionName: string;
+    currentFunctionType?: FunctionType;
+    currentClosureCaptures?: string[];
+    currentClosureCaptureFrameLevel?: number;
+    currentClosureType?: FunctionType;
+    currentClosureCaptureTypeCName?: string;
+    inStateMachine?: {
+        futureType: SomeType | DynType;
+    };
+    stateMachineVariables?: Map<string, CapturedVariable>;
+    pendingDeferredDrops?: Expr[];
+    deferredAsyncBlocks?: Array<{
+        bodyExpr: Expr;
+        asyncBlockId: string;
+        structName: string;
+        resumeFunctionName: string;
+        constructorName: string;
+        disposeFunctionName: string;
+        futureType: SomeType | DynType;
+        futureModuleType: import("../../types").FutureModuleType;
+        resultType: Type;
+        resultTypeCName: string;
+        captureType: StructType | undefined;
+        analysis: AwaitAnalysisResult;
+    }>;
+    condBranchInfo?: Map<number, {
+        branches: Array<{
+            index: number;
+            value: Expr;
+            hasAwait: boolean;
+            remainingExprs?: Expr[];
+            deferredDropExpressions?: Expr[];
+        }>;
+        targetVariableId?: string;
+    }>;
+    whileLoopInfo?: Map<number, {
+        conditionExpr: Expr;
+        bodyExpr: Expr;
+        bodyExprsAfterAwait?: Expr[];
+    }>;
+    localShadowedVariables?: Set<string>;
+}

package/out/types/src/codegen/functions/generation.d.ts

@@ -0,0 +1,25 @@
+import { Expr } from "../../expr";
+import { FunctionValue } from "../../function-value";
+import { FunctionType } from "../../types";
+import { CodeGenContext } from "../utils";
+import { FunctionGenerationContext } from "./context";
+export declare function generateFunctionDeclarations(context: FunctionGenerationContext): void;
+export declare function generateFunctionPrototype(functionType: FunctionType, cFunctionName: string, context: CodeGenContext, overrideReturnType?: string): string;
+export declare function generateFunctionDeclaration(functionType: FunctionType, cFunctionName: string, isExtern: boolean, context: CodeGenContext, functionBody?: Expr): void;
+export declare function generateAllFunctions(context: FunctionGenerationContext): void;
+export declare function generateDynDupDrop(context: FunctionGenerationContext): void;
+export declare function generateMainWrapper(context: FunctionGenerationContext): void;
+export declare function generateFunction(functionValue: FunctionValue, cFunctionName: string, context: FunctionGenerationContext): void;
+export declare function generateFunctionBody(expr: Expr, functionType: FunctionType, indent: string, context: FunctionGenerationContext): void;
+export declare function generateSpecializedFunctionDeclarations(context: CodeGenContext): void;
+export declare function generateSpecializedFunctions(context: CodeGenContext): void;
+export declare function generateObjectConstructorDeclarations(context: FunctionGenerationContext): void;
+export declare function generateClosureConstructorDeclarations(context: FunctionGenerationContext): void;
+export declare function generateCaptureDisposeFunctionDeclarations(context: FunctionGenerationContext): void;
+export declare function generateClosureVtableDeclarations(_context: FunctionGenerationContext): void;
+export declare function generateRefStructConstructorFunctions(context: FunctionGenerationContext): void;
+export declare function generateClosureConstructorFunctions(context: FunctionGenerationContext): void;
+export declare function generateClosureDisposeFunctions(context: FunctionGenerationContext): void;
+export declare function generateDynBoxFunctions(context: FunctionGenerationContext): void;
+export declare function generateDynWrapperFunctions(context: FunctionGenerationContext): void;
+export declare function generateDynVtables(context: FunctionGenerationContext): void;

package/out/types/src/codegen/functions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./collection";
+export * from "./generation";

package/out/types/src/codegen/index.d.ts

@@ -0,0 +1,20 @@
+export declare class CodeGenerator {
+    private moduleManager;
+    constructor();
+    compileModule(modulePath: string, options: {
+        output: string;
+        cCompiler: string;
+        target: "c";
+        extern: string[];
+        emitC?: boolean;
+        skipCodegen?: boolean;
+        skipCCompiler?: boolean;
+        debugGc?: boolean;
+        debugParallelism?: boolean;
+        debugAsyncAwait?: boolean;
+        release?: boolean;
+        optimize?: "0" | "1" | "2" | "3";
+        allocator?: "mimalloc" | "libc";
+        sanitize?: "address" | "leak";
+    }): void;
+}

package/out/types/src/codegen/parallelism/runtime.d.ts

@@ -0,0 +1,2 @@
+import { Emitter } from "../../emitter";
+export declare function generateParallelismRuntime(emitter: Emitter, _debugParallelism: boolean): void;

package/out/types/src/codegen/types/collection.d.ts

@@ -0,0 +1,8 @@
+import { Expr } from "../../expr";
+import { FunctionType, Type } from "../../types";
+import { ModuleValue } from "../../value";
+import { CodeGenContext } from "../utils";
+export declare function collectRequiredTypes(moduleValue: ModuleValue, context: CodeGenContext): void;
+export declare function collectTypesFromFunctionType(functionType: FunctionType, context: CodeGenContext): void;
+export declare function collectTypesFromExpr(expr: Expr, context: CodeGenContext): void;
+export declare function collectType(type: Type, context: CodeGenContext): void;

package/out/types/src/codegen/types/generation.d.ts

@@ -0,0 +1,13 @@
+import { DynType, EnumType, FunctionType, StructType, TupleType, UnionType } from "../../types";
+import { CodeGenContext } from "../utils";
+export declare function generateTypeDeclarations(context: CodeGenContext): void;
+export declare function generateArrayStructDeclarations(context: CodeGenContext): void;
+export declare function generateSliceStructDeclarations(context: CodeGenContext): void;
+export declare function generateIsoTypeDeclarations(context: CodeGenContext): void;
+export declare function generateClosureDeclaration(functionType: FunctionType, cName: string, captureType: StructType | undefined, context: CodeGenContext): void;
+export declare function generateStructDeclaration(structType: StructType, cName: string, context: CodeGenContext): void;
+export declare function generateTupleDeclaration(tupleType: TupleType, cName: string, context: CodeGenContext): void;
+export declare function generateUnionDeclaration(unionType: UnionType, cName: string, context: CodeGenContext): void;
+export declare function generateEnumDeclaration(enumType: EnumType, cName: string, context: CodeGenContext): void;
+export declare function generateDynDeclaration(dynType: DynType, cName: string, context: CodeGenContext): void;
+export declare function generateDynBoxTypes(context: CodeGenContext): void;

package/out/types/src/codegen/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./collection";
+export * from "./generation";

package/out/types/src/codegen/utils/fixup.d.ts

@@ -0,0 +1,2 @@
+import { CodeGenContext } from "./index";
+export declare function fixupDynImplKeys(context: CodeGenContext): void;

package/out/types/src/codegen/utils/index.d.ts

@@ -0,0 +1,77 @@
+import { Emitter } from "../../emitter";
+import { FunctionValue, FuncValueId } from "../../function-value";
+import { DynType, EnumType, FunctionType, IsoType, StructType, Type, TypeId } from "../../types";
+import { ModuleValue } from "../../value";
+export interface CodeGenContext {
+    types: Record<TypeId, {
+        type: Type;
+        cName: string;
+    }>;
+    functions: Record<FuncValueId, {
+        value: FunctionValue;
+        cName: string;
+    }>;
+    externFunctions: Record<TypeId, {
+        type: FunctionType;
+        cName: string;
+        cInclude?: string;
+    }>;
+    arrayStructTypes: Map<string, {
+        childType: string;
+        length: number;
+    }>;
+    sliceStructTypes: Map<string, {
+        childType: string;
+    }>;
+    isoTypes?: Map<string, {
+        childTypeCName: string;
+        isoType: IsoType;
+        optionTypeCName?: string;
+        structGenerated?: boolean;
+        createGenerated?: boolean;
+        extractGenerated?: boolean;
+        disposeGenerated?: boolean;
+    }>;
+    spawnedFunctionSignatures: Map<string, {
+        parameterTypes: Type[];
+        returnType: Type;
+    }>;
+    spawnedClosureSignatures: Map<string, {
+        closureType: Type;
+    }>;
+    tempVarAsyncStructNames?: Map<string, string>;
+    closureCaptureMap: Map<string, {
+        closureType: FunctionType;
+        closureCName: string;
+        captureType: StructType;
+        captureCName: string;
+    }>;
+    implClosureCallMap: Map<TypeId, {
+        functionCName: string;
+        callTypeId: TypeId;
+    }>;
+    currentFunctionName: string;
+    cIncludes: Set<string>;
+    emitter: Emitter;
+    debugGc: boolean;
+    debugParallelism: boolean;
+    debugAsyncAwait: boolean;
+    allocator: "mimalloc" | "libc";
+    dynImpls: Map<string, {
+        dynType: DynType;
+        concreteType: Type;
+        dataType: Type;
+        moduleValue: ModuleValue;
+    }>;
+    currentLoopLabel?: string;
+}
+export declare function sanitizeForCIdentifier(str: string): string;
+export declare function shouldAvoidConst(type: Type): boolean;
+export declare function getTypeString(type: Type | undefined, context: CodeGenContext): string;
+export declare function getVariableTypeString(type: Type, varName: string, context: CodeGenContext): string;
+export declare function getEnumVariantCName(enumType: EnumType, variantName: string, context: CodeGenContext): string;
+export declare function isGenericFunction(functionValue: FunctionValue): boolean;
+export declare function isComptFunction(functionValue: FunctionValue): boolean;
+export declare function isFunctionValueWithOnlyBuiltinYoInlineFunctionCall(functionValue: FunctionValue): string | null;
+export declare function canOptimizeAsNullablePointer(enumType: EnumType): Type | null;
+export declare function canOptimizeAsSimpleEnum(enumType: EnumType): boolean;

package/out/types/src/codegen/values/index.d.ts

@@ -0,0 +1 @@
+export {};

package/out/types/src/emitter.d.ts

@@ -0,0 +1,11 @@
+export declare class Emitter {
+    private headers;
+    private declarations;
+    private code;
+    constructor();
+    emit(code: string, indentation?: string): string;
+    emitLine(code: string, indentation?: string): string;
+    emitHeaderLine(code: string, indentation?: string): string;
+    emitDeclarationLine(code: string, indentation?: string): string;
+    print(): string;
+}

package/out/types/src/env.d.ts

@@ -0,0 +1,85 @@
+import { Token } from "./token";
+import { FunctionType, Type } from "./types";
+import { Value } from "./value";
+export interface Variable {
+    id: string;
+    name: string;
+    type: Type;
+    value?: Value;
+    isCompileTimeOnly: boolean;
+    isOwningTheGcValue: boolean;
+    isOwningTheSameGcValueAs?: Variable;
+    isReassignable?: boolean;
+    initializedAtToken: Token | undefined;
+    consumedAtToken: Token | undefined;
+    frameLevel: number;
+    token: Token;
+    isCreatedFromDestructuringAtomVariable?: boolean;
+    parameterAlias?: string;
+}
+export type Frame = {
+    variables: Variable[];
+    id: string;
+    isBeginBlockFrame: boolean;
+};
+export type Environment = {
+    functionDeclarationFrameLevel: number;
+    freeVariables: Variable[];
+    frames: Frame[];
+    modulePath: string;
+    inputString: string;
+};
+export declare function createNewEnv({ modulePath, inputString, }: {
+    modulePath: string;
+    inputString: string;
+}): Environment;
+export declare function createEmptyEnv(): Environment;
+export declare function setEnvContainingPrelude(env: Environment): void;
+export declare function clearEnvContainingPrelude(): void;
+export declare function createEnvContainingPrelude(): Environment;
+export declare function isEvaluatingPreludeModule(): boolean;
+export declare function addVariableToEnv({ env, variable, deltaFrame, variableId, skipCheckingFunctionOverloading, addToBeginBlockFrame, }: {
+    env: Environment;
+    variable: Omit<Variable, "id" | "frameLevel">;
+    deltaFrame?: number;
+    variableId?: string;
+    skipCheckingFunctionOverloading?: boolean;
+    addToBeginBlockFrame?: boolean;
+}): {
+    env: Environment;
+    variable: Variable;
+};
+export declare function addVariableToFrame({ frame, variable, }: {
+    frame: Frame;
+    variable: Variable;
+}): Frame;
+export declare function getVariablesFromFrame(frame: Frame, variableName: string, variableFilter?: (variable: Variable) => boolean): Variable[];
+export declare function getVariablesFromEnv(env: Environment, variableName: string, variableFilter?: (variable: Variable) => boolean): Variable[];
+export declare function getVariablesFromEnvByFilter(env: Environment, variableFilter: (variable: Variable) => boolean): Variable[];
+export declare function pushEnvFrame(env: Environment, frame?: Frame, isBeginBlockFrame?: boolean): Environment;
+export declare function popEnvFrame(env: Environment, ignoreCheck?: boolean): Environment;
+export declare function updateExistingVariable(env: Environment, oldVariable: Variable, newVariable: Variable): Environment;
+export declare function printEnvVarNames(env: Environment): void;
+export declare function printEnvFrame(frame: Frame): void;
+export declare function getVariableInfo(variable: Variable): {
+    id: string;
+    name: string;
+    type: string;
+    typeId: string;
+    value: string;
+    isCompileTimeOnly: boolean;
+    isUndefined: boolean;
+    isOwningTheGcValue: boolean;
+    isOwningTheSameGcValueAs: string | undefined;
+    isReassignable: boolean;
+    isConsumed: boolean;
+};
+export declare function getMethodsByNameFromEnv(env: Environment, methodName: string, receiverType: Type, isInfixOperatorCall?: boolean, currentFunctionType?: FunctionType): {
+    type: Type;
+    value: Value | undefined;
+    needsPointerConversion?: boolean;
+}[];
+export declare function keepTopLevelFrameAndComptimeVariablesFromEnv(env: Environment): Environment;
+export declare function getVariablesNeedingDrop(env: Environment): Variable[];
+export declare function findNearestBeginBlockFrameLevel(env: Environment): number;
+export declare function variableExistsInEnvTopFrame(env: Environment, variableName: string): boolean;

package/out/types/src/error.d.ts

@@ -0,0 +1,45 @@
+import { Token } from "./token";
+export interface TokenAndError {
+    token: Token;
+    errorMessage: string;
+}
+export declare class YoLexerError {
+    characterIndex: number;
+    message: string;
+    constructor({ characterIndex, message, }: {
+        characterIndex: number;
+        message: string;
+    });
+}
+export declare class YoError {
+    tokenAndErrorList: TokenAndError[];
+    isAssertionError: boolean;
+    constructor(tokenAndErrorList: TokenAndError[], isAssertionError?: boolean);
+    toString(): string;
+}
+export declare function getLineAtToken({ token }: {
+    token: Token;
+}): string;
+export declare function getLineAtPosition({ modulePath, inputString, position, }: {
+    modulePath: string;
+    inputString: string;
+    position: {
+        row: number;
+        column: number;
+    };
+}): string;
+export declare function formatErrorMessage({ token, errorMessage, cause, isAssertionError, }: {
+    token: Token;
+    errorMessage: string;
+    cause?: Error;
+    isAssertionError?: boolean;
+}): YoError;
+export declare function formatErrorMessages(tokenAndErrorList: TokenAndError[], isAssertionError?: boolean): YoError;
+export declare function formatWarningMessages({ warningMessage, tokenAndWarningList, }: {
+    warningMessage?: string;
+    tokenAndWarningList: {
+        token: Token;
+        warningMessage: string;
+    }[];
+}): string;
+export declare function printYoError(error: YoError | Error): void;

package/out/types/src/evaluator/async/await-analysis-types.d.ts

@@ -0,0 +1,23 @@
+import { Type } from "../../types";
+export interface AwaitPoint {
+    index: number;
+    expr: unknown;
+    resultType: Type;
+    futureType?: Type;
+    targetVariableId?: string;
+    futureVariableId?: string;
+    isInsideCond?: boolean;
+    isInsideWhile?: boolean;
+}
+export interface CapturedVariable {
+    id: string;
+    name: string;
+    type: Type;
+    kind: "local" | "outer";
+    isOwningTheSameGcValueAs: CapturedVariable | undefined;
+}
+export interface AwaitAnalysisResult {
+    awaitPoints: AwaitPoint[];
+    capturedVariables: CapturedVariable[];
+    hasAwaits: boolean;
+}

package/out/types/src/evaluator/async/await-analysis.d.ts

@@ -0,0 +1,5 @@
+import { Expr } from "../../expr";
+export type { AwaitAnalysisResult, AwaitPoint, CapturedVariable, } from "./await-analysis-types";
+import type { AwaitAnalysisResult, CapturedVariable } from "./await-analysis-types";
+export declare function analyzeAwaitPoints(body: Expr): AwaitAnalysisResult;
+export declare function getLocalVariablesFromBody(body: Expr): CapturedVariable[];

package/out/types/src/evaluator/builtins/alignof.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateAlignOf({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;

package/out/types/src/evaluator/builtins/and_or.d.ts

@@ -0,0 +1,8 @@
+import { Environment } from "../../env";
+import { FuncCallExpr } from "../../expr";
+import { EvaluatorContext } from "../context";
+export declare function evaluateAndOr({ expr, env, context, }: {
+    expr: FuncCallExpr;
+    env: Environment;
+    context: EvaluatorContext;
+}): FuncCallExpr;