@knightcodeai/cli 0.18.4 → 0.20.0

package/dist/bundle/chunks/{chunk-T6M3FJYR.js → chunk-B7A4GIBK.js}

@@ -1,2 +1,2 @@
 import { createRequire as __kcCreateRequire } from "node:module"; const require = __kcCreateRequire(import.meta.url);
-import{theme}from"./chunk-GCXF7ZNR.js";var ARMIN_WIDTH=31,ARMIN_HEIGHT=36,WIDTH=ARMIN_WIDTH,HEIGHT=ARMIN_HEIGHT,BITS=[255,255,255,127,255,240,255,127,255,237,255,127,255,219,255,127,255,183,255,127,255,119,254,127,63,248,254,127,223,255,254,127,223,63,252,127,159,195,251,127,111,252,244,127,247,15,247,127,247,255,247,127,247,255,227,127,247,7,232,127,239,248,103,112,15,255,187,111,241,0,208,91,253,63,236,83,193,255,239,87,159,253,238,95,159,252,174,95,31,120,172,95,63,0,80,108,127,0,220,119,255,192,63,120,255,1,248,127,255,3,156,120,255,7,140,124,255,15,206,120,255,255,207,127,255,255,207,120,255,255,223,120,255,255,223,125,255,255,63,126,255,255,255,127],BYTES_PER_ROW=Math.ceil(WIDTH/8),DISPLAY_HEIGHT=Math.ceil(HEIGHT/2),EFFECTS=["typewriter","scanline","rain","fade","crt","glitch","dissolve"];function isArminPixel(x,y){if(y>=HEIGHT)return!1;let byteIndex=y*BYTES_PER_ROW+Math.floor(x/8),bitIndex=x%8;return(BITS[byteIndex]>>bitIndex&1)===0}function getChar(x,row){let upper=isArminPixel(x,row*2),lower=isArminPixel(x,row*2+1);return upper&&lower?"\u2588":upper?"\u2580":lower?"\u2584":" "}function buildFinalGrid(){let grid=[];for(let row=0;row<DISPLAY_HEIGHT;row++){let line=[];for(let x=0;x<WIDTH;x++)line.push(getChar(x,row));grid.push(line)}return grid}var ArminComponent=class{ui;interval=null;effect;finalGrid;currentGrid;effectState={};cachedLines=[];cachedWidth=0;gridVersion=0;cachedVersion=-1;constructor(ui){this.ui=ui,this.effect=EFFECTS[Math.floor(Math.random()*EFFECTS.length)],this.finalGrid=buildFinalGrid(),this.currentGrid=this.createEmptyGrid(),this.initEffect(),this.startAnimation()}invalidate(){this.cachedWidth=0}render(width){if(width===this.cachedWidth&&this.cachedVersion===this.gridVersion)return this.cachedLines;let padding=1,availableWidth=width-padding;this.cachedLines=this.currentGrid.map(row=>{let clipped=row.slice(0,availableWidth).join(""),padRight=Math.max(0,width-padding-clipped.length);return` ${theme.fg("accent",clipped)}${" ".repeat(padRight)}`});let message="ARMIN SAYS HI",msgPadRight=Math.max(0,width-padding-message.length);return this.cachedLines.push(` ${theme.fg("accent",message)}${" ".repeat(msgPadRight)}`),this.cachedWidth=width,this.cachedVersion=this.gridVersion,this.cachedLines}createEmptyGrid(){return Array.from({length:DISPLAY_HEIGHT},()=>Array(WIDTH).fill(" "))}initEffect(){switch(this.effect){case"typewriter":this.effectState={pos:0};break;case"scanline":this.effectState={row:0};break;case"rain":this.effectState={drops:Array.from({length:WIDTH},()=>({y:-Math.floor(Math.random()*DISPLAY_HEIGHT*2),settled:0}))};break;case"fade":{let positions=[];for(let row=0;row<DISPLAY_HEIGHT;row++)for(let x=0;x<WIDTH;x++)positions.push([row,x]);for(let i=positions.length-1;i>0;i--){let j=Math.floor(Math.random()*(i+1));[positions[i],positions[j]]=[positions[j],positions[i]]}this.effectState={positions,idx:0};break}case"crt":this.effectState={expansion:0};break;case"glitch":this.effectState={phase:0,glitchFrames:8};break;case"dissolve":{this.currentGrid=Array.from({length:DISPLAY_HEIGHT},()=>Array.from({length:WIDTH},()=>{let chars=[" ","\u2591","\u2592","\u2593","\u2588","\u2580","\u2584"];return chars[Math.floor(Math.random()*chars.length)]}));let dissolvePositions=[];for(let row=0;row<DISPLAY_HEIGHT;row++)for(let x=0;x<WIDTH;x++)dissolvePositions.push([row,x]);for(let i=dissolvePositions.length-1;i>0;i--){let j=Math.floor(Math.random()*(i+1));[dissolvePositions[i],dissolvePositions[j]]=[dissolvePositions[j],dissolvePositions[i]]}this.effectState={positions:dissolvePositions,idx:0};break}}}startAnimation(){let fps=this.effect==="glitch"?60:30;this.interval=setInterval(()=>{let done=this.tickEffect();this.updateDisplay(),this.ui.requestRender(),done&&this.stopAnimation()},1e3/fps)}stopAnimation(){this.interval&&(clearInterval(this.interval),this.interval=null)}tickEffect(){switch(this.effect){case"typewriter":return this.tickTypewriter();case"scanline":return this.tickScanline();case"rain":return this.tickRain();case"fade":return this.tickFade();case"crt":return this.tickCrt();case"glitch":return this.tickGlitch();case"dissolve":return this.tickDissolve();default:return!0}}tickTypewriter(){let state=this.effectState,pixelsPerFrame=3;for(let i=0;i<pixelsPerFrame;i++){let row=Math.floor(state.pos/WIDTH),x=state.pos%WIDTH;if(row>=DISPLAY_HEIGHT)return!0;this.currentGrid[row][x]=this.finalGrid[row][x],state.pos++}return!1}tickScanline(){let state=this.effectState;if(state.row>=DISPLAY_HEIGHT)return!0;for(let x=0;x<WIDTH;x++)this.currentGrid[state.row][x]=this.finalGrid[state.row][x];return state.row++,!1}tickRain(){let state=this.effectState,allSettled=!0;this.currentGrid=this.createEmptyGrid();for(let x=0;x<WIDTH;x++){let drop=state.drops[x];for(let row=DISPLAY_HEIGHT-1;row>=DISPLAY_HEIGHT-drop.settled;row--)row>=0&&(this.currentGrid[row][x]=this.finalGrid[row][x]);if(drop.settled>=DISPLAY_HEIGHT)continue;allSettled=!1;let targetRow=-1;for(let row=DISPLAY_HEIGHT-1-drop.settled;row>=0;row--)if(this.finalGrid[row][x]!==" "){targetRow=row;break}drop.y++,drop.y>=0&&drop.y<DISPLAY_HEIGHT&&(targetRow>=0&&drop.y>=targetRow?(drop.settled=DISPLAY_HEIGHT-targetRow,drop.y=-Math.floor(Math.random()*5)-1):this.currentGrid[drop.y][x]="\u2593")}return allSettled}tickFade(){let state=this.effectState,pixelsPerFrame=15;for(let i=0;i<pixelsPerFrame;i++){if(state.idx>=state.positions.length)return!0;let[row,x]=state.positions[state.idx];this.currentGrid[row][x]=this.finalGrid[row][x],state.idx++}return!1}tickCrt(){let state=this.effectState,midRow=Math.floor(DISPLAY_HEIGHT/2);this.currentGrid=this.createEmptyGrid();let top=midRow-state.expansion,bottom=midRow+state.expansion;for(let row=Math.max(0,top);row<=Math.min(DISPLAY_HEIGHT-1,bottom);row++)for(let x=0;x<WIDTH;x++)this.currentGrid[row][x]=this.finalGrid[row][x];return state.expansion++,state.expansion>DISPLAY_HEIGHT}tickGlitch(){let state=this.effectState;return state.phase<state.glitchFrames?(this.currentGrid=this.finalGrid.map(row=>{let offset=Math.floor(Math.random()*7)-3,glitchRow=[...row];if(Math.random()<.3)return glitchRow.slice(offset).concat(glitchRow.slice(0,offset)).slice(0,WIDTH);if(Math.random()<.2){let swapRow=Math.floor(Math.random()*DISPLAY_HEIGHT);return[...this.finalGrid[swapRow]]}return glitchRow}),state.phase++,!1):(this.currentGrid=this.finalGrid.map(row=>[...row]),!0)}tickDissolve(){let state=this.effectState,pixelsPerFrame=20;for(let i=0;i<pixelsPerFrame;i++){if(state.idx>=state.positions.length)return!0;let[row,x]=state.positions[state.idx];this.currentGrid[row][x]=this.finalGrid[row][x],state.idx++}return!1}updateDisplay(){this.gridVersion++}dispose(){this.stopAnimation()}};export{ARMIN_WIDTH,ARMIN_HEIGHT,isArminPixel,ArminComponent};
+import{theme}from"./chunk-L6QGGIZG.js";var ARMIN_WIDTH=31,ARMIN_HEIGHT=36,WIDTH=ARMIN_WIDTH,HEIGHT=ARMIN_HEIGHT,BITS=[255,255,255,127,255,240,255,127,255,237,255,127,255,219,255,127,255,183,255,127,255,119,254,127,63,248,254,127,223,255,254,127,223,63,252,127,159,195,251,127,111,252,244,127,247,15,247,127,247,255,247,127,247,255,227,127,247,7,232,127,239,248,103,112,15,255,187,111,241,0,208,91,253,63,236,83,193,255,239,87,159,253,238,95,159,252,174,95,31,120,172,95,63,0,80,108,127,0,220,119,255,192,63,120,255,1,248,127,255,3,156,120,255,7,140,124,255,15,206,120,255,255,207,127,255,255,207,120,255,255,223,120,255,255,223,125,255,255,63,126,255,255,255,127],BYTES_PER_ROW=Math.ceil(WIDTH/8),DISPLAY_HEIGHT=Math.ceil(HEIGHT/2),EFFECTS=["typewriter","scanline","rain","fade","crt","glitch","dissolve"];function isArminPixel(x,y){if(y>=HEIGHT)return!1;let byteIndex=y*BYTES_PER_ROW+Math.floor(x/8),bitIndex=x%8;return(BITS[byteIndex]>>bitIndex&1)===0}function getChar(x,row){let upper=isArminPixel(x,row*2),lower=isArminPixel(x,row*2+1);return upper&&lower?"\u2588":upper?"\u2580":lower?"\u2584":" "}function buildFinalGrid(){let grid=[];for(let row=0;row<DISPLAY_HEIGHT;row++){let line=[];for(let x=0;x<WIDTH;x++)line.push(getChar(x,row));grid.push(line)}return grid}var ArminComponent=class{ui;interval=null;effect;finalGrid;currentGrid;effectState={};cachedLines=[];cachedWidth=0;gridVersion=0;cachedVersion=-1;constructor(ui){this.ui=ui,this.effect=EFFECTS[Math.floor(Math.random()*EFFECTS.length)],this.finalGrid=buildFinalGrid(),this.currentGrid=this.createEmptyGrid(),this.initEffect(),this.startAnimation()}invalidate(){this.cachedWidth=0}render(width){if(width===this.cachedWidth&&this.cachedVersion===this.gridVersion)return this.cachedLines;let padding=1,availableWidth=width-padding;this.cachedLines=this.currentGrid.map(row=>{let clipped=row.slice(0,availableWidth).join(""),padRight=Math.max(0,width-padding-clipped.length);return` ${theme.fg("accent",clipped)}${" ".repeat(padRight)}`});let message="ARMIN SAYS HI",msgPadRight=Math.max(0,width-padding-message.length);return this.cachedLines.push(` ${theme.fg("accent",message)}${" ".repeat(msgPadRight)}`),this.cachedWidth=width,this.cachedVersion=this.gridVersion,this.cachedLines}createEmptyGrid(){return Array.from({length:DISPLAY_HEIGHT},()=>Array(WIDTH).fill(" "))}initEffect(){switch(this.effect){case"typewriter":this.effectState={pos:0};break;case"scanline":this.effectState={row:0};break;case"rain":this.effectState={drops:Array.from({length:WIDTH},()=>({y:-Math.floor(Math.random()*DISPLAY_HEIGHT*2),settled:0}))};break;case"fade":{let positions=[];for(let row=0;row<DISPLAY_HEIGHT;row++)for(let x=0;x<WIDTH;x++)positions.push([row,x]);for(let i=positions.length-1;i>0;i--){let j=Math.floor(Math.random()*(i+1));[positions[i],positions[j]]=[positions[j],positions[i]]}this.effectState={positions,idx:0};break}case"crt":this.effectState={expansion:0};break;case"glitch":this.effectState={phase:0,glitchFrames:8};break;case"dissolve":{this.currentGrid=Array.from({length:DISPLAY_HEIGHT},()=>Array.from({length:WIDTH},()=>{let chars=[" ","\u2591","\u2592","\u2593","\u2588","\u2580","\u2584"];return chars[Math.floor(Math.random()*chars.length)]}));let dissolvePositions=[];for(let row=0;row<DISPLAY_HEIGHT;row++)for(let x=0;x<WIDTH;x++)dissolvePositions.push([row,x]);for(let i=dissolvePositions.length-1;i>0;i--){let j=Math.floor(Math.random()*(i+1));[dissolvePositions[i],dissolvePositions[j]]=[dissolvePositions[j],dissolvePositions[i]]}this.effectState={positions:dissolvePositions,idx:0};break}}}startAnimation(){let fps=this.effect==="glitch"?60:30;this.interval=setInterval(()=>{let done=this.tickEffect();this.updateDisplay(),this.ui.requestRender(),done&&this.stopAnimation()},1e3/fps)}stopAnimation(){this.interval&&(clearInterval(this.interval),this.interval=null)}tickEffect(){switch(this.effect){case"typewriter":return this.tickTypewriter();case"scanline":return this.tickScanline();case"rain":return this.tickRain();case"fade":return this.tickFade();case"crt":return this.tickCrt();case"glitch":return this.tickGlitch();case"dissolve":return this.tickDissolve();default:return!0}}tickTypewriter(){let state=this.effectState,pixelsPerFrame=3;for(let i=0;i<pixelsPerFrame;i++){let row=Math.floor(state.pos/WIDTH),x=state.pos%WIDTH;if(row>=DISPLAY_HEIGHT)return!0;this.currentGrid[row][x]=this.finalGrid[row][x],state.pos++}return!1}tickScanline(){let state=this.effectState;if(state.row>=DISPLAY_HEIGHT)return!0;for(let x=0;x<WIDTH;x++)this.currentGrid[state.row][x]=this.finalGrid[state.row][x];return state.row++,!1}tickRain(){let state=this.effectState,allSettled=!0;this.currentGrid=this.createEmptyGrid();for(let x=0;x<WIDTH;x++){let drop=state.drops[x];for(let row=DISPLAY_HEIGHT-1;row>=DISPLAY_HEIGHT-drop.settled;row--)row>=0&&(this.currentGrid[row][x]=this.finalGrid[row][x]);if(drop.settled>=DISPLAY_HEIGHT)continue;allSettled=!1;let targetRow=-1;for(let row=DISPLAY_HEIGHT-1-drop.settled;row>=0;row--)if(this.finalGrid[row][x]!==" "){targetRow=row;break}drop.y++,drop.y>=0&&drop.y<DISPLAY_HEIGHT&&(targetRow>=0&&drop.y>=targetRow?(drop.settled=DISPLAY_HEIGHT-targetRow,drop.y=-Math.floor(Math.random()*5)-1):this.currentGrid[drop.y][x]="\u2593")}return allSettled}tickFade(){let state=this.effectState,pixelsPerFrame=15;for(let i=0;i<pixelsPerFrame;i++){if(state.idx>=state.positions.length)return!0;let[row,x]=state.positions[state.idx];this.currentGrid[row][x]=this.finalGrid[row][x],state.idx++}return!1}tickCrt(){let state=this.effectState,midRow=Math.floor(DISPLAY_HEIGHT/2);this.currentGrid=this.createEmptyGrid();let top=midRow-state.expansion,bottom=midRow+state.expansion;for(let row=Math.max(0,top);row<=Math.min(DISPLAY_HEIGHT-1,bottom);row++)for(let x=0;x<WIDTH;x++)this.currentGrid[row][x]=this.finalGrid[row][x];return state.expansion++,state.expansion>DISPLAY_HEIGHT}tickGlitch(){let state=this.effectState;return state.phase<state.glitchFrames?(this.currentGrid=this.finalGrid.map(row=>{let offset=Math.floor(Math.random()*7)-3,glitchRow=[...row];if(Math.random()<.3)return glitchRow.slice(offset).concat(glitchRow.slice(0,offset)).slice(0,WIDTH);if(Math.random()<.2){let swapRow=Math.floor(Math.random()*DISPLAY_HEIGHT);return[...this.finalGrid[swapRow]]}return glitchRow}),state.phase++,!1):(this.currentGrid=this.finalGrid.map(row=>[...row]),!0)}tickDissolve(){let state=this.effectState,pixelsPerFrame=20;for(let i=0;i<pixelsPerFrame;i++){if(state.idx>=state.positions.length)return!0;let[row,x]=state.positions[state.idx];this.currentGrid[row][x]=this.finalGrid[row][x],state.idx++}return!1}updateDisplay(){this.gridVersion++}dispose(){this.stopAnimation()}};export{ARMIN_WIDTH,ARMIN_HEIGHT,isArminPixel,ArminComponent};

package/dist/bundle/chunks/{chunk-3B66IKOZ.js → chunk-BWGDAXFH.js}

@@ -1,5 +1,5 @@
 import { createRequire as __kcCreateRequire } from "node:module"; const require = __kcCreateRequire(import.meta.url);
-import{FileAuthStorageBackend,JSON_RPC_ERROR_CODES,LATEST_PROTOCOL_VERSION,McpAuthRequiredError,McpClient,McpError,McpHttpError,McpSessionExpiredError,StdioTransport,StreamableHttpTransport,isObject,mcpNamespace,require_proper_lockfile,resolveConfigValueOrThrow,resolveHeadersOrThrow}from"./chunk-NGWSYXD5.js";import{APP_NAME,VERSION,getAgentDir}from"./chunk-BPNRVFVQ.js";import{__toESM}from"./chunk-AHB7JV5B.js";import{homedir}from"node:os";import{basename,join as join2,resolve}from"node:path";import{setTimeout as sleep}from"node:timers/promises";import{pathToFileURL}from"node:url";import{createServer}from"node:http";function plainText(page){return page.ok?"Authorization complete. You may close this window.":page.details?`${page.message}
+import{FileAuthStorageBackend,JSON_RPC_ERROR_CODES,LATEST_PROTOCOL_VERSION,McpAuthRequiredError,McpClient,McpError,McpHttpError,McpSessionExpiredError,StdioTransport,StreamableHttpTransport,isObject,mcpNamespace,require_proper_lockfile,resolveConfigValueOrThrow,resolveHeadersOrThrow}from"./chunk-IIWY7U5S.js";import{APP_NAME,VERSION,getAgentDir}from"./chunk-BPNRVFVQ.js";import{__toESM}from"./chunk-AHB7JV5B.js";import{homedir}from"node:os";import{basename,join as join2,resolve}from"node:path";import{setTimeout as sleep}from"node:timers/promises";import{pathToFileURL}from"node:url";import{createServer}from"node:http";function plainText(page){return page.ok?"Authorization complete. You may close this window.":page.details?`${page.message}
 
 ${page.details}`:page.message}var OAuthCallbackServer=class _OAuthCallbackServer{redirectUrl;server;paths;timeoutMs;renderPage;pending=new Map;constructor(server,redirectUrl,paths,timeoutMs,renderPage2){this.server=server,this.redirectUrl=redirectUrl,this.paths=paths,this.timeoutMs=timeoutMs,this.renderPage=renderPage2}static async listen(options={}){let host=options.host??"127.0.0.1",redirectHost=options.redirectHost??host,path=options.path??"/callback",instance,server=createServer((request,response)=>instance?.handle(request.url??"/",response));await new Promise((resolve2,reject)=>{server.once("error",reject),server.listen(options.port??0,host,()=>{server.off("error",reject),resolve2()})});let address=server.address();if(!address||typeof address=="string")throw new Error("OAuth callback server did not bind to TCP");return instance=new _OAuthCallbackServer(server,`http://${redirectHost.includes(":")?`[${redirectHost}]`:redirectHost}:${address.port}${path}`,[path,...options.extraPaths??[]],options.timeoutMs??5*6e4,options.renderPage),instance}waitForCallback(state,path){if(this.pending.has(state))throw new Error("OAuth state is already pending");return new Promise((resolve2,reject)=>{let timer=setTimeout(()=>{this.pending.delete(state),reject(new Error("OAuth callback timed out"))},this.timeoutMs);this.pending.set(state,{resolve:resolve2,reject,timer,path})})}async close(){for(let pending of this.pending.values())clearTimeout(pending.timer),pending.reject(new Error("OAuth callback server closed"));this.pending.clear(),await new Promise((resolve2,reject)=>{this.server.close(error=>error?reject(error):resolve2())})}reply(response,status,page){this.renderPage?(response.writeHead(status,{"content-type":"text/html; charset=utf-8","cache-control":"no-store"}),response.end(this.renderPage(page))):response.writeHead(status,{"content-type":"text/plain; charset=utf-8"}).end(plainText(page))}handle(rawUrl,response){let url=new URL(rawUrl,this.redirectUrl);if(!this.paths.includes(url.pathname)){this.reply(response,404,{ok:!1,message:"Not found"});return}let state=url.searchParams.get("state"),pending=state?this.pending.get(state):void 0;if(!state||!pending){this.reply(response,400,{ok:!1,message:"Invalid or expired OAuth state"});return}if(clearTimeout(pending.timer),this.pending.delete(state),pending.path!==void 0&&url.pathname!==pending.path){pending.reject(new Error("The authorization response arrived on another redirect URI")),this.reply(response,400,{ok:!1,message:"Unexpected redirect URI"});return}let error=url.searchParams.get("error");if(error){let description=url.searchParams.get("error_description")??error;pending.reject(new Error(description)),this.reply(response,200,{ok:!1,message:"Authorization failed. You may close this window.",details:description});return}let code=url.searchParams.get("code");if(!code){pending.reject(new Error("OAuth callback did not include an authorization code")),this.reply(response,400,{ok:!1,message:"Missing authorization code"});return}let iss=url.searchParams.get("iss");pending.resolve({code,state,...iss?{iss}:{}}),this.reply(response,200,{ok:!0})}};var OAuthError=class extends Error{code;errorUri;constructor(code,message,errorUri){super(message||code),this.name="OAuthError",this.code=code,this.errorUri=errorUri}},OAuthIssuerMismatchError=class extends Error{expected;received;constructor(expected,received){let format=issuer=>issuer===void 0?"none":JSON.stringify(issuer);super(`OAuth issuer mismatch: expected ${format(expected)}, received ${format(received)}`),this.name="OAuthIssuerMismatchError",this.expected=expected,this.received=received}},OAuthInsecureEndpointError=class extends Error{endpoint;constructor(endpoint){super(`Refusing to send OAuth credentials to non-HTTPS endpoint ${endpoint}`),this.name="OAuthInsecureEndpointError",this.endpoint=endpoint}},OAuthRegistrationError=class extends Error{status;body;constructor(status,body){super(`OAuth dynamic client registration failed with status ${status}: ${body}`),this.name="OAuthRegistrationError",this.status=status,this.body=body}},McpOAuthAuthorizationRequiredError=class extends Error{constructor(){super("MCP OAuth authorization requires user interaction"),this.name="McpOAuthAuthorizationRequiredError"}};function object(value,name){if(!isObject(value))throw new Error(`Invalid ${name}`);return value}function compact(value){return Object.fromEntries(Object.entries(value).filter(([,item])=>item!==void 0))}function requiredString(value,name){if(typeof value!="string"||value.length===0)throw new Error(`Invalid ${name}`);return value}function absent(value){return value==null||value===""}function optionalString(value,name){if(!absent(value))return requiredString(value,name)}function optionalStrings(value,name){if(value!=null){if(!Array.isArray(value)||value.some(item=>typeof item!="string"))throw new Error(`Invalid ${name}`);return[...value]}}function safeUrl(value,name){let text=requiredString(value,name);if(!URL.canParse(text))throw new Error(`Invalid ${name}`);let url=new URL(text);if(["javascript:","data:","vbscript:"].includes(url.protocol))throw new Error(`Invalid ${name}`);return text}function optionalUrl(value,name){return absent(value)?void 0:safeUrl(value,name)}function parseProtectedResourceMetadata(value){let input=object(value,"OAuth protected resource metadata");return compact({...input,resource:safeUrl(input.resource,"OAuth protected resource metadata resource"),authorization_servers:optionalStrings(input.authorization_servers,"authorization_servers")?.map(url=>safeUrl(url,"authorization server URL")),scopes_supported:optionalStrings(input.scopes_supported,"scopes_supported")})}function parseAuthorizationServerMetadata(value){let input=object(value,"authorization server metadata"),responseTypes=optionalStrings(input.response_types_supported,"response_types_supported");if(!responseTypes)throw new Error("Invalid response_types_supported");return compact({...input,issuer:safeUrl(input.issuer,"authorization server issuer"),authorization_endpoint:safeUrl(input.authorization_endpoint,"authorization endpoint"),token_endpoint:safeUrl(input.token_endpoint,"token endpoint"),registration_endpoint:optionalUrl(input.registration_endpoint,"registration endpoint"),scopes_supported:optionalStrings(input.scopes_supported,"scopes_supported"),response_types_supported:responseTypes,grant_types_supported:optionalStrings(input.grant_types_supported,"grant_types_supported"),token_endpoint_auth_methods_supported:optionalStrings(input.token_endpoint_auth_methods_supported,"token_endpoint_auth_methods_supported"),code_challenge_methods_supported:optionalStrings(input.code_challenge_methods_supported,"code_challenge_methods_supported"),client_id_metadata_document_supported:typeof input.client_id_metadata_document_supported=="boolean"?input.client_id_metadata_document_supported:void 0,authorization_response_iss_parameter_supported:typeof input.authorization_response_iss_parameter_supported=="boolean"?input.authorization_response_iss_parameter_supported:void 0})}function parseOAuthTokens(value){let input=object(value,"OAuth token response"),expires=absent(input.expires_in)?void 0:Number(input.expires_in);if(expires!==void 0&&!Number.isFinite(expires))throw new Error("Invalid expires_in");return compact({access_token:requiredString(input.access_token,"access_token"),token_type:requiredString(input.token_type,"token_type"),expires_in:expires,scope:optionalString(input.scope,"scope"),refresh_token:optionalString(input.refresh_token,"refresh_token"),id_token:optionalString(input.id_token,"id_token")})}function parseClientInformation(value){let input=object(value,"OAuth client registration response");return compact({...input,client_id:requiredString(input.client_id,"client_id"),client_secret:optionalString(input.client_secret,"client_secret"),client_id_issued_at:typeof input.client_id_issued_at=="number"?input.client_id_issued_at:void 0,client_secret_expires_at:typeof input.client_secret_expires_at=="number"?input.client_secret_expires_at:void 0,redirect_uris:optionalStrings(input.redirect_uris,"redirect_uris")??[]})}function discard(response){response?.body?.cancel().catch(()=>{})}function isDiscoveryMiss(status){return status>=400&&status<500||status===502}function pathSuffix(pathname){return pathname.endsWith("/")?pathname.slice(0,-1):pathname}function field(header,name){let match=header.match(new RegExp(String.raw`(?:^|[,\s])${name}=(?:"([^"]*)"|([^\s,]+))`,"i"));return match?.[1]||match?.[2]||void 0}function parseWwwAuthenticate(header){if(!header)return{};let scheme=header.trimStart().split(/\s+/,1)[0]?.toLowerCase();if(scheme!=="bearer"&&scheme!=="dpop")return{};let resourceMetadata=field(header,"resource_metadata"),resourceMetadataUrl;if(resourceMetadata)try{resourceMetadataUrl=new URL(resourceMetadata)}catch{}return{resourceMetadataUrl,scope:field(header,"scope"),error:field(header,"error"),errorDescription:field(header,"error_description")}}async function fetchMetadata(url,fetch,protocolVersion,signal){return fetch(url,{headers:{Accept:"application/json","MCP-Protocol-Version":protocolVersion},signal})}async function discoverProtectedResourceMetadata(serverUrl,options={}){let server=new URL(serverUrl),fetch=options.fetch??globalThis.fetch,version=options.protocolVersion??LATEST_PROTOCOL_VERSION,response=await fetchMetadata(options.resourceMetadataUrl?new URL(options.resourceMetadataUrl):new URL(`/.well-known/oauth-protected-resource${pathSuffix(server.pathname)}`,server.origin),fetch,version,options.signal);if(!options.resourceMetadataUrl&&server.pathname!=="/"&&isDiscoveryMiss(response.status)&&(discard(response),response=await fetchMetadata(new URL("/.well-known/oauth-protected-resource",server.origin),fetch,version,options.signal)),!response.ok)throw discard(response),new Error(`HTTP ${response.status} loading OAuth protected resource metadata`);return parseProtectedResourceMetadata(await response.json())}function buildAuthorizationServerDiscoveryUrls(authorizationServerUrl){let issuer=new URL(authorizationServerUrl),path=pathSuffix(issuer.pathname),urls=[{url:new URL(`/.well-known/oauth-authorization-server${path}`,issuer.origin),type:"oauth"},{url:new URL(`/.well-known/openid-configuration${path}`,issuer.origin),type:"oidc"}];return path&&urls.push({url:new URL(`${path}/.well-known/openid-configuration`,issuer.origin),type:"oidc"}),urls}async function discoverAuthorizationServerMetadata(authorizationServerUrl,options={}){let fetch=options.fetch??globalThis.fetch;for(let{url}of buildAuthorizationServerDiscoveryUrls(authorizationServerUrl)){let response=await fetchMetadata(url,fetch,options.protocolVersion??LATEST_PROTOCOL_VERSION,options.signal);if(!response.ok){if(discard(response),isDiscoveryMiss(response.status))continue;throw new Error(`HTTP ${response.status} loading authorization server metadata from ${url}`)}let metadata=parseAuthorizationServerMetadata(await response.json());if(!options.skipIssuerValidation){let expected=String(authorizationServerUrl),trim=value=>value.endsWith("/")?value.slice(0,-1):value;if(trim(metadata.issuer)!==trim(expected))throw new OAuthIssuerMismatchError(expected,metadata.issuer)}return metadata}}async function discoverOAuthServerInfo(serverUrl,options={}){let resourceMetadata;try{resourceMetadata=await discoverProtectedResourceMetadata(serverUrl,{resourceMetadataUrl:options.resourceMetadataUrl,fetch:options.fetch,signal:options.signal})}catch(error){if(error instanceof TypeError)throw error}if(options.authorizationServerMetadataUrl){let url=options.authorizationServerMetadataUrl,response=await fetchMetadata(url,options.fetch??globalThis.fetch,LATEST_PROTOCOL_VERSION,options.signal);if(!response.ok)throw discard(response),new Error(`HTTP ${response.status} loading authorization server metadata from ${url}`);let metadata=parseAuthorizationServerMetadata(await response.json());return{authorizationServerUrl:metadata.issuer,authorizationServerMetadata:metadata,resourceMetadata}}let authorizationServerUrl=resourceMetadata?.authorization_servers?.[0]??String(new URL("/",serverUrl));return{authorizationServerUrl,authorizationServerMetadata:await discoverAuthorizationServerMetadata(authorizationServerUrl,{fetch:options.fetch,skipIssuerValidation:options.skipIssuerValidation,signal:options.signal}),resourceMetadata}}function resourceUrlFromServerUrl(value){let url=new URL(value);return url.hash="",url}function selectResource(serverUrl,metadata){if(!metadata)return;let requested=resourceUrlFromServerUrl(serverUrl),configured=new URL(metadata.resource);if(requested.origin!==configured.origin)throw new Error(`Protected resource ${metadata.resource} does not match MCP server ${requested}`);let requestedPath=requested.pathname.endsWith("/")?requested.pathname:`${requested.pathname}/`,configuredPath=configured.pathname.endsWith("/")?configured.pathname:`${configured.pathname}/`;if(!requestedPath.startsWith(configuredPath))throw new Error(`Protected resource ${metadata.resource} does not match MCP server ${requested}`);return metadata.resource}function loopback(hostname){return hostname==="localhost"||hostname==="127.0.0.1"||hostname==="[::1]"||hostname==="::1"}function applicationType(redirectUris){return redirectUris.some(uri=>{if(!URL.canParse(uri))return!1;let url=new URL(uri);return url.protocol!=="http:"&&url.protocol!=="https:"||loopback(url.hostname)})?"native":"web"}function secureEndpoint(value){let url=new URL(value);if(url.protocol!=="https:"&&!loopback(url.hostname))throw new OAuthInsecureEndpointError(url.href);return url}function sameUrl(a,b){return a===b||URL.canParse(a)&&URL.canParse(b)&&new URL(a).href===new URL(b).href}function selectClientAuthMethod(information,supported){let hinted="token_endpoint_auth_method"in information?information.token_endpoint_auth_method:void 0;return hinted&&["client_secret_basic","client_secret_post","none"].includes(hinted)&&(supported.length===0||supported.includes(hinted))?hinted:supported.length===0?information.client_secret?"client_secret_basic":"none":information.client_secret&&supported.includes("client_secret_basic")?"client_secret_basic":information.client_secret&&supported.includes("client_secret_post")?"client_secret_post":supported.includes("none")?"none":information.client_secret?"client_secret_post":"none"}function applyClientAuthentication(method,information,headers,params){if(method==="client_secret_basic"){if(!information.client_secret)throw new Error("client_secret_basic requires a client secret");headers.set("Authorization",`Basic ${Buffer.from(`${information.client_id}:${information.client_secret}`).toString("base64")}`)}else params.set("client_id",information.client_id),method==="client_secret_post"&&information.client_secret&&params.set("client_secret",information.client_secret)}async function pkce(){let bytes=crypto.getRandomValues(new Uint8Array(32)),verifier=Buffer.from(bytes).toString("base64url"),digest=await crypto.subtle.digest("SHA-256",new TextEncoder().encode(verifier));return{verifier,challenge:Buffer.from(digest).toString("base64url")}}async function startAuthorization(authorizationServerUrl,options){let metadata=options.metadata;if(metadata&&!metadata.response_types_supported.includes("code"))throw new Error("Authorization server does not support authorization codes");if(metadata?.code_challenge_methods_supported&&!metadata.code_challenge_methods_supported.includes("S256"))throw new Error("Authorization server does not support PKCE S256");let url=new URL(metadata?.authorization_endpoint??new URL("/authorize",authorizationServerUrl)),{verifier,challenge}=await pkce();return url.searchParams.set("response_type","code"),url.searchParams.set("client_id",options.clientInformation.client_id),url.searchParams.set("code_challenge",challenge),url.searchParams.set("code_challenge_method","S256"),url.searchParams.set("redirect_uri",String(options.redirectUrl)),options.state&&url.searchParams.set("state",options.state),options.scope&&url.searchParams.set("scope",options.scope),options.scope?.split(/\s+/).includes("offline_access")&&url.searchParams.set("prompt","consent"),options.resource&&url.searchParams.set("resource",options.resource),{authorizationUrl:url,codeVerifier:verifier}}async function tokenRequest(authorizationServerUrl,options,params){let url=secureEndpoint(options.metadata?.token_endpoint??new URL("/token",authorizationServerUrl)),headers=new Headers({Accept:"application/json","content-type":"application/x-www-form-urlencoded"});options.resource&&params.set("resource",options.resource),options.addClientAuthentication?await options.addClientAuthentication(headers,params,url,options.metadata):applyClientAuthentication(selectClientAuthMethod(options.clientInformation,options.metadata?.token_endpoint_auth_methods_supported??[]),options.clientInformation,headers,params);let response=await(options.fetch??globalThis.fetch)(url,{method:"POST",headers,body:params,signal:options.signal}),text=await response.text(),value;try{value=JSON.parse(text)}catch{}if(isObject(value)&&typeof value.error=="string")throw new OAuthError(value.error,typeof value.error_description=="string"?value.error_description:value.error,typeof value.error_uri=="string"?value.error_uri:void 0);if(!response.ok)throw new OAuthError("server_error",`HTTP ${response.status}: ${text}`);return parseOAuthTokens(value)}async function registerClient(authorizationServerUrl,options){let endpoint=options.metadata?.registration_endpoint;if(options.metadata&&!endpoint)throw new Error("Authorization server does not support dynamic client registration");let response=await(options.fetch??globalThis.fetch)(new URL(endpoint??new URL("/register",authorizationServerUrl)),{method:"POST",headers:{Accept:"application/json","content-type":"application/json"},body:JSON.stringify({...options.clientMetadata,application_type:options.clientMetadata.application_type??applicationType(options.clientMetadata.redirect_uris),...options.scope?{scope:options.scope}:{}}),signal:options.signal});if(!response.ok)throw new OAuthRegistrationError(response.status,await response.text());return parseClientInformation(await response.json())}async function exchangeAuthorizationCode(authorizationServerUrl,options){return tokenRequest(authorizationServerUrl,options,new URLSearchParams({grant_type:"authorization_code",code:options.code,code_verifier:options.codeVerifier,redirect_uri:String(options.redirectUrl)}))}async function refreshAuthorization(authorizationServerUrl,options){let tokens=await tokenRequest(authorizationServerUrl,options,new URLSearchParams({grant_type:"refresh_token",refresh_token:options.refreshToken}));return{refresh_token:options.refreshToken,...tokens}}function withScope(tokens,scope){return tokens.scope===void 0&&scope?{...tokens,scope}:tokens}function stepUpScope(granted,challenged){if(!challenged)return;let scopes=[granted,challenged].flatMap(scope=>scope?.split(/\s+/).filter(Boolean)??[]);return[...new Set(scopes)].join(" ")}async function runFlow(provider,options){let metadataUrl=options.authorizationServerMetadataUrl&&secureEndpoint(options.authorizationServerMetadataUrl),cached=metadataUrl?void 0:await provider.discoveryState?.(),discovered=cached?.authorizationServerUrl?{authorizationServerUrl:cached.authorizationServerUrl,authorizationServerMetadata:cached.authorizationServerMetadata??await discoverAuthorizationServerMetadata(cached.authorizationServerUrl,{fetch:options.fetch,skipIssuerValidation:options.skipIssuerValidation,signal:options.signal}),resourceMetadata:cached.resourceMetadata}:await discoverOAuthServerInfo(options.serverUrl,{resourceMetadataUrl:options.resourceMetadataUrl,authorizationServerMetadataUrl:metadataUrl,fetch:options.fetch,skipIssuerValidation:options.skipIssuerValidation,signal:options.signal});metadataUrl||await provider.saveDiscoveryState?.({...discovered,...options.resourceMetadataUrl?{resourceMetadataUrl:options.resourceMetadataUrl.href}:{}});let metadata=discovered.authorizationServerMetadata,resource=selectResource(options.serverUrl,discovered.resourceMetadata),scope=options.scope||discovered.resourceMetadata?.scopes_supported?.join(" ")||provider.clientMetadata.scope,stored=await provider.clientInformation(),clientDocument=stored?void 0:provider.clientMetadataDocument?.(metadata);if(clientDocument){let url=new URL(clientDocument.url);if(url.protocol!=="https:"||url.pathname==="/")throw new Error("Invalid OAuth client metadata URL")}let client=stored??(clientDocument&&{client_id:clientDocument.url});if(!client){if(options.authorizationCode)throw new Error("OAuth client information is missing during code exchange");if(!provider.saveClientInformation)throw new Error("OAuth client information cannot be persisted");client=await registerClient(discovered.authorizationServerUrl,{metadata,clientMetadata:provider.clientMetadata,scope,fetch:options.fetch,signal:options.signal}),await provider.saveClientInformation(client)}let redirectUrl=clientDocument?.redirectUrl??provider.redirectUrl,tokenOptions={metadata,clientInformation:client,resource,addClientAuthentication:provider.addClientAuthentication,fetch:options.fetch,signal:options.signal};if(options.authorizationCode){let iss=options.iss;if(metadata){if((iss!==void 0||metadata.authorization_response_iss_parameter_supported)&&iss!==metadata.issuer)throw new OAuthIssuerMismatchError(metadata.issuer,iss)}else if(iss!==void 0&&!sameUrl(iss,discovered.authorizationServerUrl))throw new OAuthIssuerMismatchError(discovered.authorizationServerUrl,iss);let tokens=await exchangeAuthorizationCode(discovered.authorizationServerUrl,{...tokenOptions,code:options.authorizationCode,codeVerifier:await provider.codeVerifier(),redirectUrl});return await provider.saveTokens(withScope(tokens,scope)),"AUTHORIZED"}let existing=options.skipRefresh?void 0:await provider.tokens();if(existing?.refresh_token)try{let tokens=await refreshAuthorization(discovered.authorizationServerUrl,{...tokenOptions,refreshToken:existing.refresh_token});return await provider.saveTokens(withScope(tokens,existing.scope)),"AUTHORIZED"}catch(error){if(options.signal?.aborted||error instanceof OAuthInsecureEndpointError||error instanceof OAuthError&&error.code!=="server_error")throw error}let state=await provider.state?.(),authorization=await startAuthorization(discovered.authorizationServerUrl,{metadata,clientInformation:client,redirectUrl,scope,state,resource});return await provider.saveCodeVerifier(authorization.codeVerifier),await provider.redirectToAuthorization(authorization.authorizationUrl),"REDIRECT"}async function authorizeMcp(provider,options){try{return await runFlow(provider,options)}catch(error){if(error instanceof OAuthError&&["invalid_client","unauthorized_client"].includes(error.code))return await provider.invalidateCredentials?.("all"),runFlow(provider,options);if(error instanceof OAuthError&&error.code==="invalid_grant")return await provider.invalidateCredentials?.("tokens"),runFlow(provider,options);throw error}}var MemoryOAuthStateStore=class{value;load(){return this.value===void 0?void 0:structuredClone(this.value)}save(state){this.value=structuredClone(state)}},McpOAuthProvider=class{redirectUrl;clientMetadata;clientMetadataDocument;serverUrl;configuredClient;store;onRedirect;writes=Promise.resolve();constructor(options){this.serverUrl=String(new URL(options.serverUrl)),this.redirectUrl=String(options.redirectUrl),this.clientMetadata={...options.clientMetadata,redirect_uris:options.clientMetadata.redirect_uris??[this.redirectUrl],grant_types:options.clientMetadata.grant_types??["authorization_code","refresh_token"],response_types:options.clientMetadata.response_types??["code"],token_endpoint_auth_method:options.clientMetadata.token_endpoint_auth_method??(options.clientSecret?"client_secret_post":"none")},this.clientMetadataDocument=options.clientMetadataDocument,this.configuredClient=options.clientId?{client_id:options.clientId,...options.clientSecret?{client_secret:options.clientSecret}:{}}:void 0,this.store=options.store??new MemoryOAuthStateStore,this.onRedirect=options.onRedirect}async state(){let existing=(await this.load()).oauthState;if(existing)return existing;let state=Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString("hex");return await this.update(value=>({...value,oauthState:state})),state}async clientInformation(){return this.configuredClient??(await this.load()).clientInformation}async saveClientInformation(information){this.configuredClient||await this.update(value=>({...value,clientInformation:information}))}async tokens(){return(await this.load()).tokens}async saveTokens(tokens){let expiresAt=tokens.expires_in===void 0?void 0:Date.now()+tokens.expires_in*1e3;await this.update(value=>{let next={...value,tokens};return expiresAt===void 0?delete next.tokensExpireAt:next.tokensExpireAt=expiresAt,next})}async redirectToAuthorization(url){await this.onRedirect(url)}async saveCodeVerifier(verifier){await this.update(value=>({...value,codeVerifier:verifier}))}async codeVerifier(){let verifier=(await this.load()).codeVerifier;if(!verifier)throw new Error("No OAuth PKCE code verifier is stored");return verifier}async invalidateCredentials(kind){await this.update(value=>{let next={...value};return(kind==="all"||kind==="client")&&delete next.clientInformation,(kind==="all"||kind==="tokens")&&(delete next.tokens,delete next.tokensExpireAt),(kind==="all"||kind==="verifier")&&delete next.codeVerifier,(kind==="all"||kind==="discovery")&&delete next.discovery,kind==="all"&&delete next.oauthState,next})}async saveDiscoveryState(discovery){await this.update(value=>({...value,discovery}))}async discoveryState(){return(await this.load()).discovery}async load(){return await this.writes,this.own(await this.store.load())}async update(update){this.writes=this.writes.then(async()=>{await this.store.save(update(this.own(await this.store.load())))}),await this.writes}own(state){return state?.serverUrl===this.serverUrl?state:{serverUrl:this.serverUrl}}};import{createHash}from"node:crypto";import{mkdirSync}from"node:fs";import{join}from"node:path";var LOGO_SVG='<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 96 96" aria-hidden="true"><defs><radialGradient id="kc-disc" cx="32%" cy="26%" r="88%"><stop offset="0" stop-color="#ffb473"/><stop offset=".45" stop-color="#ff7f2a"/><stop offset="1" stop-color="#d24d07"/></radialGradient><linearGradient id="kc-eye" x1="0" y1="1" x2="1" y2="0"><stop offset="0" stop-color="#ff8a3d"/><stop offset="1" stop-color="#fff3e3"/></linearGradient><filter id="kc-glow" x="-300%" y="-300%" width="700%" height="700%"><feGaussianBlur stdDeviation="1.7"/></filter></defs><circle cx="48" cy="47.4" r="43.4" fill="url(#kc-disc)"/><g fill="#0b0b0f"><path fill-rule="evenodd" d="M46.8 15.2L49.4 15.8L53.4 17.7L65.2 27.1L67.4 29.9L63.9 36.1L69.7 32.7L73.4 40.1L73.3 41.3L67.7 48.8L74.5 44.2L75.4 48.3L75.8 53.3L72.7 57.0L67.9 60.7L71.7 59.5L75.4 57.2L75.3 59.8L72.6 68.5L66.5 70.5L64.6 72.1L63.4 74.0L63.0 75.8L63.4 77.4L66.6 78.5L67.2 79.3L33.8 79.4L34.2 78.1L32.9 75.8L32.4 73.4L32.4 71.1L33.4 67.7L36.4 62.6L46.0 51.2L47.7 48.1L48.5 45.0L44.7 49.3L40.6 49.0L36.9 49.3L33.6 50.5L29.8 53.0L23.5 47.6L24.0 44.4L27.9 41.8L31.5 38.7L33.4 36.3L35.1 32.6L48.6 23.2L46.8 15.2ZM50.5 41.0L50.7 46.1L50.1 48.5L48.8 51.8L45.8 56.5L40.4 63.8L38.1 68.5L37.6 70.9L37.6 73.4L38.3 75.8L39.7 78.2L36.8 78.0L35.3 76.2L34.4 73.2L34.7 69.9L36.6 65.6L38.7 62.6L45.9 54.2L48.4 50.5L50.1 46.2L50.7 42.9L50.5 41.0Z"/><rect x="31.8" y="78.2" width="36.1" height="5.2" rx="2.2"/><rect x="29.1" y="82.7" width="42" height="9.3" rx="2.6"/></g><path d="M36.8 38.5L38.9 35.5L45.1 33.0L42.0 37.0L36.8 38.6Z" fill="#ff7a1a" filter="url(#kc-glow)"/><path d="M36.8 38.5L38.9 35.5L45.1 33.0L42.0 37.0L36.8 38.6Z" fill="url(#kc-eye)"/></svg>',BRAND_LABELS={anthropic:"Anthropic",githubCopilot:"GitHub Copilot",kimiCoding:"Kimi For Coding",openaiCodex:"OpenAI Codex",openrouter:"OpenRouter",radius:"Radius",xai:"xAI"},BRAND_MARKS={anthropic:'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" fill-rule="evenodd" aria-hidden="true"><path d="M13.827 3.52h3.603L24 20h-3.603l-6.57-16.48zm-7.258 0h3.767L16.906 20h-3.674l-1.343-3.461H5.017l-1.344 3.46H0L6.57 3.522zm4.132 9.959L8.453 7.687 6.205 13.48H10.7z"/></svg>',githubCopilot:'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" fill-rule="evenodd" aria-hidden="true"><path d="M19.245 5.364c1.322 1.36 1.877 3.216 2.11 5.817.622 0 1.2.135 1.592.654l.73.964c.21.278.323.61.323.955v2.62c0 .339-.173.669-.453.868C20.239 19.602 16.157 21.5 12 21.5c-4.6 0-9.205-2.583-11.547-4.258-.28-.2-.452-.53-.453-.868v-2.62c0-.345.113-.679.321-.956l.73-.963c.392-.517.974-.654 1.593-.654l.029-.297c.25-2.446.81-4.213 2.082-5.52 2.461-2.54 5.71-2.851 7.146-2.864h.198c1.436.013 4.685.323 7.146 2.864zm-7.244 4.328c-.284 0-.613.016-.962.05-.123.447-.305.85-.57 1.108-1.05 1.023-2.316 1.18-2.994 1.18-.638 0-1.306-.13-1.851-.464-.516.165-1.012.403-1.044.996a65.882 65.882 0 00-.063 2.884l-.002.48c-.002.563-.005 1.126-.013 1.69.002.326.204.63.51.765 2.482 1.102 4.83 1.657 6.99 1.657 2.156 0 4.504-.555 6.985-1.657a.854.854 0 00.51-.766c.03-1.682.006-3.372-.076-5.053-.031-.596-.528-.83-1.046-.996-.546.333-1.212.464-1.85.464-.677 0-1.942-.157-2.993-1.18-.266-.258-.447-.661-.57-1.108-.32-.032-.64-.049-.96-.05zm-2.525 4.013c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zm5 0c.539 0 .976.426.976.95v1.753c0 .525-.437.95-.976.95a.964.964 0 01-.976-.95v-1.752c0-.525.437-.951.976-.951zM7.635 5.087c-1.05.102-1.935.438-2.385.906-.975 1.037-.765 3.668-.21 4.224.405.394 1.17.657 1.995.657h.09c.649-.013 1.785-.176 2.73-1.11.435-.41.705-1.433.675-2.47-.03-.834-.27-1.52-.63-1.813-.39-.336-1.275-.482-2.265-.394zm6.465.394c-.36.292-.6.98-.63 1.813-.03 1.037.24 2.06.675 2.47.968.957 2.136 1.104 2.776 1.11h.044c.825 0 1.59-.263 1.995-.657.555-.556.765-3.187-.21-4.224-.45-.468-1.335-.804-2.385-.906-.99-.088-1.875.058-2.265.394zM12 7.615c-.24 0-.525.015-.84.044.03.16.045.336.06.526l-.001.159a2.94 2.94 0 01-.014.25c.225-.022.425-.027.612-.028h.366c.187 0 .387.006.612.028-.015-.146-.015-.277-.015-.409.015-.19.03-.365.06-.526a9.29 9.29 0 00-.84-.044z"/></svg>',kimiCoding:'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" fill-rule="evenodd" aria-hidden="true"><path d="M21.846 0a1.923 1.923 0 110 3.846H20.15a.226.226 0 01-.227-.226V1.923C19.923.861 20.784 0 21.846 0z"/><path d="M11.065 11.199l7.257-7.2c.137-.136.06-.41-.116-.41H14.3a.164.164 0 00-.117.051l-7.82 7.756c-.122.12-.302.013-.302-.179V3.82c0-.127-.083-.23-.185-.23H3.186c-.103 0-.186.103-.186.23V19.77c0 .128.083.23.186.23h2.69c.103 0 .186-.102.186-.23v-3.25c0-.069.025-.135.069-.178l2.424-2.406a.158.158 0 01.205-.023l6.484 4.772a7.677 7.677 0 003.453 1.283c.108.012.2-.095.2-.23v-3.06c0-.117-.07-.212-.164-.227a5.028 5.028 0 01-2.027-.807l-5.613-4.064c-.117-.078-.132-.279-.028-.381z"/></svg>',openaiCodex:'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" fill-rule="evenodd" aria-hidden="true"><path d="M9.205 8.658v-2.26c0-.19.072-.333.238-.428l4.543-2.616c.619-.357 1.356-.523 2.117-.523 2.854 0 4.662 2.212 4.662 4.566 0 .167 0 .357-.024.547l-4.71-2.759a.797.797 0 00-.856 0l-5.97 3.473zm10.609 8.8V12.06c0-.333-.143-.57-.429-.737l-5.97-3.473 1.95-1.118a.433.433 0 01.476 0l4.543 2.617c1.309.76 2.189 2.378 2.189 3.948 0 1.808-1.07 3.473-2.76 4.163zM7.802 12.703l-1.95-1.142c-.167-.095-.239-.238-.239-.428V5.899c0-2.545 1.95-4.472 4.591-4.472 1 0 1.927.333 2.712.928L8.23 5.067c-.285.166-.428.404-.428.737v6.898zM12 15.128l-2.795-1.57v-3.33L12 8.658l2.795 1.57v3.33L12 15.128zm1.796 7.23c-1 0-1.927-.332-2.712-.927l4.686-2.712c.285-.166.428-.404.428-.737v-6.898l1.974 1.142c.167.095.238.238.238.428v5.233c0 2.545-1.974 4.472-4.614 4.472zm-5.637-5.303l-4.544-2.617c-1.308-.761-2.188-2.378-2.188-3.948A4.482 4.482 0 014.21 6.327v5.423c0 .333.143.571.428.738l5.947 3.449-1.95 1.118a.432.432 0 01-.476 0zm-.262 3.9c-2.688 0-4.662-2.021-4.662-4.519 0-.19.024-.38.047-.57l4.686 2.71c.286.167.571.167.856 0l5.97-3.448v2.26c0 .19-.07.333-.237.428l-4.543 2.616c-.619.357-1.356.523-2.117.523zm5.899 2.83a5.947 5.947 0 005.827-4.756C22.287 18.339 24 15.84 24 13.296c0-1.665-.713-3.282-1.998-4.448.119-.5.19-.999.19-1.498 0-3.401-2.759-5.947-5.946-5.947-.642 0-1.26.095-1.88.31A5.962 5.962 0 0010.205 0a5.947 5.947 0 00-5.827 4.757C1.713 5.447 0 7.945 0 10.49c0 1.666.713 3.283 1.998 4.448-.119.5-.19 1-.19 1.499 0 3.401 2.759 5.946 5.946 5.946.642 0 1.26-.095 1.88-.309a5.96 5.96 0 004.162 1.713z"/></svg>',openrouter:'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" fill-rule="evenodd" aria-hidden="true"><path d="M18.654 3.87a5.087 5.087 0 110 10.174L23.7 19.09c.64.641.187 1.737-.72 1.737H8.48a8.479 8.479 0 010-16.958h10.175zM8.479 7.26a5.087 5.087 0 100 10.176 5.087 5.087 0 000-10.175z"/></svg>',radius:'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.6" aria-hidden="true"><circle cx="12" cy="12" r="9.2"/><path d="M12 12 18.5 5.5" stroke-linecap="round"/><circle cx="12" cy="12" r="1.5" fill="currentColor" stroke="none"/></svg>',xai:'<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" fill-rule="evenodd" aria-hidden="true"><path d="M6.469 8.776L16.512 23h-4.464L2.005 8.776H6.47zm-.004 7.9l2.233 3.164L6.467 23H2l4.465-6.324zM22 2.582V23h-3.659V7.764L22 2.582zM22 1l-9.952 14.095-2.233-3.163L17.533 1H22z"/></svg>'};function escapeHtml(value){return value.replaceAll("&","&amp;").replaceAll("<","&lt;").replaceAll(">","&gt;").replaceAll('"',"&quot;").replaceAll("'","&#39;")}function renderPage(options){let title=escapeHtml(options.title),heading=escapeHtml(options.heading),message=escapeHtml(options.message),details=options.details?escapeHtml(options.details):void 0,brandMark=options.brand?BRAND_MARKS[options.brand]:void 0,brandLabel=options.brand?escapeHtml(BRAND_LABELS[options.brand]):void 0,knight=`<span class="mark mark-knight" role="img" aria-label="KnightCode">${LOGO_SVG}</span>`,marks=brandMark?`<div class="marks">
       <span class="mark mark-brand" role="img" aria-label="${brandLabel}">${brandMark}</span>

package/dist/bundle/chunks/{chunk-MXIWLMNT.js → chunk-CCP7VAJU.js}

@@ -5,4 +5,4 @@ import{__export}from"./chunk-AHB7JV5B.js";var build_exports={};__export(build_ex
 `,input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(Const(",",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2(If2(Const(";",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2(If2(Const(`
 `,input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>[]))))),([_0,input2])=>[_0,input2]),PropertyList_0=(input,result=[])=>If2(If2(PropertyDelimiter(input),([_0,input2])=>If2(Property(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>PropertyList_0(input2,[...result,_0]),()=>[result,input]),PropertyList=input=>If2(If2(If2(Property(input),([_0,input2])=>If2(PropertyList_0(input2),([_1,input3])=>If2(If2(PropertyDelimiter(input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[PropertyListMapping(_0),input2]),Properties=input=>If2(If2(Const("{",input),([_0,input2])=>If2(PropertyList(input2),([_1,input3])=>If2(Const("}",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[PropertiesMapping(_0),input2]),_Object_2=input=>If2(Properties(input),([_0,input2])=>[_Object_Mapping(_0),input2]),ElementNamed=input=>If2(If2(If2(Ident(input),([_0,input2])=>If2(Const("?",input2),([_1,input3])=>If2(Const(":",input3),([_2,input4])=>If2(Const("readonly",input4),([_3,input5])=>If2(Type(input5),([_4,input6])=>[[_0,_1,_2,_3,_4],input6]))))),([_0,input2])=>[_0,input2],()=>If2(If2(Ident(input),([_0,input2])=>If2(Const(":",input2),([_1,input3])=>If2(Const("readonly",input3),([_2,input4])=>If2(Type(input4),([_3,input5])=>[[_0,_1,_2,_3],input5])))),([_0,input2])=>[_0,input2],()=>If2(If2(Ident(input),([_0,input2])=>If2(Const("?",input2),([_1,input3])=>If2(Const(":",input3),([_2,input4])=>If2(Type(input4),([_3,input5])=>[[_0,_1,_2,_3],input5])))),([_0,input2])=>[_0,input2],()=>If2(If2(Ident(input),([_0,input2])=>If2(Const(":",input2),([_1,input3])=>If2(Type(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>[])))),([_0,input2])=>[ElementNamedMapping(_0),input2]),ElementBase=input=>If2(If2(ElementNamed(input),([_0,input2])=>[_0,input2],()=>If2(If2(Readonly2(input),([_0,input2])=>If2(Type(input2),([_1,input3])=>If2(Optional3(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ElementBaseMapping(_0),input2]),Element=input=>If2(If2(If2(Const("...",input),([_0,input2])=>If2(ElementBase(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(ElementBase(input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ElementMapping(_0),input2]),ElementList_0=(input,result=[])=>If2(If2(Const(",",input),([_0,input2])=>If2(Element(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>ElementList_0(input2,[...result,_0]),()=>[result,input]),ElementList=input=>If2(If2(If2(Element(input),([_0,input2])=>If2(ElementList_0(input2),([_1,input3])=>If2(If2(Const(",",input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ElementListMapping(_0),input2]),_Tuple_=input=>If2(If2(Const("[",input),([_0,input2])=>If2(ElementList(input2),([_1,input3])=>If2(Const("]",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_Tuple_Mapping(_0),input2]),ParameterReadonlyOptional=input=>If2(If2(Ident(input),([_0,input2])=>If2(Const("?",input2),([_1,input3])=>If2(Const(":",input3),([_2,input4])=>If2(Const("readonly",input4),([_3,input5])=>If2(Type(input5),([_4,input6])=>[[_0,_1,_2,_3,_4],input6]))))),([_0,input2])=>[ParameterReadonlyOptionalMapping(_0),input2]),ParameterReadonly=input=>If2(If2(Ident(input),([_0,input2])=>If2(Const(":",input2),([_1,input3])=>If2(Const("readonly",input3),([_2,input4])=>If2(Type(input4),([_3,input5])=>[[_0,_1,_2,_3],input5])))),([_0,input2])=>[ParameterReadonlyMapping(_0),input2]),ParameterOptional=input=>If2(If2(Ident(input),([_0,input2])=>If2(Const("?",input2),([_1,input3])=>If2(Const(":",input3),([_2,input4])=>If2(Type(input4),([_3,input5])=>[[_0,_1,_2,_3],input5])))),([_0,input2])=>[ParameterOptionalMapping(_0),input2]),ParameterType=input=>If2(If2(Ident(input),([_0,input2])=>If2(Const(":",input2),([_1,input3])=>If2(Type(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[ParameterTypeMapping(_0),input2]),ParameterBase=input=>If2(If2(ParameterReadonlyOptional(input),([_0,input2])=>[_0,input2],()=>If2(ParameterReadonly(input),([_0,input2])=>[_0,input2],()=>If2(ParameterOptional(input),([_0,input2])=>[_0,input2],()=>If2(ParameterType(input),([_0,input2])=>[_0,input2],()=>[])))),([_0,input2])=>[_0,input2]),Parameter2=input=>If2(If2(If2(Const("...",input),([_0,input2])=>If2(ParameterBase(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(ParameterBase(input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ParameterMapping(_0),input2]),ParameterList_0=(input,result=[])=>If2(If2(Const(",",input),([_0,input2])=>If2(Parameter2(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>ParameterList_0(input2,[...result,_0]),()=>[result,input]),ParameterList=input=>If2(If2(If2(Parameter2(input),([_0,input2])=>If2(ParameterList_0(input2),([_1,input3])=>If2(If2(Const(",",input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ParameterListMapping(_0),input2]),_Function_2=input=>If2(If2(Const("(",input),([_0,input2])=>If2(ParameterList(input2),([_1,input3])=>If2(Const(")",input3),([_2,input4])=>If2(Const("=>",input4),([_3,input5])=>If2(Type(input5),([_4,input6])=>[[_0,_1,_2,_3,_4],input6]))))),([_0,input2])=>[_Function_Mapping(_0),input2]),_Constructor_=input=>If2(If2(Const("new",input),([_0,input2])=>If2(Const("(",input2),([_1,input3])=>If2(ParameterList(input3),([_2,input4])=>If2(Const(")",input4),([_3,input5])=>If2(Const("=>",input5),([_4,input6])=>If2(Type(input6),([_5,input7])=>[[_0,_1,_2,_3,_4,_5],input7])))))),([_0,input2])=>[_Constructor_Mapping(_0),input2]),MappedReadonly=input=>If2(If2(If2(Const("+",input),([_0,input2])=>If2(Const("readonly",input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(Const("-",input),([_0,input2])=>If2(Const("readonly",input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(Const("readonly",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])))),([_0,input2])=>[MappedReadonlyMapping(_0),input2]),MappedOptional=input=>If2(If2(If2(Const("+",input),([_0,input2])=>If2(Const("?",input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(Const("-",input),([_0,input2])=>If2(Const("?",input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(Const("?",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])))),([_0,input2])=>[MappedOptionalMapping(_0),input2]),MappedAs=input=>If2(If2(If2(Const("as",input),([_0,input2])=>If2(Type(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[MappedAsMapping(_0),input2]),_Mapped_=input=>If2(If2(Const("{",input),([_0,input2])=>If2(MappedReadonly(input2),([_1,input3])=>If2(Const("[",input3),([_2,input4])=>If2(Ident(input4),([_3,input5])=>If2(Const("in",input5),([_4,input6])=>If2(Type(input6),([_5,input7])=>If2(MappedAs(input7),([_6,input8])=>If2(Const("]",input8),([_7,input9])=>If2(MappedOptional(input9),([_8,input10])=>If2(Const(":",input10),([_9,input11])=>If2(Type(input11),([_10,input12])=>If2(OptionalSemiColon(input12),([_11,input13])=>If2(Const("}",input13),([_12,input14])=>[[_0,_1,_2,_3,_4,_5,_6,_7,_8,_9,_10,_11,_12],input14]))))))))))))),([_0,input2])=>[_Mapped_Mapping(_0),input2]),Reference=input=>If2(Ident(input),([_0,input2])=>[ReferenceMapping(_0),input2]),WithBigInt=input=>If2(BigInt3(input),([_0,input2])=>[WithBigIntMapping(_0),input2]),WithNumber=input=>If2(Number3(input),([_0,input2])=>[WithNumberMapping(_0),input2]),WithBoolean=input=>If2(If2(Const("true",input),([_0,input2])=>[_0,input2],()=>If2(Const("false",input),([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[WithBooleanMapping(_0),input2]),WithString=input=>If2(String3(['"',"'"],input),([_0,input2])=>[_0,input2]),WithNull=input=>If2(Const("null",input),([_0,input2])=>[WithNullMapping(_0),input2]),WithUndefined=input=>If2(Const("undefined",input),([_0,input2])=>[void 0,input2]),WithProperty=input=>If2(If2(PropertyKey(input),([_0,input2])=>If2(Const(":",input2),([_1,input3])=>If2(WithValue(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[WithPropertyMapping(_0),input2]),WithPropertyList_0=(input,result=[])=>If2(If2(PropertyDelimiter(input),([_0,input2])=>If2(WithProperty(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>WithPropertyList_0(input2,[...result,_0]),()=>[result,input]),WithPropertyList=input=>If2(If2(If2(WithProperty(input),([_0,input2])=>If2(WithPropertyList_0(input2),([_1,input3])=>If2(If2(PropertyDelimiter(input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[WithPropertyListMapping(_0),input2]),WithObject=input=>If2(If2(Const("{",input),([_0,input2])=>If2(WithPropertyList(input2),([_1,input3])=>If2(Const("}",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[WithObjectMapping(_0),input2]),WithElementList_0=(input,result=[])=>If2(If2(Const(",",input),([_0,input2])=>If2(WithValue(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>WithElementList_0(input2,[...result,_0]),()=>[result,input]),WithElementList=input=>If2(If2(If2(WithValue(input),([_0,input2])=>If2(WithElementList_0(input2),([_1,input3])=>If2(If2(Const(",",input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[WithElementListMapping(_0),input2]),WithArray=input=>If2(If2(Const("[",input),([_0,input2])=>If2(WithElementList(input2),([_1,input3])=>If2(Const("]",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[WithArrayMapping(_0),input2]),WithValue=input=>If2(If2(WithBigInt(input),([_0,input2])=>[_0,input2],()=>If2(WithNumber(input),([_0,input2])=>[_0,input2],()=>If2(WithBoolean(input),([_0,input2])=>[_0,input2],()=>If2(WithString(input),([_0,input2])=>[_0,input2],()=>If2(WithNull(input),([_0,input2])=>[_0,input2],()=>If2(WithUndefined(input),([_0,input2])=>[_0,input2],()=>If2(WithObject(input),([_0,input2])=>[_0,input2],()=>If2(WithArray(input),([_0,input2])=>[_0,input2],()=>[])))))))),([_0,input2])=>[_0,input2]),PatternBigInt=input=>If2(Const("-?(?:0|[1-9][0-9]*)n",input),([_0,input2])=>[PatternBigIntMapping(_0),input2]),PatternString=input=>If2(Const(".*",input),([_0,input2])=>[PatternStringMapping(_0),input2]),PatternNumber=input=>If2(Const("-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?",input),([_0,input2])=>[PatternNumberMapping(_0),input2]),PatternInteger=input=>If2(Const("-?(?:0|[1-9][0-9]*)",input),([_0,input2])=>[PatternIntegerMapping(_0),input2]),PatternNever=input=>If2(Const("(?!)",input),([_0,input2])=>[PatternNeverMapping(_0),input2]),PatternText=input=>If2(Until_1(["-?(?:0|[1-9][0-9]*)n",".*","-?(?:0|[1-9][0-9]*)(?:\\.[0-9]+)?","-?(?:0|[1-9][0-9]*)","(?!)","(",")","$","|"],input),([_0,input2])=>[PatternTextMapping(_0),input2]),PatternBase=input=>If2(If2(PatternBigInt(input),([_0,input2])=>[_0,input2],()=>If2(PatternString(input),([_0,input2])=>[_0,input2],()=>If2(PatternNumber(input),([_0,input2])=>[_0,input2],()=>If2(PatternInteger(input),([_0,input2])=>[_0,input2],()=>If2(PatternNever(input),([_0,input2])=>[_0,input2],()=>If2(PatternGroup(input),([_0,input2])=>[_0,input2],()=>If2(PatternText(input),([_0,input2])=>[_0,input2],()=>[]))))))),([_0,input2])=>[_0,input2]),PatternGroup=input=>If2(If2(Const("(",input),([_0,input2])=>If2(PatternBody(input2),([_1,input3])=>If2(Const(")",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[PatternGroupMapping(_0),input2]),PatternUnion=input=>If2(If2(If2(PatternTerm(input),([_0,input2])=>If2(Const("|",input2),([_1,input3])=>If2(PatternUnion(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2(If2(PatternTerm(input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[]))),([_0,input2])=>[PatternUnionMapping(_0),input2]),PatternTerm=input=>If2(If2(PatternBase(input),([_0,input2])=>If2(PatternBody(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[PatternTermMapping(_0),input2]),PatternBody=input=>If2(If2(PatternUnion(input),([_0,input2])=>[_0,input2],()=>If2(PatternTerm(input),([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[_0,input2]),Pattern=input=>If2(If2(Const("^",input),([_0,input2])=>If2(PatternBody(input2),([_1,input3])=>If2(Const("$",input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[PatternMapping(_0),input2]),InterfaceDeclarationHeritageList_0=(input,result=[])=>If2(If2(Const(",",input),([_0,input2])=>If2(Type(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>InterfaceDeclarationHeritageList_0(input2,[...result,_0]),()=>[result,input]),InterfaceDeclarationHeritageList=input=>If2(If2(If2(Type(input),([_0,input2])=>If2(InterfaceDeclarationHeritageList_0(input2),([_1,input3])=>If2(If2(Const(",",input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[InterfaceDeclarationHeritageListMapping(_0),input2]),InterfaceDeclarationHeritage=input=>If2(If2(If2(Const("extends",input),([_0,input2])=>If2(InterfaceDeclarationHeritageList(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[InterfaceDeclarationHeritageMapping(_0),input2]),InterfaceDeclarationGeneric=input=>If2(If2(Const("interface",input),([_0,input2])=>If2(Ident(input2),([_1,input3])=>If2(GenericParameters(input3),([_2,input4])=>If2(InterfaceDeclarationHeritage(input4),([_3,input5])=>If2(Properties(input5),([_4,input6])=>[[_0,_1,_2,_3,_4],input6]))))),([_0,input2])=>[InterfaceDeclarationGenericMapping(_0),input2]),InterfaceDeclaration=input=>If2(If2(Const("interface",input),([_0,input2])=>If2(Ident(input2),([_1,input3])=>If2(InterfaceDeclarationHeritage(input3),([_2,input4])=>If2(Properties(input4),([_3,input5])=>[[_0,_1,_2,_3],input5])))),([_0,input2])=>[InterfaceDeclarationMapping(_0),input2]),TypeAliasDeclarationGeneric=input=>If2(If2(Const("type",input),([_0,input2])=>If2(Ident(input2),([_1,input3])=>If2(GenericParameters(input3),([_2,input4])=>If2(Const("=",input4),([_3,input5])=>If2(Type(input5),([_4,input6])=>[[_0,_1,_2,_3,_4],input6]))))),([_0,input2])=>[TypeAliasDeclarationGenericMapping(_0),input2]),TypeAliasDeclaration=input=>If2(If2(Const("type",input),([_0,input2])=>If2(Ident(input2),([_1,input3])=>If2(Const("=",input3),([_2,input4])=>If2(Type(input4),([_3,input5])=>[[_0,_1,_2,_3],input5])))),([_0,input2])=>[TypeAliasDeclarationMapping(_0),input2]),ExportKeyword=input=>If2(If2(If2(Const("export",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ExportKeywordMapping(_0),input2]),ModuleDeclarationDelimiter=input=>If2(If2(If2(Const(";",input),([_0,input2])=>If2(Const(`
 `,input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[_0,input2],()=>If2(If2(Const(";",input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>If2(If2(Const(`
-`,input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>[]))),([_0,input2])=>[_0,input2]),ModuleDeclarationList_0=(input,result=[])=>If2(If2(ModuleDeclarationDelimiter(input),([_0,input2])=>If2(ModuleDeclaration(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>ModuleDeclarationList_0(input2,[...result,_0]),()=>[result,input]),ModuleDeclarationList=input=>If2(If2(If2(ModuleDeclaration(input),([_0,input2])=>If2(ModuleDeclarationList_0(input2),([_1,input3])=>If2(If2(ModuleDeclarationDelimiter(input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ModuleDeclarationListMapping(_0),input2]),ModuleDeclaration=input=>If2(If2(ExportKeyword(input),([_0,input2])=>If2(If2(InterfaceDeclarationGeneric(input2),([_02,input3])=>[_02,input3],()=>If2(InterfaceDeclaration(input2),([_02,input3])=>[_02,input3],()=>If2(TypeAliasDeclarationGeneric(input2),([_02,input3])=>[_02,input3],()=>If2(TypeAliasDeclaration(input2),([_02,input3])=>[_02,input3],()=>[])))),([_1,input3])=>If2(OptionalSemiColon(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[ModuleDeclarationMapping(_0),input2]),Module=input=>If2(If2(ModuleDeclaration(input),([_0,input2])=>If2(ModuleDeclarationList(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[ModuleMapping(_0),input2]),Script=input=>If2(If2(Module(input),([_0,input2])=>[_0,input2],()=>If2(GenericType(input),([_0,input2])=>[_0,input2],()=>If2(Type(input),([_0,input2])=>[_0,input2],()=>[]))),([_0,input2])=>[_0,input2]);function ParseTemplateIntoTypes(template){let parsed=TemplateLiteralTypes(`\`${template}\``);return guard_exports.IsEqual(parsed.length,2)?parsed[0]:Unreachable()}function JoinString(input){return input.join("|")}function UnwrapTemplateLiteralPattern(pattern){return pattern.slice(1,pattern.length-1)}function EncodeLiteral(value,right,pattern){return EncodeTypes(right,`${pattern}${value}`)}function EncodeBigInt(right,pattern){return EncodeTypes(right,`${pattern}${BigIntPattern}`)}function EncodeInteger(right,pattern){return EncodeTypes(right,`${pattern}${IntegerPattern}`)}function EncodeNumber(right,pattern){return EncodeTypes(right,`${pattern}${NumberPattern}`)}function EncodeBoolean(right,pattern){return EncodeType(Union([Literal("false"),Literal("true")]),right,pattern)}function EncodeString(right,pattern){return EncodeTypes(right,`${pattern}${StringPattern}`)}function EncodeTemplateLiteral(templatePattern,right,pattern){return EncodeTypes(right,`${pattern}${UnwrapTemplateLiteralPattern(templatePattern)}`)}function EncodeTemplateLiteralDeferred(types,right,pattern){let templateLiteral=TemplateLiteralAction(types,{});return EncodeType(templateLiteral,right,pattern)}function EncodeEnum(values,right,pattern){let evaluated=EvaluateEnum(values);return EncodeType(evaluated,right,pattern)}function EncodeUnion(types,right,pattern,result=[]){return guard_exports.ShiftLeft(types,(head,tail)=>EncodeUnion(tail,right,pattern,[...result,EncodeType(head,[],"")]),()=>EncodeTypes(right,`${pattern}(${JoinString(result)})`))}function EncodeType(type,right,pattern){return IsEnum(type)?EncodeEnum(type.enum,right,pattern):IsInteger3(type)?EncodeInteger(right,pattern):IsLiteral(type)?EncodeLiteral(type.const,right,pattern):IsBigInt3(type)?EncodeBigInt(right,pattern):IsBoolean4(type)?EncodeBoolean(right,pattern):IsNumber4(type)?EncodeNumber(right,pattern):IsString4(type)?EncodeString(right,pattern):IsTemplateLiteral(type)?EncodeTemplateLiteral(type.pattern,right,pattern):IsTemplateLiteralDeferred(type)?EncodeTemplateLiteralDeferred(type.parameters[0],right,pattern):IsUnion(type)?EncodeUnion(type.anyOf,right,pattern):NeverPattern}function EncodeTypes(types,pattern){return guard_exports.ShiftLeft(types,(left,right)=>EncodeType(left,right,pattern),()=>pattern)}function EncodePattern(types){return`^${EncodeTypes(types,"")}$`}function TemplateLiteralEncode(types){let pattern=EncodePattern(types);return TemplateLiteralCreate(pattern)}function TemplateLiteralAction(types,options){return CanInstantiate(types)?memory_exports.Update(TemplateLiteralEncode(types),{},options):TemplateLiteralDeferred(types,options)}function TemplateLiteralInstantiate(context,state,types,options){let instantiatedTypes=InstantiateTypes(context,state,types);return TemplateLiteralAction(instantiatedTypes,options)}function TemplateLiteralDeferred(types,options={}){return Deferred("TemplateLiteral",[types],options)}function IsTemplateLiteralDeferred(value){return IsSchema(value)&&guard_exports.HasPropertyKey(value,"action")&&guard_exports.IsEqual(value.action,"TemplateLiteral")}function TemplateLiteralFromTypes(types){return TemplateLiteralAction(types,{})}function TemplateLiteralFromString(template){let types=ParseTemplateIntoTypes(template);return TemplateLiteralFromTypes(types)}function TemplateLiteral2(input,options={}){let type=guard_exports.IsString(input)?TemplateLiteralFromString(input):TemplateLiteralFromTypes(input);return memory_exports.Update(type,{},options)}function IsTemplateLiteral(value){return IsKind(value,"TemplateLiteral")}var result_exports={};__export(result_exports,{ExtendsFalse:()=>ExtendsFalse,ExtendsTrue:()=>ExtendsTrue,ExtendsUnion:()=>ExtendsUnion,IsExtendsFalse:()=>IsExtendsFalse,IsExtendsTrue:()=>IsExtendsTrue,IsExtendsTrueLike:()=>IsExtendsTrueLike,IsExtendsUnion:()=>IsExtendsUnion,Match:()=>Match3});function ExtendsUnion(inferred){return memory_exports.Create({"~kind":"ExtendsUnion"},{inferred})}function IsExtendsUnion(value){return guard_exports.IsObject(value)&&guard_exports.HasPropertyKey(value,"~kind")&&guard_exports.HasPropertyKey(value,"inferred")&&guard_exports.IsEqual(value["~kind"],"ExtendsUnion")&&guard_exports.IsObject(value.inferred)}function ExtendsTrue(inferred){return memory_exports.Create({"~kind":"ExtendsTrue"},{inferred})}function IsExtendsTrue(value){return guard_exports.IsObject(value)&&guard_exports.HasPropertyKey(value,"~kind")&&guard_exports.HasPropertyKey(value,"inferred")&&guard_exports.IsEqual(value["~kind"],"ExtendsTrue")&&guard_exports.IsObject(value.inferred)}function ExtendsFalse(){return memory_exports.Create({"~kind":"ExtendsFalse"},{})}function IsExtendsFalse(value){return guard_exports.IsObject(value)&&guard_exports.HasPropertyKey(value,"~kind")&&guard_exports.IsEqual(value["~kind"],"ExtendsFalse")}function IsExtendsTrueLike(value){return IsExtendsUnion(value)||IsExtendsTrue(value)}function Match3(result,true_,false_){return IsExtendsTrueLike(result)?true_(result.inferred):false_()}function ExtendsRightInfer(inferred,name,left,right){return Match3(ExtendsLeft(inferred,left,right),checkInferred=>ExtendsTrue(memory_exports.Assign(memory_exports.Assign(inferred,checkInferred),{[name]:left})),()=>ExtendsFalse())}function ExtendsRightAny(inferred,_left){return ExtendsTrue(inferred)}function ExtendsRightDependent(inferred,left,if_,then_,else_){return Match3(ExtendsLeft(inferred,left,if_),inferred2=>Match3(ExtendsLeft(inferred2,left,then_),inferred3=>ExtendsTrue(inferred3),()=>ExtendsFalse()),()=>Match3(ExtendsLeft(inferred,left,else_),inferred2=>ExtendsTrue(inferred2),()=>ExtendsFalse()))}function ExtendsRightEnum(inferred,left,right){let evaluated=EvaluateEnum(right);return ExtendsLeft(inferred,left,evaluated)}function ExtendsRightIntersect(inferred,left,right){return guard_exports.ShiftLeft(right,(head,tail)=>Match3(ExtendsLeft(inferred,left,head),inferred2=>ExtendsRightIntersect(inferred2,left,tail),()=>ExtendsFalse()),()=>ExtendsTrue(inferred))}function ExtendsRightTemplateLiteral(inferred,left,right){let evaluated=EvaluateTemplateLiteral(right);return ExtendsLeft(inferred,left,evaluated)}function ExtendsRightUnion(inferred,left,right){return guard_exports.ShiftLeft(right,(head,tail)=>Match3(ExtendsLeft(inferred,left,head),inferred2=>ExtendsTrue(inferred2),()=>ExtendsRightUnion(inferred,left,tail)),()=>ExtendsFalse())}function ExtendsRight(inferred,left,right){return IsAny(right)?ExtendsRightAny(inferred,left):IsDependent(right)?ExtendsRightDependent(inferred,left,right.if,right.then,right.else):IsEnum(right)?ExtendsRightEnum(inferred,left,right.enum):IsInfer(right)?ExtendsRightInfer(inferred,right.name,left,right.extends):IsIntersect(right)?ExtendsRightIntersect(inferred,left,right.allOf):IsTemplateLiteral(right)?ExtendsRightTemplateLiteral(inferred,left,right.pattern):IsUnion(right)?ExtendsRightUnion(inferred,left,right.anyOf):IsUnknown(right)?ExtendsTrue(inferred):ExtendsFalse()}function ExtendsAny(inferred,left,right){return IsInfer(right)?ExtendsRight(inferred,left,right):IsAny(right)?ExtendsTrue(inferred):IsUnknown(right)?ExtendsTrue(inferred):ExtendsUnion(inferred)}function ExtendsImmutable(left,right){let isImmutableLeft=IsImmutable(left),isImmutableRight=IsImmutable(right);return isImmutableLeft&&isImmutableRight||!isImmutableLeft&&isImmutableRight?!0:!(isImmutableLeft&&!isImmutableRight)}function ExtendsArray(inferred,arrayLeft,left,right){return IsArray3(right)?ExtendsImmutable(arrayLeft,right)?ExtendsLeft(inferred,left,right.items):ExtendsFalse():ExtendsRight(inferred,arrayLeft,right)}function ExtendsBigInt(inferred,left,right){return IsBigInt3(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsBoolean(inferred,left,right){return IsBoolean4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ParameterCompare(inferred,left,leftRest,right,rightRest){let checkLeft=IsInfer(right)?left:right,checkRight=IsInfer(right)?right:left,isLeftOptional=IsOptional(left),isRightOptional=IsOptional(right);return!isLeftOptional&&isRightOptional?ExtendsFalse():Match3(ExtendsLeft(inferred,checkLeft,checkRight),inferred2=>ExtendsParameters(inferred2,leftRest,rightRest),()=>ExtendsFalse())}function ParameterRight(inferred,left,leftRest,rightRest){return guard_exports.ShiftLeft(rightRest,(head,tail)=>ParameterCompare(inferred,left,leftRest,head,tail),()=>IsOptional(left)?ExtendsTrue(inferred):ExtendsFalse())}function ParametersLeft(inferred,left,rightRest){return guard_exports.ShiftLeft(left,(head,tail)=>ParameterRight(inferred,head,tail,rightRest),()=>ExtendsTrue(inferred))}function ExtendsParameters(inferred,left,right){return ParametersLeft(inferred,left,right)}function ExtendsReturnType(inferred,left,right){return IsVoid(right)?ExtendsTrue(inferred):ExtendsLeft(inferred,left,right)}function ExtendsConstructor(inferred,parameters,returnType,right){return IsAny(right)?ExtendsTrue(inferred):IsUnknown(right)?ExtendsTrue(inferred):IsConstructor3(right)?Match3(ExtendsParameters(inferred,parameters,right.parameters),inferred2=>ExtendsReturnType(inferred2,returnType,right.instanceType),()=>ExtendsFalse()):ExtendsFalse()}function ExtendsDependent(inferred,if_,then_,else_,right){return Match3(ExtendsLeft(inferred,if_,right),()=>ExtendsLeft(inferred,then_,right),()=>ExtendsLeft(inferred,else_,right))}function ExtendsEnum(inferred,left,right){let evaluated=EvaluateEnum(left);return ExtendsLeft(inferred,evaluated,right)}function ExtendsFunction(inferred,parameters,returnType,right){return IsAny(right)?ExtendsTrue(inferred):IsUnknown(right)?ExtendsTrue(inferred):IsFunction3(right)?Match3(ExtendsParameters(inferred,parameters,right.parameters),inferred2=>ExtendsReturnType(inferred2,returnType,right.returnType),()=>ExtendsFalse()):ExtendsFalse()}function ExtendsInteger(inferred,left,right){return IsInteger3(right)?ExtendsTrue(inferred):IsNumber4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsIntersect(inferred,left,right){let evaluated=EvaluateIntersect(left);return ExtendsLeft(inferred,evaluated,right)}function ExtendsLiteralValue(inferred,left,right){return left===right?ExtendsTrue(inferred):ExtendsFalse()}function ExtendsLiteralBigInt(inferred,left,right){return IsLiteral(right)?ExtendsLiteralValue(inferred,left,right.const):IsBigInt3(right)?ExtendsTrue(inferred):ExtendsRight(inferred,Literal(left),right)}function ExtendsLiteralBoolean(inferred,left,right){return IsLiteral(right)?ExtendsLiteralValue(inferred,left,right.const):IsBoolean4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,Literal(left),right)}function ExtendsLiteralNumber(inferred,left,right){return IsLiteral(right)?ExtendsLiteralValue(inferred,left,right.const):IsNumber4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,Literal(left),right)}function ExtendsLiteralString(inferred,left,right){return IsLiteral(right)?ExtendsLiteralValue(inferred,left,right.const):IsString4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,Literal(left),right)}function ExtendsLiteral(inferred,left,right){return guard_exports.IsBigInt(left.const)?ExtendsLiteralBigInt(inferred,left.const,right):guard_exports.IsBoolean(left.const)?ExtendsLiteralBoolean(inferred,left.const,right):guard_exports.IsNumber(left.const)?ExtendsLiteralNumber(inferred,left.const,right):guard_exports.IsString(left.const)?ExtendsLiteralString(inferred,left.const,right):Unreachable()}function ExtendsNever(inferred,left,right){return IsInfer(right)?ExtendsRight(inferred,left,right):ExtendsTrue(inferred)}function ExtendsNull(inferred,left,right){return IsNull3(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsNumber(inferred,left,right){return IsNumber4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsPropertyOptional(inferred,left,right){return IsOptional(left)?IsOptional(right)?ExtendsTrue(inferred):ExtendsFalse():ExtendsTrue(inferred)}function ExtendsProperty(inferred,left,right){return IsInfer(right)&&IsNever(right.extends)?ExtendsFalse():Match3(ExtendsLeft(inferred,left,right),inferred2=>ExtendsPropertyOptional(inferred2,left,right),()=>ExtendsFalse())}function ExtractInferredProperties(keys,properties){return keys.reduce((result,key)=>key in properties?IsExtendsTrueLike(properties[key])?{...result,...properties[key].inferred}:Unreachable():Unreachable(),{})}function ExtendsPropertiesComparer(inferred,left,right){let properties={};for(let rightKey of guard_exports.Keys(right))properties[rightKey]=rightKey in left?ExtendsProperty({},left[rightKey],right[rightKey]):IsOptional(right[rightKey])?IsInfer(right[rightKey])?ExtendsTrue(memory_exports.Assign(inferred,{[right[rightKey].name]:right[rightKey].extends})):ExtendsTrue(inferred):ExtendsFalse();let checked=guard_exports.Values(properties).every(result=>IsExtendsTrueLike(result)),extracted=checked?ExtractInferredProperties(guard_exports.Keys(properties),properties):{};return checked?ExtendsTrue(extracted):ExtendsFalse()}function ExtendsProperties(inferred,left,right){let compared=ExtendsPropertiesComparer(inferred,left,right);return IsExtendsTrueLike(compared)?ExtendsTrue(memory_exports.Assign(inferred,compared.inferred)):ExtendsFalse()}function ExtendsObjectToObject(inferred,left,right){return ExtendsProperties(inferred,left,right)}function RecordMergeInferred(left,right){return guard_exports.Keys(right).reduce((result,key)=>({...result,[key]:guard_exports.HasPropertyKey(left,key)?IsUnion(result[key])?Union([...result[key].anyOf,right[key]]):Union([left[key],right[key]]):right[key]}),left)}function ExtendsRecordComparer(properties,keys,type,result){return guard_exports.ShiftLeft(keys,(left,right)=>Match3(ExtendsLeft({},properties[left],type),inferred=>ExtendsRecordComparer(properties,right,type,RecordMergeInferred(result,inferred)),()=>ExtendsFalse()),()=>ExtendsTrue(result))}function ExtendsObjectToRecord(inferred,properties,_pattern,value){let keys=guard_exports.Keys(properties);return ExtendsRecordComparer(properties,keys,value,inferred)}function ExtendsObject(inferred,left,right){return IsRecord(right)?ExtendsObjectToRecord(inferred,left,RecordPattern(right),RecordValue(right)):IsObject3(right)?ExtendsObjectToObject(inferred,left,right.properties):ExtendsRight(inferred,_Object_(left),right)}function FromObject3(inferred,properties){return guard_exports.IsEqual(guard_exports.Keys(properties).length,0)?ExtendsTrue(inferred):ExtendsFalse()}function FromRecord(inferred,_leftKey,leftValue,_rightKey,rightValue){return ExtendsLeft(inferred,leftValue,rightValue)}function ExtendsRecord(inferred,leftPattern,leftValue,right){return IsRecord(right)?FromRecord(inferred,RecordPatternToType(leftPattern),leftValue,RecordPatternToType(RecordPattern(right)),RecordValue(right)):IsObject3(right)?FromObject3(inferred,right.properties):IsAny(right)?ExtendsTrue(inferred):IsUnknown(right)?ExtendsTrue(inferred):ExtendsFalse()}function ExtendsString(inferred,left,right){return IsString4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsSymbol(inferred,left,right){return IsSymbol3(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsTemplateLiteral(inferred,left,right){let evaluated=EvaluateTemplateLiteral(left);return ExtendsLeft(inferred,evaluated,right)}function Inferrable(name,type){return memory_exports.Create({"~kind":"Inferrable"},{name,type},{})}function IsInferable(value){return guard_exports.IsObject(value)&&guard_exports.HasPropertyKey(value,"~kind")&&guard_exports.HasPropertyKey(value,"name")&&guard_exports.HasPropertyKey(value,"type")&&guard_exports.IsEqual(value["~kind"],"Inferrable")&&guard_exports.IsString(value.name)&&guard_exports.IsObject(value.type)}function TryRestInferable(type){return IsRest(type)?IsInfer(type.items)?IsArray3(type.items.extends)?Inferrable(type.items.name,type.items.extends.items):IsUnknown(type.items.extends)?Inferrable(type.items.name,type.items.extends):void 0:Unreachable():void 0}function TryInferable(type){return IsInfer(type)?Inferrable(type.name,type.extends):void 0}function TryInferResults(rest,right,result=[]){return guard_exports.ShiftLeft(rest,(head,tail)=>Match3(ExtendsLeft({},head,right),()=>TryInferResults(tail,right,[...result,head]),()=>{}),()=>result)}function InferTupleResult(inferred,name,left,right){let results=TryInferResults(left,right);return guard_exports.IsArray(results)?ExtendsTrue(memory_exports.Assign(inferred,{[name]:Tuple(results)})):ExtendsFalse()}function InferUnionResult(inferred,name,left,right){let results=TryInferResults(left,right);return guard_exports.IsArray(results)?ExtendsTrue(memory_exports.Assign(inferred,{[name]:Union(results)})):ExtendsFalse()}function Reverse(types){return[...types].reverse()}function ApplyReverse(types,reversed){return reversed?Reverse(types):types}function Reversed(types){let first=types.length>0?types[0]:void 0,inferrable=IsSchema(first)?TryRestInferable(first):void 0;return IsSchema(inferrable)}function ElementsCompare(inferred,reversed,left,leftRest,right,rightRest){return Match3(ExtendsLeft(inferred,left,right),checkInferred=>Elements(checkInferred,reversed,leftRest,rightRest),()=>ExtendsFalse())}function ElementsLeft(inferred,reversed,leftRest,right,rightRest){let inferable=TryRestInferable(right);return IsInferable(inferable)?InferTupleResult(inferred,inferable.name,ApplyReverse(leftRest,reversed),inferable.type):guard_exports.ShiftLeft(leftRest,(head,tail)=>ElementsCompare(inferred,reversed,head,tail,right,rightRest),()=>ExtendsFalse())}function ElementsRight(inferred,reversed,leftRest,rightRest){return guard_exports.ShiftLeft(rightRest,(head,tail)=>ElementsLeft(inferred,reversed,leftRest,head,tail),()=>guard_exports.IsEqual(leftRest.length,0)?ExtendsTrue(inferred):ExtendsFalse())}function Elements(inferred,reversed,leftRest,rightRest){return ElementsRight(inferred,reversed,leftRest,rightRest)}function ExtendsTupleToTuple(inferred,left,right){let instantiatedRight=InstantiateElements(inferred,State([],[]),right),reversed=Reversed(instantiatedRight);return Elements(inferred,reversed,ApplyReverse(left,reversed),ApplyReverse(instantiatedRight,reversed))}function ExtendsTupleToArray(inferred,left,right){let inferrable=TryInferable(right);return IsInferable(inferrable)?InferUnionResult(inferred,inferrable.name,left,inferrable.type):guard_exports.ShiftLeft(left,(head,tail)=>Match3(ExtendsLeft(inferred,head,right),inferred2=>ExtendsTupleToArray(inferred2,tail,right),()=>ExtendsFalse()),()=>ExtendsTrue(inferred))}function ExtendsTuple(inferred,left,right){let instantiatedLeft=InstantiateElements(inferred,State([],[]),left);return IsTuple(right)?ExtendsTupleToTuple(inferred,instantiatedLeft,right.items):IsArray3(right)?ExtendsTupleToArray(inferred,instantiatedLeft,right.items):ExtendsRight(inferred,Tuple(instantiatedLeft),right)}function ExtendsUndefined(inferred,left,right){return IsVoid(right)?ExtendsTrue(inferred):IsUndefined3(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsUnionSome(inferred,type,unionTypes){return guard_exports.ShiftLeft(unionTypes,(head,tail)=>Match3(ExtendsLeft(inferred,type,head),inferred2=>ExtendsTrue(inferred2),()=>ExtendsUnionSome(inferred,type,tail)),()=>ExtendsFalse())}function ExtendsUnionLeft(inferred,left,right){return guard_exports.ShiftLeft(left,(head,tail)=>Match3(ExtendsUnionSome(inferred,head,right),inferred2=>ExtendsUnionLeft(inferred2,tail,right),()=>ExtendsFalse()),()=>ExtendsTrue(inferred))}function ExtendsUnion2(inferred,left,right){let inferrable=TryInferable(right);return IsInferable(inferrable)?InferUnionResult(inferred,inferrable.name,left,inferrable.type):IsUnion(right)?ExtendsUnionLeft(inferred,left,right.anyOf):ExtendsUnionLeft(inferred,left,[right])}function ExtendsUnknown(inferred,left,right){return IsInfer(right)?ExtendsRight(inferred,left,right):IsAny(right)?ExtendsTrue(inferred):IsUnknown(right)?ExtendsTrue(inferred):ExtendsFalse()}function ExtendsVoid(inferred,left,right){return IsVoid(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsLeft(inferred,left,right){return IsAny(left)?ExtendsAny(inferred,left,right):IsArray3(left)?ExtendsArray(inferred,left,left.items,right):IsBigInt3(left)?ExtendsBigInt(inferred,left,right):IsBoolean4(left)?ExtendsBoolean(inferred,left,right):IsConstructor3(left)?ExtendsConstructor(inferred,left.parameters,left.instanceType,right):IsDependent(left)?ExtendsDependent(inferred,left.if,left.then,left.else,right):IsEnum(left)?ExtendsEnum(inferred,left.enum,right):IsFunction3(left)?ExtendsFunction(inferred,left.parameters,left.returnType,right):IsInteger3(left)?ExtendsInteger(inferred,left,right):IsIntersect(left)?ExtendsIntersect(inferred,left.allOf,right):IsLiteral(left)?ExtendsLiteral(inferred,left,right):IsNever(left)?ExtendsNever(inferred,left,right):IsNull3(left)?ExtendsNull(inferred,left,right):IsNumber4(left)?ExtendsNumber(inferred,left,right):IsObject3(left)?ExtendsObject(inferred,left.properties,right):IsRecord(left)?ExtendsRecord(inferred,RecordPattern(left),RecordValue(left),right):IsString4(left)?ExtendsString(inferred,left,right):IsSymbol3(left)?ExtendsSymbol(inferred,left,right):IsTemplateLiteral(left)?ExtendsTemplateLiteral(inferred,left.pattern,right):IsTuple(left)?ExtendsTuple(inferred,left.items,right):IsUndefined3(left)?ExtendsUndefined(inferred,left,right):IsUnion(left)?ExtendsUnion2(inferred,left.anyOf,right):IsUnknown(left)?ExtendsUnknown(inferred,left,right):IsVoid(left)?ExtendsVoid(inferred,left,right):ExtendsFalse()}function InterfaceOperation(heritage,properties){return EvaluateIntersect([...heritage,_Object_(properties)])}function InterfaceAction(heritage,properties,options){return CanInstantiate(heritage)?memory_exports.Update(InterfaceOperation(heritage,properties),{},options):InterfaceDeferred(heritage,properties,options)}function InterfaceInstantiate(context,state,heritage,properties,options){let instantiatedHeritage=InstantiateTypes(context,state,heritage),instantiatedProperties=InstantiateProperties(context,state,properties);return InterfaceAction(instantiatedHeritage,instantiatedProperties,options)}function InterfaceDeferred(heritage,properties,options={}){return Deferred("Interface",[heritage,properties],options)}function IsInterfaceDeferred(value){return IsSchema(value)&&guard_exports.HasPropertyKey(value,"action")&&guard_exports.IsEqual(value.action,"Interface")}function Interface(heritage,properties,options={}){return InterfaceAction(heritage,properties,options)}function FromRef(stack,context,ref){return stack.includes(ref)?!0:FromType3([...stack,ref],context,context[ref])}function FromProperties(stack,context,properties){let types=PropertyValues(properties);return FromTypes2(stack,context,types)}function FromTypes2(stack,context,types){return guard_exports.ShiftLeft(types,(left,right)=>FromType3(stack,context,left)?!0:FromTypes2(stack,context,right),()=>!1)}function FromType3(stack,context,type){return IsRef(type)?FromRef(stack,context,type.$ref):IsArray3(type)?FromType3(stack,context,type.items):IsConstructor3(type)?FromTypes2(stack,context,[...type.parameters,type.instanceType]):IsFunction3(type)?FromTypes2(stack,context,[...type.parameters,type.returnType]):IsInterfaceDeferred(type)?FromProperties(stack,context,type.parameters[1]):IsIntersect(type)?FromTypes2(stack,context,type.allOf):IsObject3(type)?FromProperties(stack,context,type.properties):IsUnion(type)?FromTypes2(stack,context,type.anyOf):IsTuple(type)?FromTypes2(stack,context,type.items):IsRecord(type)?FromType3(stack,context,RecordValue(type)):!1}function CyclicCheck(stack,context,type){return FromType3(stack,context,type)}function ResolveCandidateKeys(context,keys){return keys.reduce((result,left)=>CyclicCheck([left],context,context[left])?[...result,left]:result,[])}function CyclicCandidates(context){let keys=PropertyKeys(context);return ResolveCandidateKeys(context,keys)}function FromRef2(context,ref,result){return result.includes(ref)?result:ref in context?FromType4(context,context[ref],[...result,ref]):Unreachable()}function FromProperties2(context,properties,result){let types=PropertyValues(properties);return FromTypes3(context,types,result)}function FromTypes3(context,types,result){return types.reduce((result2,left)=>FromType4(context,left,result2),result)}function FromType4(context,type,result){return IsRef(type)?FromRef2(context,type.$ref,result):IsArray3(type)?FromType4(context,type.items,result):IsConstructor3(type)?FromTypes3(context,[...type.parameters,type.instanceType],result):IsFunction3(type)?FromTypes3(context,[...type.parameters,type.returnType],result):IsInterfaceDeferred(type)?FromProperties2(context,type.parameters[1],result):IsIntersect(type)?FromTypes3(context,type.allOf,result):IsObject3(type)?FromProperties2(context,type.properties,result):IsUnion(type)?FromTypes3(context,type.anyOf,result):IsTuple(type)?FromTypes3(context,type.items,result):IsRecord(type)?FromType4(context,RecordValue(type),result):result}function CyclicDependencies(context,key,type){return FromType4(context,type,[key])}function FromRef3(_ref){return Any()}function FromProperties3(properties){return guard_exports.Keys(properties).reduce((result,key)=>({...result,[key]:FromType5(properties[key])}),{})}function FromTypes4(types){return types.reduce((result,left)=>[...result,FromType5(left)],[])}function FromType5(type){return IsRef(type)?FromRef3(type.$ref):IsArray3(type)?_Array_(FromType5(type.items),ArrayOptions(type)):IsConstructor3(type)?Constructor(FromTypes4(type.parameters),FromType5(type.instanceType)):IsFunction3(type)?_Function_(FromTypes4(type.parameters),FromType5(type.returnType)):IsIntersect(type)?Intersect(FromTypes4(type.allOf)):IsObject3(type)?_Object_(FromProperties3(type.properties)):IsRecord(type)?Record(RecordKey(type),FromType5(RecordValue(type))):IsUnion(type)?Union(FromTypes4(type.anyOf)):IsTuple(type)?Tuple(FromTypes4(type.items)):type}function CyclicAnyFromParameters(defs,ref){return ref in defs?FromType5(defs[ref]):Unknown()}function CyclicExtends(type){return CyclicAnyFromParameters(type.$defs,type.$ref)}function CyclicInterface(context,heritage,properties){let instantiatedHeritage=InstantiateTypes(context,State([],[]),heritage),instantiatedProperties=InstantiateProperties({},State([],[]),properties);return EvaluateIntersect([...instantiatedHeritage,_Object_(instantiatedProperties)])}function CyclicDefinitions(context,dependencies){return guard_exports.Keys(context).filter(key=>dependencies.includes(key)).reduce((result,key)=>{let type=context[key],instantiatedType=IsInterfaceDeferred(type)?CyclicInterface(context,type.parameters[0],type.parameters[1]):type;return{...result,[key]:instantiatedType}},{})}function InstantiateCyclic(context,ref,type){let dependencies=CyclicDependencies(context,ref,type),definitions=CyclicDefinitions(context,dependencies);return Cyclic(definitions,ref)}function Resolve(defs,ref){return ref in defs?IsRef(defs[ref])?Resolve(defs,defs[ref].$ref):defs[ref]:Never()}function CyclicTarget(defs,ref){return Resolve(defs,ref)}function Canonical(type){return IsCyclic(type)?CyclicExtends(type):IsUnsafe(type)?Unknown():type}function Extends(inferred,left,right){let canonicalLeft=Canonical(left),canonicalRight=Canonical(right);return ExtendsLeft(inferred,canonicalLeft,canonicalRight)}var CompareResultEqual=0,CompareResultDisjoint=1,CompareResultLeftInside=2,CompareResultRightInside=3;function Compare(left,right){let extendsCheck=[Extends({},left,right),Extends({},right,left)];return result_exports.IsExtendsTrueLike(extendsCheck[0])&&result_exports.IsExtendsTrueLike(extendsCheck[1])?CompareResultEqual:result_exports.IsExtendsTrueLike(extendsCheck[0])&&result_exports.IsExtendsFalse(extendsCheck[1])?CompareResultLeftInside:result_exports.IsExtendsFalse(extendsCheck[0])&&result_exports.IsExtendsTrueLike(extendsCheck[1])?CompareResultRightInside:CompareResultDisjoint}function BroadenFilter(type,types,result=[],all=types){return guard_exports.ShiftLeft(types,(left,right)=>{let compare=Compare(type,left);return guard_exports.IsEqual(compare,CompareResultLeftInside)||guard_exports.IsEqual(compare,CompareResultEqual)?all:guard_exports.IsEqual(compare,CompareResultDisjoint)?BroadenFilter(type,right,[...result,left],all):BroadenFilter(type,right,result,all)},()=>[...result,type])}function BroadenType(type,types,result){let evaluated=EvaluateType(type);return IsAny(evaluated)?[evaluated]:IsUnknown(evaluated)?[evaluated]:IsNever(evaluated)?BroadenTypes(types,result):IsObject3(evaluated)?BroadenTypes(types,[...result,evaluated]):BroadenTypes(types,BroadenFilter(evaluated,result))}function BroadenTypes(types,result=[]){return guard_exports.ShiftLeft(types,(left,right)=>BroadenType(left,right,result),()=>result)}function Broaden(types){let broadened=BroadenTypes(types);return Flatten(broadened)}function EvaluateAction(type,options){return memory_exports.Update(EvaluateType(type),{},options)}function EvaluateInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return EvaluateAction(instantiatedType,options)}function CollectDistributionNames(expression,result=[]){return IsDeferred(expression)&&guard_exports.IsEqual(expression.action,"Conditional")?IsRef(expression.parameters[0])?CollectDistributionNames(expression.parameters[2],CollectDistributionNames(expression.parameters[3],[...result,expression.parameters[0].$ref])):CollectDistributionNames(expression.parameters[2],CollectDistributionNames(expression.parameters[3],result)):IsDeferred(expression)&&guard_exports.IsEqual(expression.action,"Mapped")&&IsDeferred(expression.parameters[1])&&guard_exports.IsEqual(expression.parameters[1].action,"KeyOf")&&IsRef(expression.parameters[1].parameters[0])?[...result,expression.parameters[1].parameters[0].$ref]:result}function BuildDistributionArray(parameters,names){return parameters.reduce((result,left)=>[...result,names.includes(left.name)],[])}function ZipDistributionArray(arguments_,distributionArray,result=[]){return guard_exports.ShiftLeft(arguments_,(argumentLeft,argumentRight)=>guard_exports.ShiftLeft(distributionArray,(booleanLeft,booleanRight)=>ZipDistributionArray(argumentRight,booleanRight,[...result,[booleanLeft,argumentLeft]]),()=>result),()=>result)}function CanonicalArgument(type){return IsTemplateLiteral(type)?EvaluateTemplateLiteral(type.pattern):IsEnum(type)?EvaluateEnum(type.enum):type}function Expand(type){let canonicalArgument=CanonicalArgument(type);return IsUnion(canonicalArgument)?[...canonicalArgument.anyOf]:[canonicalArgument]}function Append(current,type){return current.reduce((result,left)=>[...result,[...left,type]],[])}function Cross(current,variants){return variants.reduce((result,left)=>[...result,...Append(current,left)],[])}function Distribute2(zipped){return zipped.reduce((result,left)=>guard_exports.IsEqual(left[0],!0)?Cross(result,Expand(left[1])):Cross(result,[left[1]]),[[]])}function DistributeArguments(parameters,arguments_,expression){let distributionNames=CollectDistributionNames(expression),distributionArray=BuildDistributionArray(parameters,distributionNames),zippedArguments=ZipDistributionArray(arguments_,distributionArray);return IsDeferred(expression)&&guard_exports.IsEqual(expression.action,"Conditional")||IsDeferred(expression)&&guard_exports.IsEqual(expression.action,"Mapped")?Distribute2(zippedArguments):[arguments_]}function FromNotResolvable(){return["(not-resolvable)",Never()]}function FromNotGeneric(){return["(not-generic)",Never()]}function FromGeneric(name,parameters,expression){return[name,Generic(parameters,expression)]}function FromRef4(context,ref,arguments_){return ref in context?FromType6(context,ref,context[ref],arguments_):FromNotResolvable()}function FromType6(context,name,target,arguments_){return IsGeneric(target)?FromGeneric(name,target.parameters,target.expression):IsRef(target)?FromRef4(context,target.$ref,arguments_):FromNotGeneric()}function ResolveTarget(context,target,arguments_){return FromType6(context,"(anonymous)",target,arguments_)}function AssertArgumentExtends(name,type,extends_){if(IsInfer(type)||IsCall(type)||result_exports.IsExtendsTrueLike(Extends({},type,extends_)))return;let cause={parameter:name,expect:extends_,actual:type};throw new Error(`Argument for parameter ${name} does not satisfy constraint`,{cause})}function BindArgument(context,state,name,extends_,type){let instantiatedArgument=InstantiateType(context,state,type);return AssertArgumentExtends(name,instantiatedArgument,extends_),memory_exports.Assign(context,{[name]:instantiatedArgument})}function BindArguments(context,state,parameterLeft,parameterRight,arguments_){let instantiatedExtends=InstantiateType(context,state,parameterLeft.extends),instantiatedEquals=InstantiateType(context,state,parameterLeft.equals);return guard_exports.ShiftLeft(arguments_,(left,right)=>BindParameters(BindArgument(context,state,parameterLeft.name,instantiatedExtends,left),state,parameterRight,right),()=>BindParameters(BindArgument(context,state,parameterLeft.name,instantiatedExtends,instantiatedEquals),state,parameterRight,[]))}function BindParameters(context,state,parameters,arguments_){return guard_exports.ShiftLeft(parameters,(left,right)=>BindArguments(context,state,left,right,arguments_),()=>context)}function ResolveArgumentsContext(context,state,parameters,arguments_){return BindParameters(context,state,parameters,arguments_)}var instantiationDepth=0,instantiationCount=0;function InstantiationAssert(){if(!guard_exports.IsLessThan(instantiationCount,settings_exports.Get().maxInstantiationCount))throw Error("Type instantiation is excessively deep and possibly infinite")}function InstantiationIncrement(){InstantiationAssert(),instantiationCount++,instantiationDepth++}function InstantiationDecrement(){instantiationDepth--,guard_exports.IsEqual(instantiationDepth,0)&&(instantiationCount=0)}function Peek(state){return guard_exports.IsGreaterThan(state.callstack.length,0)?state.callstack[state.callstack.length-1]:""}function IsTailCall(state,name){return guard_exports.IsEqual(Peek(state),name)}function CallDispatch(context,state,target,parameters,expression,arguments_){InstantiationIncrement();try{let argumentsContext=ResolveArgumentsContext(context,state,parameters,arguments_),returnType=InstantiateType(argumentsContext,State([...state.callstack,target.$ref],state.visited),expression);return InstantiateType(argumentsContext,State([],[]),returnType)}finally{InstantiationDecrement()}}function CallDistributed(context,state,target,parameters,expression,distributedArguments){return distributedArguments.reduce((result,arguments_)=>{let returnType=CallDispatch(context,state,target,parameters,expression,arguments_);return[...result,returnType]},[])}function CallImmediate(context,state,target,parameters,expression,arguments_){let distributedArguments=DistributeArguments(parameters,arguments_,expression),returnTypes=CallDistributed(context,state,target,parameters,expression,distributedArguments);return guard_exports.IsEqual(returnTypes.length,1)?returnTypes[0]:EvaluateUnion(returnTypes)}function CallInstantiate(context,state,target,arguments_){let instantiatedArguments=InstantiateTypes(context,state,arguments_),resolved=ResolveTarget(context,target,arguments_),name=resolved[0],type=resolved[1];return IsGeneric(type)?IsTailCall(state,name)?CallConstruct(Ref(name),instantiatedArguments):CallImmediate(context,state,Ref(name),type.parameters,type.expression,instantiatedArguments):CallConstruct(target,instantiatedArguments)}function CallConstruct(target,arguments_){return memory_exports.Create({"~kind":"Call"},{type:"call",target,arguments:arguments_},{})}function Call2(target,arguments_){return CallInstantiate({},State([],[]),target,arguments_)}function IsCall(value){return IsKind(value,"Call")}function RemoveImmutableOperation(type){return memory_exports.Discard(type,["~immutable"])}function RemoveImmutableAction(type,options){return memory_exports.Update(RemoveImmutableOperation(type),{},options)}function RemoveImmutableInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return RemoveImmutableAction(instantiatedType,options)}function ApplyMapping(mapping,value){return mapping(value)}function FromLiteral3(mapping,value){return guard_exports.IsString(value)?Literal(ApplyMapping(mapping,value)):Literal(value)}function FromTemplateLiteral(mapping,pattern){let evaluated=EvaluateTemplateLiteral(pattern);return FromType7(mapping,evaluated)}function FromUnion2(mapping,types){let result=types.map(type=>FromType7(mapping,type));return Union(result)}function FromType7(mapping,type){return IsLiteral(type)?FromLiteral3(mapping,type.const):IsTemplateLiteral(type)?FromTemplateLiteral(mapping,type.pattern):IsUnion(type)?FromUnion2(mapping,type.anyOf):type}function CapitalizeDeferred(type,options={}){return Deferred("Capitalize",[type],options)}function Capitalize(type,options={}){return CapitalizeAction(type,options)}function LowercaseDeferred(type,options={}){return Deferred("Lowercase",[type],options)}function Lowercase(type,options={}){return LowercaseAction(type,options)}function UncapitalizeDeferred(type,options={}){return Deferred("Uncapitalize",[type],options)}function Uncapitalize(type,options={}){return UncapitalizeAction(type,options)}function UppercaseDeferred(type,options={}){return Deferred("Uppercase",[type],options)}function Uppercase(type,options={}){return UppercaseAction(type,options)}var CapitalizeMapping=input=>input[0].toUpperCase()+input.slice(1),LowercaseMapping=input=>input.toLowerCase(),UncapitalizeMapping=input=>input[0].toLowerCase()+input.slice(1),UppercaseMapping=input=>input.toUpperCase();function CapitalizeAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType7(CapitalizeMapping,type),{},options):CapitalizeDeferred(type,options)}function LowercaseAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType7(LowercaseMapping,type),{},options):LowercaseDeferred(type,options)}function UncapitalizeAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType7(UncapitalizeMapping,type),{},options):UncapitalizeDeferred(type,options)}function UppercaseAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType7(UppercaseMapping,type),{},options):UppercaseDeferred(type,options)}function CapitalizeInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return CapitalizeAction(instantiatedType,options)}function LowercaseInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return LowercaseAction(instantiatedType,options)}function UncapitalizeInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return UncapitalizeAction(instantiatedType,options)}function UppercaseInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return UppercaseAction(instantiatedType,options)}function ConditionalDeferred(left,right,true_,false_,options={}){return Deferred("Conditional",[left,right,true_,false_],options)}function Conditional(left,right,true_,false_,options={}){return ConditionalAction({},State([],[]),left,right,true_,false_,options)}function ConditionalOperation(context,state,left,right,true_,false_){let extendsResult=Extends(context,left,right);return result_exports.IsExtendsUnion(extendsResult)?Union([InstantiateType(extendsResult.inferred,state,true_),InstantiateType(context,state,false_)]):result_exports.IsExtendsTrue(extendsResult)?InstantiateType(extendsResult.inferred,state,true_):InstantiateType(context,state,false_)}function ConditionalAction(context,state,left,right,true_,false_,options){return CanInstantiate([left,right])?memory_exports.Update(ConditionalOperation(context,state,left,right,true_,false_),{},options):ConditionalDeferred(left,right,true_,false_,options)}function ConditionalInstantiate(context,state,left,right,true_,false_,options){let instantiatedLeft=InstantiateType(context,state,left),instantiatedRight=InstantiateType(context,state,right);return ConditionalAction(context,state,instantiatedLeft,instantiatedRight,true_,false_,options)}function ConstructorParametersDeferred(type,options={}){return Deferred("ConstructorParameters",[type],options)}function ConstructorParameters(type,options={}){return ConstructorParametersAction(type,options)}function ConstructorParametersOperation(type){let parameters=IsConstructor3(type)?type.parameters:[],instantiatedParameters=InstantiateElements({},State([],[]),parameters);return Tuple(instantiatedParameters)}function ConstructorParametersAction(type,options){return CanInstantiate([type])?memory_exports.Update(ConstructorParametersOperation(type),{},options):ConstructorParametersDeferred(type,options)}function ConstructorParametersInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return ConstructorParametersAction(instantiatedType,options)}function ExcludeDeferred(left,right,options={}){return Deferred("Exclude",[left,right],options)}function Exclude(left,right,options={}){return ExcludeAction(left,right,options)}function ExcludeAction(left,right,options){return CanInstantiate([left,right])?memory_exports.Update(ExcludeOperation(left,right),{},options):ExcludeDeferred(left,right,options)}function ExcludeInstantiate(context,state,left,right,options){let instantiatedLeft=InstantiateType(context,state,left),instantiatedRight=InstantiateType(context,state,right);return ExcludeAction(instantiatedLeft,instantiatedRight,options)}function ExtractDeferred(left,right,options={}){return Deferred("Extract",[left,right],options)}function Extract(left,right,options={}){return ExtractAction(left,right,options)}function ExtractType(left,right){let check=Extends({},left,right);return result_exports.IsExtendsTrueLike(check)?[left]:[]}function ExtractUnion(left,right,result=[]){return guard_exports.ShiftLeft(left,(head,tail)=>ExtractUnion(tail,right,[...result,...ExtractType(head,right)]),()=>result)}function ExtractOperation(left,right){let evaluated=EvaluateType(left),canonical=IsUnion(evaluated)?evaluated.anyOf:[evaluated],remaining=ExtractUnion(canonical,right);return EvaluateUnion(remaining)}function ExtractAction(left,right,options){return CanInstantiate([left,right])?memory_exports.Update(ExtractOperation(left,right),{},options):ExtractDeferred(left,right,options)}function ExtractInstantiate(context,state,left,right,options){let instantiatedLeft=InstantiateType(context,state,left),instantiatedRight=InstantiateType(context,state,right);return ExtractAction(instantiatedLeft,instantiatedRight,options)}function KeysToLiterals(keys){return keys.reduce((result,left)=>IsLiteralValue(left)?[...result,Literal(left)]:result,[])}function KeysToIndexer(keys){let literals=KeysToLiterals(keys);return Union(literals)}function IndexDeferred(type,indexer,options={}){return Deferred("Index",[type,indexer],options)}function Index(type,indexer_or_keys,options={}){let indexer=guard_exports.IsArray(indexer_or_keys)?KeysToIndexer(indexer_or_keys):indexer_or_keys;return IndexAction(type,indexer,options)}function FromCyclic(defs,ref){let target=CyclicTarget(defs,ref);return FromType8(target)}function FromDependent(if_,then_,else_){let evaluated=EvaluateDependent(if_,then_,else_);return FromType8(evaluated)}function CollapseIntersectProperties(left,right){let leftKeys=guard_exports.Keys(left).filter(key=>!guard_exports.HasPropertyKey(right,key)),rightKeys=guard_exports.Keys(right).filter(key=>!guard_exports.HasPropertyKey(left,key)),sharedKeys=guard_exports.Keys(left).filter(key=>guard_exports.HasPropertyKey(right,key)),leftProperties=leftKeys.reduce((result,key)=>({...result,[key]:left[key]}),{}),rightProperties=rightKeys.reduce((result,key)=>({...result,[key]:right[key]}),{}),sharedProperties=sharedKeys.reduce((result,key)=>({...result,[key]:EvaluateIntersect([left[key],right[key]])}),{}),unique=memory_exports.Assign(leftProperties,rightProperties);return memory_exports.Assign(unique,sharedProperties)}function FromIntersect(types){return types.reduce((result,left)=>CollapseIntersectProperties(result,FromType8(left)),{})}function FromTuple(types){let object=TupleToObject(Tuple(types));return FromType8(object)}function CollapseUnionProperties(left,right){return guard_exports.Keys(left).filter(key=>key in right).reduce((result2,key)=>({...result2,[key]:EvaluateUnion([left[key],right[key]])}),{})}function ReduceVariants(types,result){return guard_exports.ShiftLeft(types,(left,right)=>ReduceVariants(right,CollapseUnionProperties(result,FromType8(left))),()=>result)}function FromUnion3(types){return guard_exports.ShiftLeft(types,(left,right)=>ReduceVariants(right,FromType8(left)),()=>Unreachable())}function FromType8(type){return IsCyclic(type)?FromCyclic(type.$defs,type.$ref):IsDependent(type)?FromDependent(type.if,type.then,type.else):IsIntersect(type)?FromIntersect(type.allOf):IsUnion(type)?FromUnion3(type.anyOf):IsTuple(type)?FromTuple(type.items):IsObject3(type)?type.properties:{}}function CollapseToObject(type){let properties=FromType8(type);return _Object_(properties)}var integerKeyPattern=new RegExp("^(?:0|[1-9][0-9]*)$");function ConvertToIntegerKey(value){let normal=`${value}`;return integerKeyPattern.test(normal)?parseInt(normal):value}function NormalizeLiteral(value){return Literal(ConvertToIntegerKey(value))}function NormalizeIndexerTypes(types){return types.map(type=>NormalizeIndexer(type))}function NormalizeIndexer(type){return IsIntersect(type)?Intersect(NormalizeIndexerTypes(type.allOf)):IsUnion(type)?Union(NormalizeIndexerTypes(type.anyOf)):IsLiteral(type)?NormalizeLiteral(type.const):type}function FromArray3(type,indexer){let normalizedIndexer=NormalizeIndexer(indexer),check=Extends({},normalizedIndexer,Number2());return result_exports.IsExtendsTrueLike(check)?type:IsLiteral(indexer)&&guard_exports.IsEqual(indexer.const,"length")?Number2():Never()}function FromCyclic2(defs,ref){let target=CyclicTarget(defs,ref);return FromType9(target)}function FromDependent2(if_,then_,else_){let evaluated=EvaluateDependent(if_,then_,else_);return FromType9(evaluated)}function FromEnum(values){let evaluated=EvaluateEnum(values);return FromType9(evaluated)}function FromIntersect2(types){let evaluated=EvaluateIntersect(types);return FromType9(evaluated)}function FromLiteral4(value){return[`${value}`]}function FromTemplateLiteral2(pattern){let evaluated=EvaluateTemplateLiteral(pattern);return FromType9(evaluated)}function FromUnion4(types){return types.reduce((result,left)=>[...result,...FromType9(left)],[])}function FromType9(type){return IsCyclic(type)?FromCyclic2(type.$defs,type.$ref):IsDependent(type)?FromDependent2(type.if,type.then,type.else):IsEnum(type)?FromEnum(type.enum):IsIntersect(type)?FromIntersect2(type.allOf):IsLiteral(type)?FromLiteral4(type.const):IsTemplateLiteral(type)?FromTemplateLiteral2(type.pattern):IsUnion(type)?FromUnion4(type.anyOf):[]}function ToIndexableKeys(type){return FromType9(type)}function FromTypes5(properties,types){return types.map(type=>FromType10(properties,type))}function FromType10(properties,type){return IsArray3(type)?_Array_(FromType10(properties,type.items)):IsConstructor3(type)?Constructor(FromTypes5(properties,type.parameters),FromType10(properties,type.instanceType)):IsFunction3(type)?_Function_(FromTypes5(properties,type.parameters),FromType10(properties,type.returnType)):IsTuple(type)?Tuple(FromTypes5(properties,type.items)):IsUnion(type)?Union(FromTypes5(properties,type.anyOf)):IsIntersect(type)?Intersect(FromTypes5(properties,type.allOf)):IsThis(type)?_Object_(properties):type}function ExpandThis(properties,type){return FromType10(properties,type)}function IndexProperty(properties,key){let selectedType=key in properties?properties[key]:Never();return ExpandThis(properties,selectedType)}function IndexProperties(properties,keys){return keys.reduce((result,left)=>[...result,IndexProperty(properties,left)],[])}function FromIndexer(properties,indexer){let keys=ToIndexableKeys(indexer),variants=IndexProperties(properties,keys);return EvaluateUnion(variants)}var NumericKeyPattern=new RegExp(IntegerKey);function NumericKeys(keys){return keys.filter(key=>NumericKeyPattern.test(key))}function FromIndexerNumber(properties){let keys=PropertyKeys(properties),numericKeys=NumericKeys(keys),variants=IndexProperties(properties,numericKeys);return EvaluateUnion(variants)}function FromObject5(properties,indexer){return IsNumber4(indexer)?FromIndexerNumber(properties):FromIndexer(properties,indexer)}function ConvertLiteral(value){return Literal(ConvertToIntegerKey(value))}function ArrayIndexerTypes(types){return types.map(type=>FormatArrayIndexer(type))}function FormatArrayIndexer(type){return IsIntersect(type)?Intersect(ArrayIndexerTypes(type.allOf)):IsUnion(type)?Union(ArrayIndexerTypes(type.anyOf)):IsLiteral(type)?ConvertLiteral(type.const):type}function IndexElementsWithIndexer(types,indexer){return types.reduceRight((result,right,index)=>{let check=Extends({},Literal(index),indexer);return result_exports.IsExtendsTrueLike(check)?[right,...result]:result},[])}function FromTupleWithIndexer(types,indexer){let formattedArrayIndexer=FormatArrayIndexer(indexer),elements=IndexElementsWithIndexer(types,formattedArrayIndexer);return EvaluateUnionFast(elements)}function FromTupleWithoutIndexer(types){return EvaluateUnionFast(types)}function FromTuple2(types,indexer){return IsLiteral(indexer)&&guard_exports.IsEqual(indexer.const,"length")?Literal(types.length):IsNumber4(indexer)||IsInteger3(indexer)?FromTupleWithoutIndexer(types):FromTupleWithIndexer(types,indexer)}function FromType11(type,indexer){return IsArray3(type)?FromArray3(type.items,indexer):IsObject3(type)?FromObject5(type.properties,indexer):IsTuple(type)?FromTuple2(type.items,indexer):Never()}function NormalizeType(type){return IsCyclic(type)||IsDependent(type)||IsIntersect(type)||IsUnion(type)?CollapseToObject(type):type}function IndexAction(type,indexer,options){return CanInstantiate([type,indexer])?memory_exports.Update(FromType11(NormalizeType(type),indexer),{},options):IndexDeferred(type,indexer,options)}function IndexInstantiate(context,state,type,indexer,options){let instantiatedType=InstantiateType(context,state,type),instantiatedIndexer=InstantiateType(context,state,indexer);return IndexAction(instantiatedType,instantiatedIndexer,options)}function InstanceTypeDeferred(type,options={}){return Deferred("InstanceType",[type],options)}function InstanceType(type,options={}){return InstanceTypeAction(type,options)}function InstanceTypeOperation(type){return IsConstructor3(type)?type.instanceType:Never()}function InstanceTypeAction(type,options){return CanInstantiate([type])?memory_exports.Update(InstanceTypeOperation(type),{},options):InstanceTypeDeferred(type,options)}function InstanceTypeInstantiate(context,state,type,options={}){let instantiatedType=InstantiateType(context,state,type);return InstanceTypeAction(instantiatedType,options)}function KeyOfDeferred(type,options={}){return Deferred("KeyOf",[type],options)}function KeyOf2(type,options={}){return KeyOfAction(type,options)}function FromAny(){return Union([Number2(),String2(),Symbol()])}function FromArray4(_type){return Number2()}function FromPropertyKeys(keys){return keys.reduce((result2,left)=>IsLiteralValue(left)?[...result2,Literal(ConvertToIntegerKey(left))]:Unreachable(),[])}function FromObject6(properties){let propertyKeys=guard_exports.Keys(properties),variants=FromPropertyKeys(propertyKeys);return EvaluateUnionFast(variants)}function FromRecord2(type){return RecordKey(type)}function FromTuple3(types){let result=types.map((_,index)=>Literal(index));return EvaluateUnionFast(result)}function FromType12(type){return IsAny(type)?FromAny():IsArray3(type)?FromArray4(type.items):IsObject3(type)?FromObject6(type.properties):IsRecord(type)?FromRecord2(type):IsTuple(type)?FromTuple3(type.items):Never()}function NormalizeType2(type){return IsCyclic(type)||IsDependent(type)||IsIntersect(type)||IsUnion(type)?CollapseToObject(type):type}function KeyOfAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType12(NormalizeType2(type)),{},options):KeyOfDeferred(type,options)}function KeyOfInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return KeyOfAction(instantiatedType,options)}function MappedDeferred(identifier,type,as,property,options={}){return Deferred("Mapped",[identifier,type,as,property],options)}function Mapped(identifier,type,as,property,options={}){return MappedAction({},State([],[]),identifier,type,as,property,options)}function FromTemplateLiteral3(pattern){let evaluated=EvaluateTemplateLiteral(pattern);return FromType13(evaluated)}function FromUnion5(types){return types.reduce((result,left)=>[...result,...FromType13(left)],[])}function FromEnum2(values){let evaluated=EvaluateEnum(values);return FromType13(evaluated)}function FromLiteral5(value){return guard_exports.IsNumber(value)?[Literal(`${value}`)]:[Literal(value)]}function FromType13(type){return IsEnum(type)?FromEnum2(type.enum):IsLiteral(type)?FromLiteral5(type.const):IsTemplateLiteral(type)?FromTemplateLiteral3(type.pattern):IsUnion(type)?FromUnion5(type.anyOf):[type]}function MappedVariants(type){return FromType13(type)}function CanonicalAs(instantiatedAs){return IsTemplateLiteral(instantiatedAs)?EvaluateTemplateLiteral(instantiatedAs.pattern):instantiatedAs}function MappedVariant(context,state,identifier,variant,as,property){let variantContext=memory_exports.Assign(context,{[identifier.name]:variant}),instantiatedAs=InstantiateType(variantContext,state,as),canonicalAs=CanonicalAs(instantiatedAs),instantiatedProperty=InstantiateType(variantContext,state,property);return IsLiteralNumber(canonicalAs)||IsLiteralString(canonicalAs)?{[canonicalAs.const]:instantiatedProperty}:{}}function MappedProperties(context,state,identifier,variants,as,property){return variants.reduce((result,left)=>[...result,MappedVariant(context,state,identifier,left,as,property)],[])}function MappedObjects(properties){return properties.reduce((result,left)=>[...result,_Object_(left)],[])}function MappedOperation(context,state,identifier,type,as,property){let variants=MappedVariants(type),mappedProperties=MappedProperties(context,state,identifier,variants,as,property),mappedObjects=MappedObjects(mappedProperties);return EvaluateIntersect(mappedObjects)}function MappedAction(context,state,identifier,type,as,property,options){return CanInstantiate([type])?memory_exports.Update(MappedOperation(context,state,identifier,type,as,property),{},options):MappedDeferred(identifier,type,as,property,options)}function MappedInstantiate(context,state,identifier,type,as,property,options){let instantiatedType=InstantiateType(context,state,type);return MappedAction(context,state,identifier,instantiatedType,as,property,options)}function InstantiateCyclics(context,declarations,cyclicKeys){let declarationContext=memory_exports.Assign(context,declarations);return guard_exports.Keys(declarations).filter(key=>cyclicKeys.includes(key)).reduce((result,key)=>({...result,[key]:InstantiateCyclic(declarationContext,key,declarations[key])}),{})}function InstantiateNonCyclics(context,declarations,cyclicKeys){let declarationContext=memory_exports.Assign(context,declarations);return guard_exports.Keys(declarations).filter(key=>!cyclicKeys.includes(key)).reduce((result,key)=>({...result,[key]:InstantiateType(declarationContext,State([],[]),declarations[key])}),{})}function InstantiateModule(context,declarations,options){let cyclicCandidates=CyclicCandidates(declarations),instantiatedCyclics=InstantiateCyclics(context,declarations,cyclicCandidates),instantiatedNonCyclics=InstantiateNonCyclics(context,declarations,cyclicCandidates),instantiatedModule={...instantiatedCyclics,...instantiatedNonCyclics};return memory_exports.Update(instantiatedModule,{},options)}function ModuleInstantiate(context,_state,declarations,options){return InstantiateModule(context,declarations,options)}function NonNullableDeferred(type,options={}){return Deferred("NonNullable",[type],options)}function NonNullable(type,options={}){return NonNullableAction(type,options)}function NonNullableOperation(type){let excluded=Union([Null(),Undefined()]);return ExcludeAction(type,excluded,{})}function NonNullableAction(type,options){return CanInstantiate([type])?memory_exports.Update(NonNullableOperation(type),{},options):NonNullableDeferred(type,options)}function NonNullableInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return NonNullableAction(instantiatedType,options)}function OmitDeferred(type,indexer,options={}){return Deferred("Omit",[type,indexer],options)}function Omit(type,indexer_or_keys,options={}){let indexer=guard_exports.IsArray(indexer_or_keys)?KeysToIndexer(indexer_or_keys):indexer_or_keys;return OmitAction(type,indexer,options)}function ToIndexable(type){let collapsed=CollapseToObject(type);return IsObject3(collapsed)?collapsed.properties:Unreachable()}function FromKeys(properties,keys){return guard_exports.Keys(properties).reduce((result2,key)=>keys.includes(key)?result2:{...result2,[key]:properties[key]},{})}function FromType14(type,indexer){let indexable=ToIndexable(type),indexableKeys=ToIndexableKeys(indexer),omitted=FromKeys(indexable,indexableKeys);return _Object_(omitted)}function OmitAction(type,indexer,options){return CanInstantiate([type,indexer])?memory_exports.Update(FromType14(type,indexer),{},options):OmitDeferred(type,indexer,options)}function OmitInstantiate(context,state,type,indexer,options){let instantiatedType=InstantiateType(context,state,type),instantiatedIndexer=InstantiateType(context,state,indexer);return OmitAction(instantiatedType,instantiatedIndexer,options)}function ParametersDeferred(type,options={}){return Deferred("Parameters",[type],options)}function Parameters(type,options={}){return ParametersAction(type,options)}function ParametersOperation(type){let parameters=IsFunction3(type)?type.parameters:[],instantiatedParameters=InstantiateElements({},State([],[]),parameters);return Tuple(instantiatedParameters)}function ParametersAction(type,options){return CanInstantiate([type])?memory_exports.Update(ParametersOperation(type),{},options):ParametersDeferred(type,options)}function ParametersInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return ParametersAction(instantiatedType,options)}function PartialDeferred(type,options={}){return Deferred("Partial",[type],options)}function Partial(type,options={}){return PartialAction(type,options)}function FromCyclic3(defs,ref){let target=CyclicTarget(defs,ref),partial=FromType15(target);return Cyclic(memory_exports.Assign(defs,{[ref]:partial}),ref)}function FromDependent3(if_,then_,else_){let evaluated=EvaluateDependent(if_,then_,else_);return FromType15(evaluated)}function FromIntersect3(types){let evaluated=EvaluateIntersect(types);return FromType15(evaluated)}function FromUnion6(types){let result=types.map(type=>FromType15(type));return Union(result)}function FromObject7(properties){let mapped=guard_exports.Keys(properties).reduce((result2,left)=>({...result2,[left]:AddOptional(properties[left])}),{});return _Object_(mapped)}function FromType15(type){return IsCyclic(type)?FromCyclic3(type.$defs,type.$ref):IsDependent(type)?FromDependent3(type.if,type.then,type.else):IsIntersect(type)?FromIntersect3(type.allOf):IsUnion(type)?FromUnion6(type.anyOf):IsObject3(type)?FromObject7(type.properties):_Object_({})}function PartialAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType15(type),{},options):PartialDeferred(type,options)}function PartialInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return PartialAction(instantiatedType,options)}function PickDeferred(type,indexer,options={}){return Deferred("Pick",[type,indexer],options)}function Pick(type,indexer_or_keys,options={}){let indexer=guard_exports.IsArray(indexer_or_keys)?KeysToIndexer(indexer_or_keys):indexer_or_keys;return PickAction(type,indexer,options)}function FromKeys2(properties,keys){return guard_exports.Keys(properties).reduce((result2,key)=>keys.includes(key)?memory_exports.Assign(result2,{[key]:properties[key]}):result2,{})}function FromType16(type,indexer){let indexable=ToIndexable(type),keys=ToIndexableKeys(indexer),applied=FromKeys2(indexable,keys);return _Object_(applied)}function PickAction(type,indexer,options){return CanInstantiate([type,indexer])?memory_exports.Update(FromType16(type,indexer),{},options):PickDeferred(type,indexer,options)}function PickInstantiate(context,state,type,indexer,options){let instantiatedType=InstantiateType(context,state,type),instantiatedIndexer=InstantiateType(context,state,indexer);return PickAction(instantiatedType,instantiatedIndexer,options)}function ReadonlyObjectDeferred(type,options={}){return Deferred("ReadonlyObject",[type],options)}function ReadonlyObject(type,options={}){return ReadonlyObjectAction(type,options)}var ReadonlyType=ReadonlyObject;function FromArray5(type){return AddImmutable(_Array_(type))}function FromCyclic4(defs,ref){let target=CyclicTarget(defs,ref),partial=FromType17(target);return Cyclic(memory_exports.Assign(defs,{[ref]:partial}),ref)}function FromDependent4(if_,then_,else_){let evaluated=EvaluateDependent(if_,then_,else_);return FromType17(evaluated)}function FromIntersect4(types){let evaluated=EvaluateIntersect(types);return FromType17(evaluated)}function FromObject8(properties){let mapped=guard_exports.Keys(properties).reduce((result2,left)=>({...result2,[left]:AddReadonly(properties[left])}),{});return _Object_(mapped)}function FromTuple4(types){return AddImmutable(Tuple(types))}function FromUnion7(types){let result=types.map(type=>FromType17(type));return Union(result)}function FromType17(type){return IsArray3(type)?FromArray5(type.items):IsCyclic(type)?FromCyclic4(type.$defs,type.$ref):IsDependent(type)?FromDependent4(type.if,type.then,type.else):IsIntersect(type)?FromIntersect4(type.allOf):IsObject3(type)?FromObject8(type.properties):IsTuple(type)?FromTuple4(type.items):IsUnion(type)?FromUnion7(type.anyOf):type}function ReadonlyObjectAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType17(type),{},options):ReadonlyObjectDeferred(type)}function ReadonlyObjectInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return ReadonlyObjectAction(instantiatedType,options)}function RefInstantiate(context,state,type,ref){return state.visited.includes(ref)?type:ref in context?InstantiateType(context,State(state.callstack,[...state.visited,ref]),context[ref]):type}function FromCyclic5(defs,ref){let target=CyclicTarget(defs,ref),partial=FromType18(target);return Cyclic(memory_exports.Assign(defs,{[ref]:partial}),ref)}function FromDependent5(if_,then_,else_){let evaluated=EvaluateDependent(if_,then_,else_);return FromType18(evaluated)}function FromIntersect5(types){let evaluated=EvaluateIntersect(types);return FromType18(evaluated)}function FromUnion8(types){let result=types.map(type=>FromType18(type));return Union(result)}function FromObject9(properties){let mapped=guard_exports.Keys(properties).reduce((result2,left)=>({...result2,[left]:RemoveOptional(properties[left])}),{});return _Object_(mapped)}function FromType18(type){return IsCyclic(type)?FromCyclic5(type.$defs,type.$ref):IsDependent(type)?FromDependent5(type.if,type.then,type.else):IsIntersect(type)?FromIntersect5(type.allOf):IsUnion(type)?FromUnion8(type.anyOf):IsObject3(type)?FromObject9(type.properties):_Object_({})}function RequiredDeferred(type,options={}){return Deferred("Required",[type],options)}function Required(type,options={}){return RequiredAction(type,options)}function RequiredAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType18(type),{},options):RequiredDeferred(type,options)}function RequiredInstantiate(context,state,type,options){let instaniatedType=InstantiateType(context,state,type);return RequiredAction(instaniatedType,options)}function ReturnTypeDeferred(type,options={}){return Deferred("ReturnType",[type],options)}function ReturnType(type,options={}){return ReturnTypeAction(type,options)}function ReturnTypeOperation(type){return IsFunction3(type)?type.returnType:Never()}function ReturnTypeAction(type,options){return CanInstantiate([type])?memory_exports.Update(ReturnTypeOperation(type),{},options):ReturnTypeDeferred(type,options)}function ReturnTypeInstantiate(context,state,type,options={}){let instantiatedType=InstantiateType(context,state,type);return ReturnTypeAction(instantiatedType,options)}function WithDeferred(type,options){return Deferred("With",[type,options],{})}function With2(type,options){return WithAction(type,options)}function WithAction(type,options){return CanInstantiate([type])?memory_exports.Update(type,{},options):WithDeferred(type,options)}function WithInstantiate(context,state,type,options){let instaniatedType=InstantiateType(context,state,type);return WithAction(instaniatedType,options)}function SpreadElement(type){return IsRest(type)?IsTuple(type.items)?RestSpread(type.items.items):IsInfer(type.items)?[type]:IsRef(type.items)?[type]:[Never()]:[type]}function RestSpread(types){return types.reduce((result2,left)=>[...result2,...SpreadElement(left)],[])}function State(callstack,visited){return{callstack,visited}}function CanInstantiate(types){return guard_exports.ShiftLeft(types,(left,right)=>IsRef(left)?!1:CanInstantiate(right),()=>!0)}function InstantiateProperties(context,state,properties){return guard_exports.Keys(properties).reduce((result,key)=>({...result,[key]:InstantiateType(context,state,properties[key])}),{})}function InstantiateElements(context,state,types){let elements=InstantiateTypes(context,state,types);return RestSpread(elements)}function InstantiateTypes(context,state,types){return types.map(type=>InstantiateType(context,state,type))}function WithModifiers(type,instantiatedType){let withOptional=IsOptional(type)?AddOptionalAction(instantiatedType,{}):instantiatedType,withReadonly=IsReadonly(type)?AddReadonlyAction(withOptional,{}):withOptional;return IsImmutable(type)?AddImmutableAction(withReadonly,{}):withReadonly}function InstantiateDeferred(context,state,action,parameters,options){return guard_exports.IsEqual(action,"AddImmutable")?AddImmutableInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"RemoveImmutable")?RemoveImmutableInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"AddReadonly")?AddReadonlyInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"RemoveReadonly")?RemoveReadonlyInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"AddOptional")?AddOptionalInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"RemoveOptional")?RemoveOptionalInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Capitalize")?CapitalizeInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Conditional")?ConditionalInstantiate(context,state,parameters[0],parameters[1],parameters[2],parameters[3],options):guard_exports.IsEqual(action,"ConstructorParameters")?ConstructorParametersInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Evaluate")?EvaluateInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Exclude")?ExcludeInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"Extract")?ExtractInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"Index")?IndexInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"InstanceType")?InstanceTypeInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Interface")?InterfaceInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"KeyOf")?KeyOfInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Lowercase")?LowercaseInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Mapped")?MappedInstantiate(context,state,parameters[0],parameters[1],parameters[2],parameters[3],options):guard_exports.IsEqual(action,"Module")?ModuleInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"NonNullable")?NonNullableInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Pick")?PickInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"Parameters")?ParametersInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Partial")?PartialInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Omit")?OmitInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"ReadonlyObject")?ReadonlyObjectInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Record")?RecordInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"Required")?RequiredInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"ReturnType")?ReturnTypeInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"TemplateLiteral")?TemplateLiteralInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Uncapitalize")?UncapitalizeInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Uppercase")?UppercaseInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"With")?WithInstantiate(context,state,parameters[0],parameters[1]):Deferred(action,parameters,options)}function InstantiateImmediate(context,state,type){let instantiatedType=IsRef(type)?RefInstantiate(context,state,type,type.$ref):IsArray3(type)?_Array_(InstantiateType(context,state,type.items),ArrayOptions(type)):IsCall(type)?CallInstantiate(context,state,type.target,type.arguments):IsConstructor3(type)?Constructor(InstantiateTypes(context,state,type.parameters),InstantiateType(context,state,type.instanceType),ConstructorOptions(type)):IsFunction3(type)?_Function_(InstantiateTypes(context,state,type.parameters),InstantiateType(context,state,type.returnType),FunctionOptions(type)):IsDependent(type)?Dependent(InstantiateType(context,state,type.if),InstantiateType(context,state,type.then),InstantiateType(context,state,type.else),DependentOptions(type)):IsIntersect(type)?Intersect(InstantiateTypes(context,state,type.allOf),IntersectOptions(type)):IsObject3(type)?_Object_(InstantiateProperties(context,state,type.properties),ObjectOptions(type)):IsRecord(type)?RecordFromPattern(RecordPattern(type),InstantiateType(context,state,RecordValue(type))):IsRest(type)?Rest(InstantiateType(context,state,type.items)):IsTuple(type)?Tuple(InstantiateElements(context,state,type.items),TupleOptions(type)):IsUnion(type)?Union(InstantiateTypes(context,state,type.anyOf),UnionOptions(type)):type;return WithModifiers(type,instantiatedType)}function InstantiateType(context,state,type){return IsDeferred(type)?InstantiateDeferred(context,state,type.action,type.parameters,type.options):InstantiateImmediate(context,state,type)}function Instantiate(context,type){return InstantiateType(context,State([],[]),type)}function AddImmutableOperation(type){return memory_exports.Update(type,{"~immutable":!0},{})}function AddImmutableAction(type,options){return memory_exports.Update(AddImmutableOperation(type),{},options)}function AddImmutableInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return AddImmutableAction(instantiatedType,options)}function AddImmutableDeferred(type,options={}){return Deferred("AddImmutable",[type],options)}function AddImmutable(type,options={}){return AddImmutableAction(type,options)}function RemoveImmutableDeferred(type,options={}){return Deferred("RemoveImmutable",[type],options)}function RemoveImmutable(type,options={}){return RemoveImmutableAction(type,options)}function EvaluateDeferred(type,options={}){return Deferred("Evaluate",[type],options)}function Evaluate2(type,options={}){return EvaluateAction(type,options)}function ModuleDeferred(declarations,options={}){return Deferred("Module",[declarations],options)}function Module2(declarations,options={}){return ModuleInstantiate({},State([],[]),declarations,options)}function Comparer(left,right){let compareResult=Compare(left,right);return guard_exports.IsEqual(compareResult,CompareResultRightInside)||guard_exports.IsEqual(compareResult,CompareResultDisjoint)?1:0}function Insert(type,types,result=[]){return guard_exports.ShiftLeft(types,(left,right)=>guard_exports.IsEqual(Comparer(type,left),1)?Insert(type,right,[...result,left]):[...result,type,...types],()=>[...result,type])}function Sort(types,result=[]){return guard_exports.ShiftLeft(types,(left,right)=>Sort(right,Insert(left,result)),()=>result)}function Priority(types){return Sort(types)}function IsTemplateLiteralPattern(pattern){let types=ParsePatternIntoTypes(pattern);return!guard_exports.IsEqual(types.length,0)}function Script2(...args){let[context,input,options]=arguments_exports.Match(args,{2:(script,options2)=>guard_exports.IsString(script)?[{},script,options2]:[script,options2,{}],3:(context2,script,options2)=>[context2,script,options2],1:script=>[{},script,{}]}),result=Script(input),parsed=guard_exports.IsArray(result)&&guard_exports.IsEqual(result.length,2)?InstantiateType(context,State([],[]),result[0]):Never();return memory_exports.Update(parsed,{},options)}var typebox_exports={};__export(typebox_exports,{Any:()=>Any,Array:()=>_Array_,BigInt:()=>BigInt2,Boolean:()=>Boolean2,Call:()=>Call2,Capitalize:()=>Capitalize,Codec:()=>Codec,Conditional:()=>Conditional,Constructor:()=>Constructor,ConstructorParameters:()=>ConstructorParameters,Cyclic:()=>Cyclic,Decode:()=>Decode,DecodeBuilder:()=>DecodeBuilder,Dependent:()=>Dependent,Encode:()=>Encode,EncodeBuilder:()=>EncodeBuilder,Enum:()=>Enum,Evaluate:()=>Evaluate2,Exclude:()=>Exclude,Extends:()=>Extends,ExtendsResult:()=>result_exports,Extract:()=>Extract,Function:()=>_Function_,Generic:()=>Generic,Identifier:()=>Identifier,Immutable:()=>Immutable,Index:()=>Index,Infer:()=>Infer,InstanceType:()=>InstanceType,Instantiate:()=>Instantiate,Integer:()=>Integer,Interface:()=>Interface,Intersect:()=>Intersect,IsAny:()=>IsAny,IsArray:()=>IsArray3,IsBigInt:()=>IsBigInt3,IsBoolean:()=>IsBoolean4,IsCall:()=>IsCall,IsCodec:()=>IsCodec,IsConstructor:()=>IsConstructor3,IsCyclic:()=>IsCyclic,IsDependent:()=>IsDependent,IsEnum:()=>IsEnum,IsEnumValue:()=>IsEnumValue,IsFunction:()=>IsFunction3,IsGeneric:()=>IsGeneric,IsIdentifier:()=>IsIdentifier2,IsImmutable:()=>IsImmutable,IsInfer:()=>IsInfer,IsInteger:()=>IsInteger3,IsIntersect:()=>IsIntersect,IsKind:()=>IsKind,IsLiteral:()=>IsLiteral,IsNever:()=>IsNever,IsNull:()=>IsNull3,IsNumber:()=>IsNumber4,IsObject:()=>IsObject3,IsOptional:()=>IsOptional,IsParameter:()=>IsParameter,IsReadonly:()=>IsReadonly,IsRecord:()=>IsRecord,IsRef:()=>IsRef,IsRefine:()=>IsRefine,IsRest:()=>IsRest,IsSchema:()=>IsSchema,IsString:()=>IsString4,IsSymbol:()=>IsSymbol3,IsTemplateLiteral:()=>IsTemplateLiteral,IsThis:()=>IsThis,IsTuple:()=>IsTuple,IsUndefined:()=>IsUndefined3,IsUnion:()=>IsUnion,IsUnknown:()=>IsUnknown,IsUnsafe:()=>IsUnsafe,IsVoid:()=>IsVoid,KeyOf:()=>KeyOf2,Literal:()=>Literal,Lowercase:()=>Lowercase,Mapped:()=>Mapped,Module:()=>Module2,Never:()=>Never,NonNullable:()=>NonNullable,Null:()=>Null,Number:()=>Number2,Object:()=>_Object_,Omit:()=>Omit,Optional:()=>Optional,Parameter:()=>Parameter,Parameters:()=>Parameters,Partial:()=>Partial,Pick:()=>Pick,Readonly:()=>Readonly,ReadonlyObject:()=>ReadonlyObject,ReadonlyType:()=>ReadonlyType,Record:()=>Record,RecordKey:()=>RecordKey,RecordPattern:()=>RecordPattern,RecordValue:()=>RecordValue,Ref:()=>Ref,Refine:()=>Refine,Required:()=>Required,Rest:()=>Rest,ReturnType:()=>ReturnType,Script:()=>Script2,String:()=>String2,Symbol:()=>Symbol,TemplateLiteral:()=>TemplateLiteral2,This:()=>This,Tuple:()=>Tuple,Uncapitalize:()=>Uncapitalize,Undefined:()=>Undefined,Union:()=>Union,Unknown:()=>Unknown,Unsafe:()=>Unsafe,Uppercase:()=>Uppercase,Void:()=>Void,With:()=>With2});var build_default=typebox_exports;function buildProviderErrorPattern(patterns){return new RegExp(patterns.join("|"),"i")}var NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN=buildProviderErrorPattern(["GoUsageLimitError","FreeUsageLimitError","Monthly usage limit reached","available balance","insufficient_quota","out of budget","quota exceeded","billing","subscription_sharing_usage_limit_exceeded"]),RETRYABLE_PROVIDER_ERROR_PATTERN=buildProviderErrorPattern(["overloaded","server_busy","servers are currently busy","currently experiencing high demand","model is at capacity","rate.?limit","too many requests","\\b(?:429|500|502|503|504|520|524)\\b","service.?(?:is.?)?(?:temporarily.?)?unavailable","server.?error","internal.?error","provider.?returned.?(?:an.?)?error","exceeded request buffer limit while retrying upstream","unable to forward upstream","upstream.?request.?failed","upstream_stream_read_error","stream was interrupted","http/?2 stream failed","network.?error","connection.?error","connection.?refused","connection.?lost","other side closed","fetch failed","request to \\S+ failed, reason:","getaddrinfo","ENOTFOUND","EAI_AGAIN","upstream.?connect","reset before headers","socket hang up","socket connection was closed","timed? out","timeout","terminated","websocket.?closed","websocket.?error","ended without","stream ended before message_stop","stream ended before a terminal response event","http2 request did not get a response","pending stream has been canceled","retry delay","you can retry your request","try your request again","please retry your request","ResourceExhausted","subscription_sharing_usage_unavailable","subscription_sharing_user_unavailable"]),DEFAULT_MAX_AGENT_RETRY_DELAY_MS=6e4;function retryDelayMs(policy,attempt){let delay=policy.baseDelayMs*2**Math.max(0,attempt-1),safeDelay=Number.isSafeInteger(delay)?delay:Number.MAX_SAFE_INTEGER;return Math.min(safeDelay,policy.maxAgentDelayMs??DEFAULT_MAX_AGENT_RETRY_DELAY_MS)}var RetrySleepAbortError=class extends Error{constructor(){super("Aborted")}};function sleep(ms,signal){return new Promise((resolve,reject)=>{if(signal?.aborted){reject(new RetrySleepAbortError);return}let timeout=setTimeout(resolve,ms);signal?.addEventListener("abort",()=>{clearTimeout(timeout),reject(new RetrySleepAbortError)},{once:!0})})}async function retryAssistantCall(produce,policy,signal,callbacks){let maxAttempts=policy?.enabled?policy.maxRetries:0,attempt=0,lastRetry;for(;;){let response=await produce();if(response.stopReason==="aborted")return lastRetry&&await callbacks?.onRetryFinished?.(!1,lastRetry.attempt),response;if(response.stopReason!=="error")return lastRetry&&await callbacks?.onRetryFinished?.(!0,lastRetry.attempt),response;if(attempt>=maxAttempts||!isRetryableAssistantError(response))return lastRetry&&await callbacks?.onRetryFinished?.(!1,lastRetry.attempt,response.errorMessage),response;attempt++,lastRetry={attempt,errorMessage:response.errorMessage||"Unknown error"};let delayMs=retryDelayMs(policy,attempt);await callbacks?.onRetryScheduled?.(attempt,maxAttempts,delayMs,lastRetry.errorMessage);try{await sleep(delayMs,signal)}catch(error){if(await callbacks?.onRetryFinished?.(!1,attempt,lastRetry.errorMessage),error instanceof RetrySleepAbortError){let{errorMessage:_errorMessage,...rest}=response;return{...rest,stopReason:"aborted"}}throw error}await callbacks?.onRetryAttemptStart?.()}}function isRetryableAssistantError(message){if(message.stopReason!=="error"||!message.errorMessage)return!1;let errorMessage=message.errorMessage;return NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN.test(errorMessage)?!1:RETRYABLE_PROVIDER_ERROR_PATTERN.test(errorMessage)}export{guard_exports,emit_exports,globals_exports,guard_default,settings_exports,Clone,IsSchema,_Array_,IsArray3 as IsArray,ArrayOptions,IsConstructor3 as IsConstructor,IsFunction3 as IsFunction,Ref,IsRef,IsNever,IsOptional,_Object_,IsObject3 as IsObject,Unknown,IsCyclic,arguments_exports,IsEnum,Intersect,IsIntersect,environment_exports,Unreachable,hash_exports,Get2 as Get,IsCodec,IsRefine,IsBigInt3 as IsBigInt,IsBoolean4 as IsBoolean,IsInteger3 as IsInteger,Literal,IsLiteralBigInt,IsLiteralBoolean,IsLiteralNumber,IsLiteralString,IsLiteral,IsNull3 as IsNull,IsNumber4 as IsNumber,IsSymbol3 as IsSymbol,String2 as String,IsString4 as IsString,Union,IsUnion,TemplateLiteralDecode,Tuple,IsTuple,Flatten,Record,RecordPattern,RecordKey,RecordValue,IsRecord,IsUndefined3 as IsUndefined,IsVoid,IsTemplateLiteral,With2 as With,Instantiate,Evaluate2 as Evaluate,Priority,typebox_exports,build_exports,DEFAULT_MAX_AGENT_RETRY_DELAY_MS,retryDelayMs,retryAssistantCall,isRetryableAssistantError};
+`,input),([_0,input2])=>[[_0],input2]),([_0,input2])=>[_0,input2],()=>[]))),([_0,input2])=>[_0,input2]),ModuleDeclarationList_0=(input,result=[])=>If2(If2(ModuleDeclarationDelimiter(input),([_0,input2])=>If2(ModuleDeclaration(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>ModuleDeclarationList_0(input2,[...result,_0]),()=>[result,input]),ModuleDeclarationList=input=>If2(If2(If2(ModuleDeclaration(input),([_0,input2])=>If2(ModuleDeclarationList_0(input2),([_1,input3])=>If2(If2(ModuleDeclarationDelimiter(input3),([_02,input4])=>[[_02],input4],()=>[[],input3]),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[_0,input2],()=>If2([[],input],([_0,input2])=>[_0,input2],()=>[])),([_0,input2])=>[ModuleDeclarationListMapping(_0),input2]),ModuleDeclaration=input=>If2(If2(ExportKeyword(input),([_0,input2])=>If2(If2(InterfaceDeclarationGeneric(input2),([_02,input3])=>[_02,input3],()=>If2(InterfaceDeclaration(input2),([_02,input3])=>[_02,input3],()=>If2(TypeAliasDeclarationGeneric(input2),([_02,input3])=>[_02,input3],()=>If2(TypeAliasDeclaration(input2),([_02,input3])=>[_02,input3],()=>[])))),([_1,input3])=>If2(OptionalSemiColon(input3),([_2,input4])=>[[_0,_1,_2],input4]))),([_0,input2])=>[ModuleDeclarationMapping(_0),input2]),Module=input=>If2(If2(ModuleDeclaration(input),([_0,input2])=>If2(ModuleDeclarationList(input2),([_1,input3])=>[[_0,_1],input3])),([_0,input2])=>[ModuleMapping(_0),input2]),Script=input=>If2(If2(Module(input),([_0,input2])=>[_0,input2],()=>If2(GenericType(input),([_0,input2])=>[_0,input2],()=>If2(Type(input),([_0,input2])=>[_0,input2],()=>[]))),([_0,input2])=>[_0,input2]);function ParseTemplateIntoTypes(template){let parsed=TemplateLiteralTypes(`\`${template}\``);return guard_exports.IsEqual(parsed.length,2)?parsed[0]:Unreachable()}function JoinString(input){return input.join("|")}function UnwrapTemplateLiteralPattern(pattern){return pattern.slice(1,pattern.length-1)}function EncodeLiteral(value,right,pattern){return EncodeTypes(right,`${pattern}${value}`)}function EncodeBigInt(right,pattern){return EncodeTypes(right,`${pattern}${BigIntPattern}`)}function EncodeInteger(right,pattern){return EncodeTypes(right,`${pattern}${IntegerPattern}`)}function EncodeNumber(right,pattern){return EncodeTypes(right,`${pattern}${NumberPattern}`)}function EncodeBoolean(right,pattern){return EncodeType(Union([Literal("false"),Literal("true")]),right,pattern)}function EncodeString(right,pattern){return EncodeTypes(right,`${pattern}${StringPattern}`)}function EncodeTemplateLiteral(templatePattern,right,pattern){return EncodeTypes(right,`${pattern}${UnwrapTemplateLiteralPattern(templatePattern)}`)}function EncodeTemplateLiteralDeferred(types,right,pattern){let templateLiteral=TemplateLiteralAction(types,{});return EncodeType(templateLiteral,right,pattern)}function EncodeEnum(values,right,pattern){let evaluated=EvaluateEnum(values);return EncodeType(evaluated,right,pattern)}function EncodeUnion(types,right,pattern,result=[]){return guard_exports.ShiftLeft(types,(head,tail)=>EncodeUnion(tail,right,pattern,[...result,EncodeType(head,[],"")]),()=>EncodeTypes(right,`${pattern}(${JoinString(result)})`))}function EncodeType(type,right,pattern){return IsEnum(type)?EncodeEnum(type.enum,right,pattern):IsInteger3(type)?EncodeInteger(right,pattern):IsLiteral(type)?EncodeLiteral(type.const,right,pattern):IsBigInt3(type)?EncodeBigInt(right,pattern):IsBoolean4(type)?EncodeBoolean(right,pattern):IsNumber4(type)?EncodeNumber(right,pattern):IsString4(type)?EncodeString(right,pattern):IsTemplateLiteral(type)?EncodeTemplateLiteral(type.pattern,right,pattern):IsTemplateLiteralDeferred(type)?EncodeTemplateLiteralDeferred(type.parameters[0],right,pattern):IsUnion(type)?EncodeUnion(type.anyOf,right,pattern):NeverPattern}function EncodeTypes(types,pattern){return guard_exports.ShiftLeft(types,(left,right)=>EncodeType(left,right,pattern),()=>pattern)}function EncodePattern(types){return`^${EncodeTypes(types,"")}$`}function TemplateLiteralEncode(types){let pattern=EncodePattern(types);return TemplateLiteralCreate(pattern)}function TemplateLiteralAction(types,options){return CanInstantiate(types)?memory_exports.Update(TemplateLiteralEncode(types),{},options):TemplateLiteralDeferred(types,options)}function TemplateLiteralInstantiate(context,state,types,options){let instantiatedTypes=InstantiateTypes(context,state,types);return TemplateLiteralAction(instantiatedTypes,options)}function TemplateLiteralDeferred(types,options={}){return Deferred("TemplateLiteral",[types],options)}function IsTemplateLiteralDeferred(value){return IsSchema(value)&&guard_exports.HasPropertyKey(value,"action")&&guard_exports.IsEqual(value.action,"TemplateLiteral")}function TemplateLiteralFromTypes(types){return TemplateLiteralAction(types,{})}function TemplateLiteralFromString(template){let types=ParseTemplateIntoTypes(template);return TemplateLiteralFromTypes(types)}function TemplateLiteral2(input,options={}){let type=guard_exports.IsString(input)?TemplateLiteralFromString(input):TemplateLiteralFromTypes(input);return memory_exports.Update(type,{},options)}function IsTemplateLiteral(value){return IsKind(value,"TemplateLiteral")}var result_exports={};__export(result_exports,{ExtendsFalse:()=>ExtendsFalse,ExtendsTrue:()=>ExtendsTrue,ExtendsUnion:()=>ExtendsUnion,IsExtendsFalse:()=>IsExtendsFalse,IsExtendsTrue:()=>IsExtendsTrue,IsExtendsTrueLike:()=>IsExtendsTrueLike,IsExtendsUnion:()=>IsExtendsUnion,Match:()=>Match3});function ExtendsUnion(inferred){return memory_exports.Create({"~kind":"ExtendsUnion"},{inferred})}function IsExtendsUnion(value){return guard_exports.IsObject(value)&&guard_exports.HasPropertyKey(value,"~kind")&&guard_exports.HasPropertyKey(value,"inferred")&&guard_exports.IsEqual(value["~kind"],"ExtendsUnion")&&guard_exports.IsObject(value.inferred)}function ExtendsTrue(inferred){return memory_exports.Create({"~kind":"ExtendsTrue"},{inferred})}function IsExtendsTrue(value){return guard_exports.IsObject(value)&&guard_exports.HasPropertyKey(value,"~kind")&&guard_exports.HasPropertyKey(value,"inferred")&&guard_exports.IsEqual(value["~kind"],"ExtendsTrue")&&guard_exports.IsObject(value.inferred)}function ExtendsFalse(){return memory_exports.Create({"~kind":"ExtendsFalse"},{})}function IsExtendsFalse(value){return guard_exports.IsObject(value)&&guard_exports.HasPropertyKey(value,"~kind")&&guard_exports.IsEqual(value["~kind"],"ExtendsFalse")}function IsExtendsTrueLike(value){return IsExtendsUnion(value)||IsExtendsTrue(value)}function Match3(result,true_,false_){return IsExtendsTrueLike(result)?true_(result.inferred):false_()}function ExtendsRightInfer(inferred,name,left,right){return Match3(ExtendsLeft(inferred,left,right),checkInferred=>ExtendsTrue(memory_exports.Assign(memory_exports.Assign(inferred,checkInferred),{[name]:left})),()=>ExtendsFalse())}function ExtendsRightAny(inferred,_left){return ExtendsTrue(inferred)}function ExtendsRightDependent(inferred,left,if_,then_,else_){return Match3(ExtendsLeft(inferred,left,if_),inferred2=>Match3(ExtendsLeft(inferred2,left,then_),inferred3=>ExtendsTrue(inferred3),()=>ExtendsFalse()),()=>Match3(ExtendsLeft(inferred,left,else_),inferred2=>ExtendsTrue(inferred2),()=>ExtendsFalse()))}function ExtendsRightEnum(inferred,left,right){let evaluated=EvaluateEnum(right);return ExtendsLeft(inferred,left,evaluated)}function ExtendsRightIntersect(inferred,left,right){return guard_exports.ShiftLeft(right,(head,tail)=>Match3(ExtendsLeft(inferred,left,head),inferred2=>ExtendsRightIntersect(inferred2,left,tail),()=>ExtendsFalse()),()=>ExtendsTrue(inferred))}function ExtendsRightTemplateLiteral(inferred,left,right){let evaluated=EvaluateTemplateLiteral(right);return ExtendsLeft(inferred,left,evaluated)}function ExtendsRightUnion(inferred,left,right){return guard_exports.ShiftLeft(right,(head,tail)=>Match3(ExtendsLeft(inferred,left,head),inferred2=>ExtendsTrue(inferred2),()=>ExtendsRightUnion(inferred,left,tail)),()=>ExtendsFalse())}function ExtendsRight(inferred,left,right){return IsAny(right)?ExtendsRightAny(inferred,left):IsDependent(right)?ExtendsRightDependent(inferred,left,right.if,right.then,right.else):IsEnum(right)?ExtendsRightEnum(inferred,left,right.enum):IsInfer(right)?ExtendsRightInfer(inferred,right.name,left,right.extends):IsIntersect(right)?ExtendsRightIntersect(inferred,left,right.allOf):IsTemplateLiteral(right)?ExtendsRightTemplateLiteral(inferred,left,right.pattern):IsUnion(right)?ExtendsRightUnion(inferred,left,right.anyOf):IsUnknown(right)?ExtendsTrue(inferred):ExtendsFalse()}function ExtendsAny(inferred,left,right){return IsInfer(right)?ExtendsRight(inferred,left,right):IsAny(right)?ExtendsTrue(inferred):IsUnknown(right)?ExtendsTrue(inferred):ExtendsUnion(inferred)}function ExtendsImmutable(left,right){let isImmutableLeft=IsImmutable(left),isImmutableRight=IsImmutable(right);return isImmutableLeft&&isImmutableRight||!isImmutableLeft&&isImmutableRight?!0:!(isImmutableLeft&&!isImmutableRight)}function ExtendsArray(inferred,arrayLeft,left,right){return IsArray3(right)?ExtendsImmutable(arrayLeft,right)?ExtendsLeft(inferred,left,right.items):ExtendsFalse():ExtendsRight(inferred,arrayLeft,right)}function ExtendsBigInt(inferred,left,right){return IsBigInt3(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsBoolean(inferred,left,right){return IsBoolean4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ParameterCompare(inferred,left,leftRest,right,rightRest){let checkLeft=IsInfer(right)?left:right,checkRight=IsInfer(right)?right:left,isLeftOptional=IsOptional(left),isRightOptional=IsOptional(right);return!isLeftOptional&&isRightOptional?ExtendsFalse():Match3(ExtendsLeft(inferred,checkLeft,checkRight),inferred2=>ExtendsParameters(inferred2,leftRest,rightRest),()=>ExtendsFalse())}function ParameterRight(inferred,left,leftRest,rightRest){return guard_exports.ShiftLeft(rightRest,(head,tail)=>ParameterCompare(inferred,left,leftRest,head,tail),()=>IsOptional(left)?ExtendsTrue(inferred):ExtendsFalse())}function ParametersLeft(inferred,left,rightRest){return guard_exports.ShiftLeft(left,(head,tail)=>ParameterRight(inferred,head,tail,rightRest),()=>ExtendsTrue(inferred))}function ExtendsParameters(inferred,left,right){return ParametersLeft(inferred,left,right)}function ExtendsReturnType(inferred,left,right){return IsVoid(right)?ExtendsTrue(inferred):ExtendsLeft(inferred,left,right)}function ExtendsConstructor(inferred,parameters,returnType,right){return IsAny(right)?ExtendsTrue(inferred):IsUnknown(right)?ExtendsTrue(inferred):IsConstructor3(right)?Match3(ExtendsParameters(inferred,parameters,right.parameters),inferred2=>ExtendsReturnType(inferred2,returnType,right.instanceType),()=>ExtendsFalse()):ExtendsFalse()}function ExtendsDependent(inferred,if_,then_,else_,right){return Match3(ExtendsLeft(inferred,if_,right),()=>ExtendsLeft(inferred,then_,right),()=>ExtendsLeft(inferred,else_,right))}function ExtendsEnum(inferred,left,right){let evaluated=EvaluateEnum(left);return ExtendsLeft(inferred,evaluated,right)}function ExtendsFunction(inferred,parameters,returnType,right){return IsAny(right)?ExtendsTrue(inferred):IsUnknown(right)?ExtendsTrue(inferred):IsFunction3(right)?Match3(ExtendsParameters(inferred,parameters,right.parameters),inferred2=>ExtendsReturnType(inferred2,returnType,right.returnType),()=>ExtendsFalse()):ExtendsFalse()}function ExtendsInteger(inferred,left,right){return IsInteger3(right)?ExtendsTrue(inferred):IsNumber4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsIntersect(inferred,left,right){let evaluated=EvaluateIntersect(left);return ExtendsLeft(inferred,evaluated,right)}function ExtendsLiteralValue(inferred,left,right){return left===right?ExtendsTrue(inferred):ExtendsFalse()}function ExtendsLiteralBigInt(inferred,left,right){return IsLiteral(right)?ExtendsLiteralValue(inferred,left,right.const):IsBigInt3(right)?ExtendsTrue(inferred):ExtendsRight(inferred,Literal(left),right)}function ExtendsLiteralBoolean(inferred,left,right){return IsLiteral(right)?ExtendsLiteralValue(inferred,left,right.const):IsBoolean4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,Literal(left),right)}function ExtendsLiteralNumber(inferred,left,right){return IsLiteral(right)?ExtendsLiteralValue(inferred,left,right.const):IsNumber4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,Literal(left),right)}function ExtendsLiteralString(inferred,left,right){return IsLiteral(right)?ExtendsLiteralValue(inferred,left,right.const):IsString4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,Literal(left),right)}function ExtendsLiteral(inferred,left,right){return guard_exports.IsBigInt(left.const)?ExtendsLiteralBigInt(inferred,left.const,right):guard_exports.IsBoolean(left.const)?ExtendsLiteralBoolean(inferred,left.const,right):guard_exports.IsNumber(left.const)?ExtendsLiteralNumber(inferred,left.const,right):guard_exports.IsString(left.const)?ExtendsLiteralString(inferred,left.const,right):Unreachable()}function ExtendsNever(inferred,left,right){return IsInfer(right)?ExtendsRight(inferred,left,right):ExtendsTrue(inferred)}function ExtendsNull(inferred,left,right){return IsNull3(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsNumber(inferred,left,right){return IsNumber4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsPropertyOptional(inferred,left,right){return IsOptional(left)?IsOptional(right)?ExtendsTrue(inferred):ExtendsFalse():ExtendsTrue(inferred)}function ExtendsProperty(inferred,left,right){return IsInfer(right)&&IsNever(right.extends)?ExtendsFalse():Match3(ExtendsLeft(inferred,left,right),inferred2=>ExtendsPropertyOptional(inferred2,left,right),()=>ExtendsFalse())}function ExtractInferredProperties(keys,properties){return keys.reduce((result,key)=>key in properties?IsExtendsTrueLike(properties[key])?{...result,...properties[key].inferred}:Unreachable():Unreachable(),{})}function ExtendsPropertiesComparer(inferred,left,right){let properties={};for(let rightKey of guard_exports.Keys(right))properties[rightKey]=rightKey in left?ExtendsProperty({},left[rightKey],right[rightKey]):IsOptional(right[rightKey])?IsInfer(right[rightKey])?ExtendsTrue(memory_exports.Assign(inferred,{[right[rightKey].name]:right[rightKey].extends})):ExtendsTrue(inferred):ExtendsFalse();let checked=guard_exports.Values(properties).every(result=>IsExtendsTrueLike(result)),extracted=checked?ExtractInferredProperties(guard_exports.Keys(properties),properties):{};return checked?ExtendsTrue(extracted):ExtendsFalse()}function ExtendsProperties(inferred,left,right){let compared=ExtendsPropertiesComparer(inferred,left,right);return IsExtendsTrueLike(compared)?ExtendsTrue(memory_exports.Assign(inferred,compared.inferred)):ExtendsFalse()}function ExtendsObjectToObject(inferred,left,right){return ExtendsProperties(inferred,left,right)}function RecordMergeInferred(left,right){return guard_exports.Keys(right).reduce((result,key)=>({...result,[key]:guard_exports.HasPropertyKey(left,key)?IsUnion(result[key])?Union([...result[key].anyOf,right[key]]):Union([left[key],right[key]]):right[key]}),left)}function ExtendsRecordComparer(properties,keys,type,result){return guard_exports.ShiftLeft(keys,(left,right)=>Match3(ExtendsLeft({},properties[left],type),inferred=>ExtendsRecordComparer(properties,right,type,RecordMergeInferred(result,inferred)),()=>ExtendsFalse()),()=>ExtendsTrue(result))}function ExtendsObjectToRecord(inferred,properties,_pattern,value){let keys=guard_exports.Keys(properties);return ExtendsRecordComparer(properties,keys,value,inferred)}function ExtendsObject(inferred,left,right){return IsRecord(right)?ExtendsObjectToRecord(inferred,left,RecordPattern(right),RecordValue(right)):IsObject3(right)?ExtendsObjectToObject(inferred,left,right.properties):ExtendsRight(inferred,_Object_(left),right)}function FromObject3(inferred,properties){return guard_exports.IsEqual(guard_exports.Keys(properties).length,0)?ExtendsTrue(inferred):ExtendsFalse()}function FromRecord(inferred,_leftKey,leftValue,_rightKey,rightValue){return ExtendsLeft(inferred,leftValue,rightValue)}function ExtendsRecord(inferred,leftPattern,leftValue,right){return IsRecord(right)?FromRecord(inferred,RecordPatternToType(leftPattern),leftValue,RecordPatternToType(RecordPattern(right)),RecordValue(right)):IsObject3(right)?FromObject3(inferred,right.properties):IsAny(right)?ExtendsTrue(inferred):IsUnknown(right)?ExtendsTrue(inferred):ExtendsFalse()}function ExtendsString(inferred,left,right){return IsString4(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsSymbol(inferred,left,right){return IsSymbol3(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsTemplateLiteral(inferred,left,right){let evaluated=EvaluateTemplateLiteral(left);return ExtendsLeft(inferred,evaluated,right)}function Inferrable(name,type){return memory_exports.Create({"~kind":"Inferrable"},{name,type},{})}function IsInferable(value){return guard_exports.IsObject(value)&&guard_exports.HasPropertyKey(value,"~kind")&&guard_exports.HasPropertyKey(value,"name")&&guard_exports.HasPropertyKey(value,"type")&&guard_exports.IsEqual(value["~kind"],"Inferrable")&&guard_exports.IsString(value.name)&&guard_exports.IsObject(value.type)}function TryRestInferable(type){return IsRest(type)?IsInfer(type.items)?IsArray3(type.items.extends)?Inferrable(type.items.name,type.items.extends.items):IsUnknown(type.items.extends)?Inferrable(type.items.name,type.items.extends):void 0:Unreachable():void 0}function TryInferable(type){return IsInfer(type)?Inferrable(type.name,type.extends):void 0}function TryInferResults(rest,right,result=[]){return guard_exports.ShiftLeft(rest,(head,tail)=>Match3(ExtendsLeft({},head,right),()=>TryInferResults(tail,right,[...result,head]),()=>{}),()=>result)}function InferTupleResult(inferred,name,left,right){let results=TryInferResults(left,right);return guard_exports.IsArray(results)?ExtendsTrue(memory_exports.Assign(inferred,{[name]:Tuple(results)})):ExtendsFalse()}function InferUnionResult(inferred,name,left,right){let results=TryInferResults(left,right);return guard_exports.IsArray(results)?ExtendsTrue(memory_exports.Assign(inferred,{[name]:Union(results)})):ExtendsFalse()}function Reverse(types){return[...types].reverse()}function ApplyReverse(types,reversed){return reversed?Reverse(types):types}function Reversed(types){let first=types.length>0?types[0]:void 0,inferrable=IsSchema(first)?TryRestInferable(first):void 0;return IsSchema(inferrable)}function ElementsCompare(inferred,reversed,left,leftRest,right,rightRest){return Match3(ExtendsLeft(inferred,left,right),checkInferred=>Elements(checkInferred,reversed,leftRest,rightRest),()=>ExtendsFalse())}function ElementsLeft(inferred,reversed,leftRest,right,rightRest){let inferable=TryRestInferable(right);return IsInferable(inferable)?InferTupleResult(inferred,inferable.name,ApplyReverse(leftRest,reversed),inferable.type):guard_exports.ShiftLeft(leftRest,(head,tail)=>ElementsCompare(inferred,reversed,head,tail,right,rightRest),()=>ExtendsFalse())}function ElementsRight(inferred,reversed,leftRest,rightRest){return guard_exports.ShiftLeft(rightRest,(head,tail)=>ElementsLeft(inferred,reversed,leftRest,head,tail),()=>guard_exports.IsEqual(leftRest.length,0)?ExtendsTrue(inferred):ExtendsFalse())}function Elements(inferred,reversed,leftRest,rightRest){return ElementsRight(inferred,reversed,leftRest,rightRest)}function ExtendsTupleToTuple(inferred,left,right){let instantiatedRight=InstantiateElements(inferred,State([],[]),right),reversed=Reversed(instantiatedRight);return Elements(inferred,reversed,ApplyReverse(left,reversed),ApplyReverse(instantiatedRight,reversed))}function ExtendsTupleToArray(inferred,left,right){let inferrable=TryInferable(right);return IsInferable(inferrable)?InferUnionResult(inferred,inferrable.name,left,inferrable.type):guard_exports.ShiftLeft(left,(head,tail)=>Match3(ExtendsLeft(inferred,head,right),inferred2=>ExtendsTupleToArray(inferred2,tail,right),()=>ExtendsFalse()),()=>ExtendsTrue(inferred))}function ExtendsTuple(inferred,left,right){let instantiatedLeft=InstantiateElements(inferred,State([],[]),left);return IsTuple(right)?ExtendsTupleToTuple(inferred,instantiatedLeft,right.items):IsArray3(right)?ExtendsTupleToArray(inferred,instantiatedLeft,right.items):ExtendsRight(inferred,Tuple(instantiatedLeft),right)}function ExtendsUndefined(inferred,left,right){return IsVoid(right)?ExtendsTrue(inferred):IsUndefined3(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsUnionSome(inferred,type,unionTypes){return guard_exports.ShiftLeft(unionTypes,(head,tail)=>Match3(ExtendsLeft(inferred,type,head),inferred2=>ExtendsTrue(inferred2),()=>ExtendsUnionSome(inferred,type,tail)),()=>ExtendsFalse())}function ExtendsUnionLeft(inferred,left,right){return guard_exports.ShiftLeft(left,(head,tail)=>Match3(ExtendsUnionSome(inferred,head,right),inferred2=>ExtendsUnionLeft(inferred2,tail,right),()=>ExtendsFalse()),()=>ExtendsTrue(inferred))}function ExtendsUnion2(inferred,left,right){let inferrable=TryInferable(right);return IsInferable(inferrable)?InferUnionResult(inferred,inferrable.name,left,inferrable.type):IsUnion(right)?ExtendsUnionLeft(inferred,left,right.anyOf):ExtendsUnionLeft(inferred,left,[right])}function ExtendsUnknown(inferred,left,right){return IsInfer(right)?ExtendsRight(inferred,left,right):IsAny(right)?ExtendsTrue(inferred):IsUnknown(right)?ExtendsTrue(inferred):ExtendsFalse()}function ExtendsVoid(inferred,left,right){return IsVoid(right)?ExtendsTrue(inferred):ExtendsRight(inferred,left,right)}function ExtendsLeft(inferred,left,right){return IsAny(left)?ExtendsAny(inferred,left,right):IsArray3(left)?ExtendsArray(inferred,left,left.items,right):IsBigInt3(left)?ExtendsBigInt(inferred,left,right):IsBoolean4(left)?ExtendsBoolean(inferred,left,right):IsConstructor3(left)?ExtendsConstructor(inferred,left.parameters,left.instanceType,right):IsDependent(left)?ExtendsDependent(inferred,left.if,left.then,left.else,right):IsEnum(left)?ExtendsEnum(inferred,left.enum,right):IsFunction3(left)?ExtendsFunction(inferred,left.parameters,left.returnType,right):IsInteger3(left)?ExtendsInteger(inferred,left,right):IsIntersect(left)?ExtendsIntersect(inferred,left.allOf,right):IsLiteral(left)?ExtendsLiteral(inferred,left,right):IsNever(left)?ExtendsNever(inferred,left,right):IsNull3(left)?ExtendsNull(inferred,left,right):IsNumber4(left)?ExtendsNumber(inferred,left,right):IsObject3(left)?ExtendsObject(inferred,left.properties,right):IsRecord(left)?ExtendsRecord(inferred,RecordPattern(left),RecordValue(left),right):IsString4(left)?ExtendsString(inferred,left,right):IsSymbol3(left)?ExtendsSymbol(inferred,left,right):IsTemplateLiteral(left)?ExtendsTemplateLiteral(inferred,left.pattern,right):IsTuple(left)?ExtendsTuple(inferred,left.items,right):IsUndefined3(left)?ExtendsUndefined(inferred,left,right):IsUnion(left)?ExtendsUnion2(inferred,left.anyOf,right):IsUnknown(left)?ExtendsUnknown(inferred,left,right):IsVoid(left)?ExtendsVoid(inferred,left,right):ExtendsFalse()}function InterfaceOperation(heritage,properties){return EvaluateIntersect([...heritage,_Object_(properties)])}function InterfaceAction(heritage,properties,options){return CanInstantiate(heritage)?memory_exports.Update(InterfaceOperation(heritage,properties),{},options):InterfaceDeferred(heritage,properties,options)}function InterfaceInstantiate(context,state,heritage,properties,options){let instantiatedHeritage=InstantiateTypes(context,state,heritage),instantiatedProperties=InstantiateProperties(context,state,properties);return InterfaceAction(instantiatedHeritage,instantiatedProperties,options)}function InterfaceDeferred(heritage,properties,options={}){return Deferred("Interface",[heritage,properties],options)}function IsInterfaceDeferred(value){return IsSchema(value)&&guard_exports.HasPropertyKey(value,"action")&&guard_exports.IsEqual(value.action,"Interface")}function Interface(heritage,properties,options={}){return InterfaceAction(heritage,properties,options)}function FromRef(stack,context,ref){return stack.includes(ref)?!0:FromType3([...stack,ref],context,context[ref])}function FromProperties(stack,context,properties){let types=PropertyValues(properties);return FromTypes2(stack,context,types)}function FromTypes2(stack,context,types){return guard_exports.ShiftLeft(types,(left,right)=>FromType3(stack,context,left)?!0:FromTypes2(stack,context,right),()=>!1)}function FromType3(stack,context,type){return IsRef(type)?FromRef(stack,context,type.$ref):IsArray3(type)?FromType3(stack,context,type.items):IsConstructor3(type)?FromTypes2(stack,context,[...type.parameters,type.instanceType]):IsFunction3(type)?FromTypes2(stack,context,[...type.parameters,type.returnType]):IsInterfaceDeferred(type)?FromProperties(stack,context,type.parameters[1]):IsIntersect(type)?FromTypes2(stack,context,type.allOf):IsObject3(type)?FromProperties(stack,context,type.properties):IsUnion(type)?FromTypes2(stack,context,type.anyOf):IsTuple(type)?FromTypes2(stack,context,type.items):IsRecord(type)?FromType3(stack,context,RecordValue(type)):!1}function CyclicCheck(stack,context,type){return FromType3(stack,context,type)}function ResolveCandidateKeys(context,keys){return keys.reduce((result,left)=>CyclicCheck([left],context,context[left])?[...result,left]:result,[])}function CyclicCandidates(context){let keys=PropertyKeys(context);return ResolveCandidateKeys(context,keys)}function FromRef2(context,ref,result){return result.includes(ref)?result:ref in context?FromType4(context,context[ref],[...result,ref]):Unreachable()}function FromProperties2(context,properties,result){let types=PropertyValues(properties);return FromTypes3(context,types,result)}function FromTypes3(context,types,result){return types.reduce((result2,left)=>FromType4(context,left,result2),result)}function FromType4(context,type,result){return IsRef(type)?FromRef2(context,type.$ref,result):IsArray3(type)?FromType4(context,type.items,result):IsConstructor3(type)?FromTypes3(context,[...type.parameters,type.instanceType],result):IsFunction3(type)?FromTypes3(context,[...type.parameters,type.returnType],result):IsInterfaceDeferred(type)?FromProperties2(context,type.parameters[1],result):IsIntersect(type)?FromTypes3(context,type.allOf,result):IsObject3(type)?FromProperties2(context,type.properties,result):IsUnion(type)?FromTypes3(context,type.anyOf,result):IsTuple(type)?FromTypes3(context,type.items,result):IsRecord(type)?FromType4(context,RecordValue(type),result):result}function CyclicDependencies(context,key,type){return FromType4(context,type,[key])}function FromRef3(_ref){return Any()}function FromProperties3(properties){return guard_exports.Keys(properties).reduce((result,key)=>({...result,[key]:FromType5(properties[key])}),{})}function FromTypes4(types){return types.reduce((result,left)=>[...result,FromType5(left)],[])}function FromType5(type){return IsRef(type)?FromRef3(type.$ref):IsArray3(type)?_Array_(FromType5(type.items),ArrayOptions(type)):IsConstructor3(type)?Constructor(FromTypes4(type.parameters),FromType5(type.instanceType)):IsFunction3(type)?_Function_(FromTypes4(type.parameters),FromType5(type.returnType)):IsIntersect(type)?Intersect(FromTypes4(type.allOf)):IsObject3(type)?_Object_(FromProperties3(type.properties)):IsRecord(type)?Record(RecordKey(type),FromType5(RecordValue(type))):IsUnion(type)?Union(FromTypes4(type.anyOf)):IsTuple(type)?Tuple(FromTypes4(type.items)):type}function CyclicAnyFromParameters(defs,ref){return ref in defs?FromType5(defs[ref]):Unknown()}function CyclicExtends(type){return CyclicAnyFromParameters(type.$defs,type.$ref)}function CyclicInterface(context,heritage,properties){let instantiatedHeritage=InstantiateTypes(context,State([],[]),heritage),instantiatedProperties=InstantiateProperties({},State([],[]),properties);return EvaluateIntersect([...instantiatedHeritage,_Object_(instantiatedProperties)])}function CyclicDefinitions(context,dependencies){return guard_exports.Keys(context).filter(key=>dependencies.includes(key)).reduce((result,key)=>{let type=context[key],instantiatedType=IsInterfaceDeferred(type)?CyclicInterface(context,type.parameters[0],type.parameters[1]):type;return{...result,[key]:instantiatedType}},{})}function InstantiateCyclic(context,ref,type){let dependencies=CyclicDependencies(context,ref,type),definitions=CyclicDefinitions(context,dependencies);return Cyclic(definitions,ref)}function Resolve(defs,ref){return ref in defs?IsRef(defs[ref])?Resolve(defs,defs[ref].$ref):defs[ref]:Never()}function CyclicTarget(defs,ref){return Resolve(defs,ref)}function Canonical(type){return IsCyclic(type)?CyclicExtends(type):IsUnsafe(type)?Unknown():type}function Extends(inferred,left,right){let canonicalLeft=Canonical(left),canonicalRight=Canonical(right);return ExtendsLeft(inferred,canonicalLeft,canonicalRight)}var CompareResultEqual=0,CompareResultDisjoint=1,CompareResultLeftInside=2,CompareResultRightInside=3;function Compare(left,right){let extendsCheck=[Extends({},left,right),Extends({},right,left)];return result_exports.IsExtendsTrueLike(extendsCheck[0])&&result_exports.IsExtendsTrueLike(extendsCheck[1])?CompareResultEqual:result_exports.IsExtendsTrueLike(extendsCheck[0])&&result_exports.IsExtendsFalse(extendsCheck[1])?CompareResultLeftInside:result_exports.IsExtendsFalse(extendsCheck[0])&&result_exports.IsExtendsTrueLike(extendsCheck[1])?CompareResultRightInside:CompareResultDisjoint}function BroadenFilter(type,types,result=[],all=types){return guard_exports.ShiftLeft(types,(left,right)=>{let compare=Compare(type,left);return guard_exports.IsEqual(compare,CompareResultLeftInside)||guard_exports.IsEqual(compare,CompareResultEqual)?all:guard_exports.IsEqual(compare,CompareResultDisjoint)?BroadenFilter(type,right,[...result,left],all):BroadenFilter(type,right,result,all)},()=>[...result,type])}function BroadenType(type,types,result){let evaluated=EvaluateType(type);return IsAny(evaluated)?[evaluated]:IsUnknown(evaluated)?[evaluated]:IsNever(evaluated)?BroadenTypes(types,result):IsObject3(evaluated)?BroadenTypes(types,[...result,evaluated]):BroadenTypes(types,BroadenFilter(evaluated,result))}function BroadenTypes(types,result=[]){return guard_exports.ShiftLeft(types,(left,right)=>BroadenType(left,right,result),()=>result)}function Broaden(types){let broadened=BroadenTypes(types);return Flatten(broadened)}function EvaluateAction(type,options){return memory_exports.Update(EvaluateType(type),{},options)}function EvaluateInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return EvaluateAction(instantiatedType,options)}function CollectDistributionNames(expression,result=[]){return IsDeferred(expression)&&guard_exports.IsEqual(expression.action,"Conditional")?IsRef(expression.parameters[0])?CollectDistributionNames(expression.parameters[2],CollectDistributionNames(expression.parameters[3],[...result,expression.parameters[0].$ref])):CollectDistributionNames(expression.parameters[2],CollectDistributionNames(expression.parameters[3],result)):IsDeferred(expression)&&guard_exports.IsEqual(expression.action,"Mapped")&&IsDeferred(expression.parameters[1])&&guard_exports.IsEqual(expression.parameters[1].action,"KeyOf")&&IsRef(expression.parameters[1].parameters[0])?[...result,expression.parameters[1].parameters[0].$ref]:result}function BuildDistributionArray(parameters,names){return parameters.reduce((result,left)=>[...result,names.includes(left.name)],[])}function ZipDistributionArray(arguments_,distributionArray,result=[]){return guard_exports.ShiftLeft(arguments_,(argumentLeft,argumentRight)=>guard_exports.ShiftLeft(distributionArray,(booleanLeft,booleanRight)=>ZipDistributionArray(argumentRight,booleanRight,[...result,[booleanLeft,argumentLeft]]),()=>result),()=>result)}function CanonicalArgument(type){return IsTemplateLiteral(type)?EvaluateTemplateLiteral(type.pattern):IsEnum(type)?EvaluateEnum(type.enum):type}function Expand(type){let canonicalArgument=CanonicalArgument(type);return IsUnion(canonicalArgument)?[...canonicalArgument.anyOf]:[canonicalArgument]}function Append(current,type){return current.reduce((result,left)=>[...result,[...left,type]],[])}function Cross(current,variants){return variants.reduce((result,left)=>[...result,...Append(current,left)],[])}function Distribute2(zipped){return zipped.reduce((result,left)=>guard_exports.IsEqual(left[0],!0)?Cross(result,Expand(left[1])):Cross(result,[left[1]]),[[]])}function DistributeArguments(parameters,arguments_,expression){let distributionNames=CollectDistributionNames(expression),distributionArray=BuildDistributionArray(parameters,distributionNames),zippedArguments=ZipDistributionArray(arguments_,distributionArray);return IsDeferred(expression)&&guard_exports.IsEqual(expression.action,"Conditional")||IsDeferred(expression)&&guard_exports.IsEqual(expression.action,"Mapped")?Distribute2(zippedArguments):[arguments_]}function FromNotResolvable(){return["(not-resolvable)",Never()]}function FromNotGeneric(){return["(not-generic)",Never()]}function FromGeneric(name,parameters,expression){return[name,Generic(parameters,expression)]}function FromRef4(context,ref,arguments_){return ref in context?FromType6(context,ref,context[ref],arguments_):FromNotResolvable()}function FromType6(context,name,target,arguments_){return IsGeneric(target)?FromGeneric(name,target.parameters,target.expression):IsRef(target)?FromRef4(context,target.$ref,arguments_):FromNotGeneric()}function ResolveTarget(context,target,arguments_){return FromType6(context,"(anonymous)",target,arguments_)}function AssertArgumentExtends(name,type,extends_){if(IsInfer(type)||IsCall(type)||result_exports.IsExtendsTrueLike(Extends({},type,extends_)))return;let cause={parameter:name,expect:extends_,actual:type};throw new Error(`Argument for parameter ${name} does not satisfy constraint`,{cause})}function BindArgument(context,state,name,extends_,type){let instantiatedArgument=InstantiateType(context,state,type);return AssertArgumentExtends(name,instantiatedArgument,extends_),memory_exports.Assign(context,{[name]:instantiatedArgument})}function BindArguments(context,state,parameterLeft,parameterRight,arguments_){let instantiatedExtends=InstantiateType(context,state,parameterLeft.extends),instantiatedEquals=InstantiateType(context,state,parameterLeft.equals);return guard_exports.ShiftLeft(arguments_,(left,right)=>BindParameters(BindArgument(context,state,parameterLeft.name,instantiatedExtends,left),state,parameterRight,right),()=>BindParameters(BindArgument(context,state,parameterLeft.name,instantiatedExtends,instantiatedEquals),state,parameterRight,[]))}function BindParameters(context,state,parameters,arguments_){return guard_exports.ShiftLeft(parameters,(left,right)=>BindArguments(context,state,left,right,arguments_),()=>context)}function ResolveArgumentsContext(context,state,parameters,arguments_){return BindParameters(context,state,parameters,arguments_)}var instantiationDepth=0,instantiationCount=0;function InstantiationAssert(){if(!guard_exports.IsLessThan(instantiationCount,settings_exports.Get().maxInstantiationCount))throw Error("Type instantiation is excessively deep and possibly infinite")}function InstantiationIncrement(){InstantiationAssert(),instantiationCount++,instantiationDepth++}function InstantiationDecrement(){instantiationDepth--,guard_exports.IsEqual(instantiationDepth,0)&&(instantiationCount=0)}function Peek(state){return guard_exports.IsGreaterThan(state.callstack.length,0)?state.callstack[state.callstack.length-1]:""}function IsTailCall(state,name){return guard_exports.IsEqual(Peek(state),name)}function CallDispatch(context,state,target,parameters,expression,arguments_){InstantiationIncrement();try{let argumentsContext=ResolveArgumentsContext(context,state,parameters,arguments_),returnType=InstantiateType(argumentsContext,State([...state.callstack,target.$ref],state.visited),expression);return InstantiateType(argumentsContext,State([],[]),returnType)}finally{InstantiationDecrement()}}function CallDistributed(context,state,target,parameters,expression,distributedArguments){return distributedArguments.reduce((result,arguments_)=>{let returnType=CallDispatch(context,state,target,parameters,expression,arguments_);return[...result,returnType]},[])}function CallImmediate(context,state,target,parameters,expression,arguments_){let distributedArguments=DistributeArguments(parameters,arguments_,expression),returnTypes=CallDistributed(context,state,target,parameters,expression,distributedArguments);return guard_exports.IsEqual(returnTypes.length,1)?returnTypes[0]:EvaluateUnion(returnTypes)}function CallInstantiate(context,state,target,arguments_){let instantiatedArguments=InstantiateTypes(context,state,arguments_),resolved=ResolveTarget(context,target,arguments_),name=resolved[0],type=resolved[1];return IsGeneric(type)?IsTailCall(state,name)?CallConstruct(Ref(name),instantiatedArguments):CallImmediate(context,state,Ref(name),type.parameters,type.expression,instantiatedArguments):CallConstruct(target,instantiatedArguments)}function CallConstruct(target,arguments_){return memory_exports.Create({"~kind":"Call"},{type:"call",target,arguments:arguments_},{})}function Call2(target,arguments_){return CallInstantiate({},State([],[]),target,arguments_)}function IsCall(value){return IsKind(value,"Call")}function RemoveImmutableOperation(type){return memory_exports.Discard(type,["~immutable"])}function RemoveImmutableAction(type,options){return memory_exports.Update(RemoveImmutableOperation(type),{},options)}function RemoveImmutableInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return RemoveImmutableAction(instantiatedType,options)}function ApplyMapping(mapping,value){return mapping(value)}function FromLiteral3(mapping,value){return guard_exports.IsString(value)?Literal(ApplyMapping(mapping,value)):Literal(value)}function FromTemplateLiteral(mapping,pattern){let evaluated=EvaluateTemplateLiteral(pattern);return FromType7(mapping,evaluated)}function FromUnion2(mapping,types){let result=types.map(type=>FromType7(mapping,type));return Union(result)}function FromType7(mapping,type){return IsLiteral(type)?FromLiteral3(mapping,type.const):IsTemplateLiteral(type)?FromTemplateLiteral(mapping,type.pattern):IsUnion(type)?FromUnion2(mapping,type.anyOf):type}function CapitalizeDeferred(type,options={}){return Deferred("Capitalize",[type],options)}function Capitalize(type,options={}){return CapitalizeAction(type,options)}function LowercaseDeferred(type,options={}){return Deferred("Lowercase",[type],options)}function Lowercase(type,options={}){return LowercaseAction(type,options)}function UncapitalizeDeferred(type,options={}){return Deferred("Uncapitalize",[type],options)}function Uncapitalize(type,options={}){return UncapitalizeAction(type,options)}function UppercaseDeferred(type,options={}){return Deferred("Uppercase",[type],options)}function Uppercase(type,options={}){return UppercaseAction(type,options)}var CapitalizeMapping=input=>input[0].toUpperCase()+input.slice(1),LowercaseMapping=input=>input.toLowerCase(),UncapitalizeMapping=input=>input[0].toLowerCase()+input.slice(1),UppercaseMapping=input=>input.toUpperCase();function CapitalizeAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType7(CapitalizeMapping,type),{},options):CapitalizeDeferred(type,options)}function LowercaseAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType7(LowercaseMapping,type),{},options):LowercaseDeferred(type,options)}function UncapitalizeAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType7(UncapitalizeMapping,type),{},options):UncapitalizeDeferred(type,options)}function UppercaseAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType7(UppercaseMapping,type),{},options):UppercaseDeferred(type,options)}function CapitalizeInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return CapitalizeAction(instantiatedType,options)}function LowercaseInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return LowercaseAction(instantiatedType,options)}function UncapitalizeInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return UncapitalizeAction(instantiatedType,options)}function UppercaseInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return UppercaseAction(instantiatedType,options)}function ConditionalDeferred(left,right,true_,false_,options={}){return Deferred("Conditional",[left,right,true_,false_],options)}function Conditional(left,right,true_,false_,options={}){return ConditionalAction({},State([],[]),left,right,true_,false_,options)}function ConditionalOperation(context,state,left,right,true_,false_){let extendsResult=Extends(context,left,right);return result_exports.IsExtendsUnion(extendsResult)?Union([InstantiateType(extendsResult.inferred,state,true_),InstantiateType(context,state,false_)]):result_exports.IsExtendsTrue(extendsResult)?InstantiateType(extendsResult.inferred,state,true_):InstantiateType(context,state,false_)}function ConditionalAction(context,state,left,right,true_,false_,options){return CanInstantiate([left,right])?memory_exports.Update(ConditionalOperation(context,state,left,right,true_,false_),{},options):ConditionalDeferred(left,right,true_,false_,options)}function ConditionalInstantiate(context,state,left,right,true_,false_,options){let instantiatedLeft=InstantiateType(context,state,left),instantiatedRight=InstantiateType(context,state,right);return ConditionalAction(context,state,instantiatedLeft,instantiatedRight,true_,false_,options)}function ConstructorParametersDeferred(type,options={}){return Deferred("ConstructorParameters",[type],options)}function ConstructorParameters(type,options={}){return ConstructorParametersAction(type,options)}function ConstructorParametersOperation(type){let parameters=IsConstructor3(type)?type.parameters:[],instantiatedParameters=InstantiateElements({},State([],[]),parameters);return Tuple(instantiatedParameters)}function ConstructorParametersAction(type,options){return CanInstantiate([type])?memory_exports.Update(ConstructorParametersOperation(type),{},options):ConstructorParametersDeferred(type,options)}function ConstructorParametersInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return ConstructorParametersAction(instantiatedType,options)}function ExcludeDeferred(left,right,options={}){return Deferred("Exclude",[left,right],options)}function Exclude(left,right,options={}){return ExcludeAction(left,right,options)}function ExcludeAction(left,right,options){return CanInstantiate([left,right])?memory_exports.Update(ExcludeOperation(left,right),{},options):ExcludeDeferred(left,right,options)}function ExcludeInstantiate(context,state,left,right,options){let instantiatedLeft=InstantiateType(context,state,left),instantiatedRight=InstantiateType(context,state,right);return ExcludeAction(instantiatedLeft,instantiatedRight,options)}function ExtractDeferred(left,right,options={}){return Deferred("Extract",[left,right],options)}function Extract(left,right,options={}){return ExtractAction(left,right,options)}function ExtractType(left,right){let check=Extends({},left,right);return result_exports.IsExtendsTrueLike(check)?[left]:[]}function ExtractUnion(left,right,result=[]){return guard_exports.ShiftLeft(left,(head,tail)=>ExtractUnion(tail,right,[...result,...ExtractType(head,right)]),()=>result)}function ExtractOperation(left,right){let evaluated=EvaluateType(left),canonical=IsUnion(evaluated)?evaluated.anyOf:[evaluated],remaining=ExtractUnion(canonical,right);return EvaluateUnion(remaining)}function ExtractAction(left,right,options){return CanInstantiate([left,right])?memory_exports.Update(ExtractOperation(left,right),{},options):ExtractDeferred(left,right,options)}function ExtractInstantiate(context,state,left,right,options){let instantiatedLeft=InstantiateType(context,state,left),instantiatedRight=InstantiateType(context,state,right);return ExtractAction(instantiatedLeft,instantiatedRight,options)}function KeysToLiterals(keys){return keys.reduce((result,left)=>IsLiteralValue(left)?[...result,Literal(left)]:result,[])}function KeysToIndexer(keys){let literals=KeysToLiterals(keys);return Union(literals)}function IndexDeferred(type,indexer,options={}){return Deferred("Index",[type,indexer],options)}function Index(type,indexer_or_keys,options={}){let indexer=guard_exports.IsArray(indexer_or_keys)?KeysToIndexer(indexer_or_keys):indexer_or_keys;return IndexAction(type,indexer,options)}function FromCyclic(defs,ref){let target=CyclicTarget(defs,ref);return FromType8(target)}function FromDependent(if_,then_,else_){let evaluated=EvaluateDependent(if_,then_,else_);return FromType8(evaluated)}function CollapseIntersectProperties(left,right){let leftKeys=guard_exports.Keys(left).filter(key=>!guard_exports.HasPropertyKey(right,key)),rightKeys=guard_exports.Keys(right).filter(key=>!guard_exports.HasPropertyKey(left,key)),sharedKeys=guard_exports.Keys(left).filter(key=>guard_exports.HasPropertyKey(right,key)),leftProperties=leftKeys.reduce((result,key)=>({...result,[key]:left[key]}),{}),rightProperties=rightKeys.reduce((result,key)=>({...result,[key]:right[key]}),{}),sharedProperties=sharedKeys.reduce((result,key)=>({...result,[key]:EvaluateIntersect([left[key],right[key]])}),{}),unique=memory_exports.Assign(leftProperties,rightProperties);return memory_exports.Assign(unique,sharedProperties)}function FromIntersect(types){return types.reduce((result,left)=>CollapseIntersectProperties(result,FromType8(left)),{})}function FromTuple(types){let object=TupleToObject(Tuple(types));return FromType8(object)}function CollapseUnionProperties(left,right){return guard_exports.Keys(left).filter(key=>key in right).reduce((result2,key)=>({...result2,[key]:EvaluateUnion([left[key],right[key]])}),{})}function ReduceVariants(types,result){return guard_exports.ShiftLeft(types,(left,right)=>ReduceVariants(right,CollapseUnionProperties(result,FromType8(left))),()=>result)}function FromUnion3(types){return guard_exports.ShiftLeft(types,(left,right)=>ReduceVariants(right,FromType8(left)),()=>Unreachable())}function FromType8(type){return IsCyclic(type)?FromCyclic(type.$defs,type.$ref):IsDependent(type)?FromDependent(type.if,type.then,type.else):IsIntersect(type)?FromIntersect(type.allOf):IsUnion(type)?FromUnion3(type.anyOf):IsTuple(type)?FromTuple(type.items):IsObject3(type)?type.properties:{}}function CollapseToObject(type){let properties=FromType8(type);return _Object_(properties)}var integerKeyPattern=new RegExp("^(?:0|[1-9][0-9]*)$");function ConvertToIntegerKey(value){let normal=`${value}`;return integerKeyPattern.test(normal)?parseInt(normal):value}function NormalizeLiteral(value){return Literal(ConvertToIntegerKey(value))}function NormalizeIndexerTypes(types){return types.map(type=>NormalizeIndexer(type))}function NormalizeIndexer(type){return IsIntersect(type)?Intersect(NormalizeIndexerTypes(type.allOf)):IsUnion(type)?Union(NormalizeIndexerTypes(type.anyOf)):IsLiteral(type)?NormalizeLiteral(type.const):type}function FromArray3(type,indexer){let normalizedIndexer=NormalizeIndexer(indexer),check=Extends({},normalizedIndexer,Number2());return result_exports.IsExtendsTrueLike(check)?type:IsLiteral(indexer)&&guard_exports.IsEqual(indexer.const,"length")?Number2():Never()}function FromCyclic2(defs,ref){let target=CyclicTarget(defs,ref);return FromType9(target)}function FromDependent2(if_,then_,else_){let evaluated=EvaluateDependent(if_,then_,else_);return FromType9(evaluated)}function FromEnum(values){let evaluated=EvaluateEnum(values);return FromType9(evaluated)}function FromIntersect2(types){let evaluated=EvaluateIntersect(types);return FromType9(evaluated)}function FromLiteral4(value){return[`${value}`]}function FromTemplateLiteral2(pattern){let evaluated=EvaluateTemplateLiteral(pattern);return FromType9(evaluated)}function FromUnion4(types){return types.reduce((result,left)=>[...result,...FromType9(left)],[])}function FromType9(type){return IsCyclic(type)?FromCyclic2(type.$defs,type.$ref):IsDependent(type)?FromDependent2(type.if,type.then,type.else):IsEnum(type)?FromEnum(type.enum):IsIntersect(type)?FromIntersect2(type.allOf):IsLiteral(type)?FromLiteral4(type.const):IsTemplateLiteral(type)?FromTemplateLiteral2(type.pattern):IsUnion(type)?FromUnion4(type.anyOf):[]}function ToIndexableKeys(type){return FromType9(type)}function FromTypes5(properties,types){return types.map(type=>FromType10(properties,type))}function FromType10(properties,type){return IsArray3(type)?_Array_(FromType10(properties,type.items)):IsConstructor3(type)?Constructor(FromTypes5(properties,type.parameters),FromType10(properties,type.instanceType)):IsFunction3(type)?_Function_(FromTypes5(properties,type.parameters),FromType10(properties,type.returnType)):IsTuple(type)?Tuple(FromTypes5(properties,type.items)):IsUnion(type)?Union(FromTypes5(properties,type.anyOf)):IsIntersect(type)?Intersect(FromTypes5(properties,type.allOf)):IsThis(type)?_Object_(properties):type}function ExpandThis(properties,type){return FromType10(properties,type)}function IndexProperty(properties,key){let selectedType=key in properties?properties[key]:Never();return ExpandThis(properties,selectedType)}function IndexProperties(properties,keys){return keys.reduce((result,left)=>[...result,IndexProperty(properties,left)],[])}function FromIndexer(properties,indexer){let keys=ToIndexableKeys(indexer),variants=IndexProperties(properties,keys);return EvaluateUnion(variants)}var NumericKeyPattern=new RegExp(IntegerKey);function NumericKeys(keys){return keys.filter(key=>NumericKeyPattern.test(key))}function FromIndexerNumber(properties){let keys=PropertyKeys(properties),numericKeys=NumericKeys(keys),variants=IndexProperties(properties,numericKeys);return EvaluateUnion(variants)}function FromObject5(properties,indexer){return IsNumber4(indexer)?FromIndexerNumber(properties):FromIndexer(properties,indexer)}function ConvertLiteral(value){return Literal(ConvertToIntegerKey(value))}function ArrayIndexerTypes(types){return types.map(type=>FormatArrayIndexer(type))}function FormatArrayIndexer(type){return IsIntersect(type)?Intersect(ArrayIndexerTypes(type.allOf)):IsUnion(type)?Union(ArrayIndexerTypes(type.anyOf)):IsLiteral(type)?ConvertLiteral(type.const):type}function IndexElementsWithIndexer(types,indexer){return types.reduceRight((result,right,index)=>{let check=Extends({},Literal(index),indexer);return result_exports.IsExtendsTrueLike(check)?[right,...result]:result},[])}function FromTupleWithIndexer(types,indexer){let formattedArrayIndexer=FormatArrayIndexer(indexer),elements=IndexElementsWithIndexer(types,formattedArrayIndexer);return EvaluateUnionFast(elements)}function FromTupleWithoutIndexer(types){return EvaluateUnionFast(types)}function FromTuple2(types,indexer){return IsLiteral(indexer)&&guard_exports.IsEqual(indexer.const,"length")?Literal(types.length):IsNumber4(indexer)||IsInteger3(indexer)?FromTupleWithoutIndexer(types):FromTupleWithIndexer(types,indexer)}function FromType11(type,indexer){return IsArray3(type)?FromArray3(type.items,indexer):IsObject3(type)?FromObject5(type.properties,indexer):IsTuple(type)?FromTuple2(type.items,indexer):Never()}function NormalizeType(type){return IsCyclic(type)||IsDependent(type)||IsIntersect(type)||IsUnion(type)?CollapseToObject(type):type}function IndexAction(type,indexer,options){return CanInstantiate([type,indexer])?memory_exports.Update(FromType11(NormalizeType(type),indexer),{},options):IndexDeferred(type,indexer,options)}function IndexInstantiate(context,state,type,indexer,options){let instantiatedType=InstantiateType(context,state,type),instantiatedIndexer=InstantiateType(context,state,indexer);return IndexAction(instantiatedType,instantiatedIndexer,options)}function InstanceTypeDeferred(type,options={}){return Deferred("InstanceType",[type],options)}function InstanceType(type,options={}){return InstanceTypeAction(type,options)}function InstanceTypeOperation(type){return IsConstructor3(type)?type.instanceType:Never()}function InstanceTypeAction(type,options){return CanInstantiate([type])?memory_exports.Update(InstanceTypeOperation(type),{},options):InstanceTypeDeferred(type,options)}function InstanceTypeInstantiate(context,state,type,options={}){let instantiatedType=InstantiateType(context,state,type);return InstanceTypeAction(instantiatedType,options)}function KeyOfDeferred(type,options={}){return Deferred("KeyOf",[type],options)}function KeyOf2(type,options={}){return KeyOfAction(type,options)}function FromAny(){return Union([Number2(),String2(),Symbol()])}function FromArray4(_type){return Number2()}function FromPropertyKeys(keys){return keys.reduce((result2,left)=>IsLiteralValue(left)?[...result2,Literal(ConvertToIntegerKey(left))]:Unreachable(),[])}function FromObject6(properties){let propertyKeys=guard_exports.Keys(properties),variants=FromPropertyKeys(propertyKeys);return EvaluateUnionFast(variants)}function FromRecord2(type){return RecordKey(type)}function FromTuple3(types){let result=types.map((_,index)=>Literal(index));return EvaluateUnionFast(result)}function FromType12(type){return IsAny(type)?FromAny():IsArray3(type)?FromArray4(type.items):IsObject3(type)?FromObject6(type.properties):IsRecord(type)?FromRecord2(type):IsTuple(type)?FromTuple3(type.items):Never()}function NormalizeType2(type){return IsCyclic(type)||IsDependent(type)||IsIntersect(type)||IsUnion(type)?CollapseToObject(type):type}function KeyOfAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType12(NormalizeType2(type)),{},options):KeyOfDeferred(type,options)}function KeyOfInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return KeyOfAction(instantiatedType,options)}function MappedDeferred(identifier,type,as,property,options={}){return Deferred("Mapped",[identifier,type,as,property],options)}function Mapped(identifier,type,as,property,options={}){return MappedAction({},State([],[]),identifier,type,as,property,options)}function FromTemplateLiteral3(pattern){let evaluated=EvaluateTemplateLiteral(pattern);return FromType13(evaluated)}function FromUnion5(types){return types.reduce((result,left)=>[...result,...FromType13(left)],[])}function FromEnum2(values){let evaluated=EvaluateEnum(values);return FromType13(evaluated)}function FromLiteral5(value){return guard_exports.IsNumber(value)?[Literal(`${value}`)]:[Literal(value)]}function FromType13(type){return IsEnum(type)?FromEnum2(type.enum):IsLiteral(type)?FromLiteral5(type.const):IsTemplateLiteral(type)?FromTemplateLiteral3(type.pattern):IsUnion(type)?FromUnion5(type.anyOf):[type]}function MappedVariants(type){return FromType13(type)}function CanonicalAs(instantiatedAs){return IsTemplateLiteral(instantiatedAs)?EvaluateTemplateLiteral(instantiatedAs.pattern):instantiatedAs}function MappedVariant(context,state,identifier,variant,as,property){let variantContext=memory_exports.Assign(context,{[identifier.name]:variant}),instantiatedAs=InstantiateType(variantContext,state,as),canonicalAs=CanonicalAs(instantiatedAs),instantiatedProperty=InstantiateType(variantContext,state,property);return IsLiteralNumber(canonicalAs)||IsLiteralString(canonicalAs)?{[canonicalAs.const]:instantiatedProperty}:{}}function MappedProperties(context,state,identifier,variants,as,property){return variants.reduce((result,left)=>[...result,MappedVariant(context,state,identifier,left,as,property)],[])}function MappedObjects(properties){return properties.reduce((result,left)=>[...result,_Object_(left)],[])}function MappedOperation(context,state,identifier,type,as,property){let variants=MappedVariants(type),mappedProperties=MappedProperties(context,state,identifier,variants,as,property),mappedObjects=MappedObjects(mappedProperties);return EvaluateIntersect(mappedObjects)}function MappedAction(context,state,identifier,type,as,property,options){return CanInstantiate([type])?memory_exports.Update(MappedOperation(context,state,identifier,type,as,property),{},options):MappedDeferred(identifier,type,as,property,options)}function MappedInstantiate(context,state,identifier,type,as,property,options){let instantiatedType=InstantiateType(context,state,type);return MappedAction(context,state,identifier,instantiatedType,as,property,options)}function InstantiateCyclics(context,declarations,cyclicKeys){let declarationContext=memory_exports.Assign(context,declarations);return guard_exports.Keys(declarations).filter(key=>cyclicKeys.includes(key)).reduce((result,key)=>({...result,[key]:InstantiateCyclic(declarationContext,key,declarations[key])}),{})}function InstantiateNonCyclics(context,declarations,cyclicKeys){let declarationContext=memory_exports.Assign(context,declarations);return guard_exports.Keys(declarations).filter(key=>!cyclicKeys.includes(key)).reduce((result,key)=>({...result,[key]:InstantiateType(declarationContext,State([],[]),declarations[key])}),{})}function InstantiateModule(context,declarations,options){let cyclicCandidates=CyclicCandidates(declarations),instantiatedCyclics=InstantiateCyclics(context,declarations,cyclicCandidates),instantiatedNonCyclics=InstantiateNonCyclics(context,declarations,cyclicCandidates),instantiatedModule={...instantiatedCyclics,...instantiatedNonCyclics};return memory_exports.Update(instantiatedModule,{},options)}function ModuleInstantiate(context,_state,declarations,options){return InstantiateModule(context,declarations,options)}function NonNullableDeferred(type,options={}){return Deferred("NonNullable",[type],options)}function NonNullable(type,options={}){return NonNullableAction(type,options)}function NonNullableOperation(type){let excluded=Union([Null(),Undefined()]);return ExcludeAction(type,excluded,{})}function NonNullableAction(type,options){return CanInstantiate([type])?memory_exports.Update(NonNullableOperation(type),{},options):NonNullableDeferred(type,options)}function NonNullableInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return NonNullableAction(instantiatedType,options)}function OmitDeferred(type,indexer,options={}){return Deferred("Omit",[type,indexer],options)}function Omit(type,indexer_or_keys,options={}){let indexer=guard_exports.IsArray(indexer_or_keys)?KeysToIndexer(indexer_or_keys):indexer_or_keys;return OmitAction(type,indexer,options)}function ToIndexable(type){let collapsed=CollapseToObject(type);return IsObject3(collapsed)?collapsed.properties:Unreachable()}function FromKeys(properties,keys){return guard_exports.Keys(properties).reduce((result2,key)=>keys.includes(key)?result2:{...result2,[key]:properties[key]},{})}function FromType14(type,indexer){let indexable=ToIndexable(type),indexableKeys=ToIndexableKeys(indexer),omitted=FromKeys(indexable,indexableKeys);return _Object_(omitted)}function OmitAction(type,indexer,options){return CanInstantiate([type,indexer])?memory_exports.Update(FromType14(type,indexer),{},options):OmitDeferred(type,indexer,options)}function OmitInstantiate(context,state,type,indexer,options){let instantiatedType=InstantiateType(context,state,type),instantiatedIndexer=InstantiateType(context,state,indexer);return OmitAction(instantiatedType,instantiatedIndexer,options)}function ParametersDeferred(type,options={}){return Deferred("Parameters",[type],options)}function Parameters(type,options={}){return ParametersAction(type,options)}function ParametersOperation(type){let parameters=IsFunction3(type)?type.parameters:[],instantiatedParameters=InstantiateElements({},State([],[]),parameters);return Tuple(instantiatedParameters)}function ParametersAction(type,options){return CanInstantiate([type])?memory_exports.Update(ParametersOperation(type),{},options):ParametersDeferred(type,options)}function ParametersInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return ParametersAction(instantiatedType,options)}function PartialDeferred(type,options={}){return Deferred("Partial",[type],options)}function Partial(type,options={}){return PartialAction(type,options)}function FromCyclic3(defs,ref){let target=CyclicTarget(defs,ref),partial=FromType15(target);return Cyclic(memory_exports.Assign(defs,{[ref]:partial}),ref)}function FromDependent3(if_,then_,else_){let evaluated=EvaluateDependent(if_,then_,else_);return FromType15(evaluated)}function FromIntersect3(types){let evaluated=EvaluateIntersect(types);return FromType15(evaluated)}function FromUnion6(types){let result=types.map(type=>FromType15(type));return Union(result)}function FromObject7(properties){let mapped=guard_exports.Keys(properties).reduce((result2,left)=>({...result2,[left]:AddOptional(properties[left])}),{});return _Object_(mapped)}function FromType15(type){return IsCyclic(type)?FromCyclic3(type.$defs,type.$ref):IsDependent(type)?FromDependent3(type.if,type.then,type.else):IsIntersect(type)?FromIntersect3(type.allOf):IsUnion(type)?FromUnion6(type.anyOf):IsObject3(type)?FromObject7(type.properties):_Object_({})}function PartialAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType15(type),{},options):PartialDeferred(type,options)}function PartialInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return PartialAction(instantiatedType,options)}function PickDeferred(type,indexer,options={}){return Deferred("Pick",[type,indexer],options)}function Pick(type,indexer_or_keys,options={}){let indexer=guard_exports.IsArray(indexer_or_keys)?KeysToIndexer(indexer_or_keys):indexer_or_keys;return PickAction(type,indexer,options)}function FromKeys2(properties,keys){return guard_exports.Keys(properties).reduce((result2,key)=>keys.includes(key)?memory_exports.Assign(result2,{[key]:properties[key]}):result2,{})}function FromType16(type,indexer){let indexable=ToIndexable(type),keys=ToIndexableKeys(indexer),applied=FromKeys2(indexable,keys);return _Object_(applied)}function PickAction(type,indexer,options){return CanInstantiate([type,indexer])?memory_exports.Update(FromType16(type,indexer),{},options):PickDeferred(type,indexer,options)}function PickInstantiate(context,state,type,indexer,options){let instantiatedType=InstantiateType(context,state,type),instantiatedIndexer=InstantiateType(context,state,indexer);return PickAction(instantiatedType,instantiatedIndexer,options)}function ReadonlyObjectDeferred(type,options={}){return Deferred("ReadonlyObject",[type],options)}function ReadonlyObject(type,options={}){return ReadonlyObjectAction(type,options)}var ReadonlyType=ReadonlyObject;function FromArray5(type){return AddImmutable(_Array_(type))}function FromCyclic4(defs,ref){let target=CyclicTarget(defs,ref),partial=FromType17(target);return Cyclic(memory_exports.Assign(defs,{[ref]:partial}),ref)}function FromDependent4(if_,then_,else_){let evaluated=EvaluateDependent(if_,then_,else_);return FromType17(evaluated)}function FromIntersect4(types){let evaluated=EvaluateIntersect(types);return FromType17(evaluated)}function FromObject8(properties){let mapped=guard_exports.Keys(properties).reduce((result2,left)=>({...result2,[left]:AddReadonly(properties[left])}),{});return _Object_(mapped)}function FromTuple4(types){return AddImmutable(Tuple(types))}function FromUnion7(types){let result=types.map(type=>FromType17(type));return Union(result)}function FromType17(type){return IsArray3(type)?FromArray5(type.items):IsCyclic(type)?FromCyclic4(type.$defs,type.$ref):IsDependent(type)?FromDependent4(type.if,type.then,type.else):IsIntersect(type)?FromIntersect4(type.allOf):IsObject3(type)?FromObject8(type.properties):IsTuple(type)?FromTuple4(type.items):IsUnion(type)?FromUnion7(type.anyOf):type}function ReadonlyObjectAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType17(type),{},options):ReadonlyObjectDeferred(type)}function ReadonlyObjectInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return ReadonlyObjectAction(instantiatedType,options)}function RefInstantiate(context,state,type,ref){return state.visited.includes(ref)?type:ref in context?InstantiateType(context,State(state.callstack,[...state.visited,ref]),context[ref]):type}function FromCyclic5(defs,ref){let target=CyclicTarget(defs,ref),partial=FromType18(target);return Cyclic(memory_exports.Assign(defs,{[ref]:partial}),ref)}function FromDependent5(if_,then_,else_){let evaluated=EvaluateDependent(if_,then_,else_);return FromType18(evaluated)}function FromIntersect5(types){let evaluated=EvaluateIntersect(types);return FromType18(evaluated)}function FromUnion8(types){let result=types.map(type=>FromType18(type));return Union(result)}function FromObject9(properties){let mapped=guard_exports.Keys(properties).reduce((result2,left)=>({...result2,[left]:RemoveOptional(properties[left])}),{});return _Object_(mapped)}function FromType18(type){return IsCyclic(type)?FromCyclic5(type.$defs,type.$ref):IsDependent(type)?FromDependent5(type.if,type.then,type.else):IsIntersect(type)?FromIntersect5(type.allOf):IsUnion(type)?FromUnion8(type.anyOf):IsObject3(type)?FromObject9(type.properties):_Object_({})}function RequiredDeferred(type,options={}){return Deferred("Required",[type],options)}function Required(type,options={}){return RequiredAction(type,options)}function RequiredAction(type,options){return CanInstantiate([type])?memory_exports.Update(FromType18(type),{},options):RequiredDeferred(type,options)}function RequiredInstantiate(context,state,type,options){let instaniatedType=InstantiateType(context,state,type);return RequiredAction(instaniatedType,options)}function ReturnTypeDeferred(type,options={}){return Deferred("ReturnType",[type],options)}function ReturnType(type,options={}){return ReturnTypeAction(type,options)}function ReturnTypeOperation(type){return IsFunction3(type)?type.returnType:Never()}function ReturnTypeAction(type,options){return CanInstantiate([type])?memory_exports.Update(ReturnTypeOperation(type),{},options):ReturnTypeDeferred(type,options)}function ReturnTypeInstantiate(context,state,type,options={}){let instantiatedType=InstantiateType(context,state,type);return ReturnTypeAction(instantiatedType,options)}function WithDeferred(type,options){return Deferred("With",[type,options],{})}function With2(type,options){return WithAction(type,options)}function WithAction(type,options){return CanInstantiate([type])?memory_exports.Update(type,{},options):WithDeferred(type,options)}function WithInstantiate(context,state,type,options){let instaniatedType=InstantiateType(context,state,type);return WithAction(instaniatedType,options)}function SpreadElement(type){return IsRest(type)?IsTuple(type.items)?RestSpread(type.items.items):IsInfer(type.items)?[type]:IsRef(type.items)?[type]:[Never()]:[type]}function RestSpread(types){return types.reduce((result2,left)=>[...result2,...SpreadElement(left)],[])}function State(callstack,visited){return{callstack,visited}}function CanInstantiate(types){return guard_exports.ShiftLeft(types,(left,right)=>IsRef(left)?!1:CanInstantiate(right),()=>!0)}function InstantiateProperties(context,state,properties){return guard_exports.Keys(properties).reduce((result,key)=>({...result,[key]:InstantiateType(context,state,properties[key])}),{})}function InstantiateElements(context,state,types){let elements=InstantiateTypes(context,state,types);return RestSpread(elements)}function InstantiateTypes(context,state,types){return types.map(type=>InstantiateType(context,state,type))}function WithModifiers(type,instantiatedType){let withOptional=IsOptional(type)?AddOptionalAction(instantiatedType,{}):instantiatedType,withReadonly=IsReadonly(type)?AddReadonlyAction(withOptional,{}):withOptional;return IsImmutable(type)?AddImmutableAction(withReadonly,{}):withReadonly}function InstantiateDeferred(context,state,action,parameters,options){return guard_exports.IsEqual(action,"AddImmutable")?AddImmutableInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"RemoveImmutable")?RemoveImmutableInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"AddReadonly")?AddReadonlyInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"RemoveReadonly")?RemoveReadonlyInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"AddOptional")?AddOptionalInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"RemoveOptional")?RemoveOptionalInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Capitalize")?CapitalizeInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Conditional")?ConditionalInstantiate(context,state,parameters[0],parameters[1],parameters[2],parameters[3],options):guard_exports.IsEqual(action,"ConstructorParameters")?ConstructorParametersInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Evaluate")?EvaluateInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Exclude")?ExcludeInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"Extract")?ExtractInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"Index")?IndexInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"InstanceType")?InstanceTypeInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Interface")?InterfaceInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"KeyOf")?KeyOfInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Lowercase")?LowercaseInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Mapped")?MappedInstantiate(context,state,parameters[0],parameters[1],parameters[2],parameters[3],options):guard_exports.IsEqual(action,"Module")?ModuleInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"NonNullable")?NonNullableInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Pick")?PickInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"Parameters")?ParametersInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Partial")?PartialInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Omit")?OmitInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"ReadonlyObject")?ReadonlyObjectInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Record")?RecordInstantiate(context,state,parameters[0],parameters[1],options):guard_exports.IsEqual(action,"Required")?RequiredInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"ReturnType")?ReturnTypeInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"TemplateLiteral")?TemplateLiteralInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Uncapitalize")?UncapitalizeInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"Uppercase")?UppercaseInstantiate(context,state,parameters[0],options):guard_exports.IsEqual(action,"With")?WithInstantiate(context,state,parameters[0],parameters[1]):Deferred(action,parameters,options)}function InstantiateImmediate(context,state,type){let instantiatedType=IsRef(type)?RefInstantiate(context,state,type,type.$ref):IsArray3(type)?_Array_(InstantiateType(context,state,type.items),ArrayOptions(type)):IsCall(type)?CallInstantiate(context,state,type.target,type.arguments):IsConstructor3(type)?Constructor(InstantiateTypes(context,state,type.parameters),InstantiateType(context,state,type.instanceType),ConstructorOptions(type)):IsFunction3(type)?_Function_(InstantiateTypes(context,state,type.parameters),InstantiateType(context,state,type.returnType),FunctionOptions(type)):IsDependent(type)?Dependent(InstantiateType(context,state,type.if),InstantiateType(context,state,type.then),InstantiateType(context,state,type.else),DependentOptions(type)):IsIntersect(type)?Intersect(InstantiateTypes(context,state,type.allOf),IntersectOptions(type)):IsObject3(type)?_Object_(InstantiateProperties(context,state,type.properties),ObjectOptions(type)):IsRecord(type)?RecordFromPattern(RecordPattern(type),InstantiateType(context,state,RecordValue(type))):IsRest(type)?Rest(InstantiateType(context,state,type.items)):IsTuple(type)?Tuple(InstantiateElements(context,state,type.items),TupleOptions(type)):IsUnion(type)?Union(InstantiateTypes(context,state,type.anyOf),UnionOptions(type)):type;return WithModifiers(type,instantiatedType)}function InstantiateType(context,state,type){return IsDeferred(type)?InstantiateDeferred(context,state,type.action,type.parameters,type.options):InstantiateImmediate(context,state,type)}function Instantiate(context,type){return InstantiateType(context,State([],[]),type)}function AddImmutableOperation(type){return memory_exports.Update(type,{"~immutable":!0},{})}function AddImmutableAction(type,options){return memory_exports.Update(AddImmutableOperation(type),{},options)}function AddImmutableInstantiate(context,state,type,options){let instantiatedType=InstantiateType(context,state,type);return AddImmutableAction(instantiatedType,options)}function AddImmutableDeferred(type,options={}){return Deferred("AddImmutable",[type],options)}function AddImmutable(type,options={}){return AddImmutableAction(type,options)}function RemoveImmutableDeferred(type,options={}){return Deferred("RemoveImmutable",[type],options)}function RemoveImmutable(type,options={}){return RemoveImmutableAction(type,options)}function EvaluateDeferred(type,options={}){return Deferred("Evaluate",[type],options)}function Evaluate2(type,options={}){return EvaluateAction(type,options)}function ModuleDeferred(declarations,options={}){return Deferred("Module",[declarations],options)}function Module2(declarations,options={}){return ModuleInstantiate({},State([],[]),declarations,options)}function Comparer(left,right){let compareResult=Compare(left,right);return guard_exports.IsEqual(compareResult,CompareResultRightInside)||guard_exports.IsEqual(compareResult,CompareResultDisjoint)?1:0}function Insert(type,types,result=[]){return guard_exports.ShiftLeft(types,(left,right)=>guard_exports.IsEqual(Comparer(type,left),1)?Insert(type,right,[...result,left]):[...result,type,...types],()=>[...result,type])}function Sort(types,result=[]){return guard_exports.ShiftLeft(types,(left,right)=>Sort(right,Insert(left,result)),()=>result)}function Priority(types){return Sort(types)}function IsTemplateLiteralPattern(pattern){let types=ParsePatternIntoTypes(pattern);return!guard_exports.IsEqual(types.length,0)}function Script2(...args){let[context,input,options]=arguments_exports.Match(args,{2:(script,options2)=>guard_exports.IsString(script)?[{},script,options2]:[script,options2,{}],3:(context2,script,options2)=>[context2,script,options2],1:script=>[{},script,{}]}),result=Script(input),parsed=guard_exports.IsArray(result)&&guard_exports.IsEqual(result.length,2)?InstantiateType(context,State([],[]),result[0]):Never();return memory_exports.Update(parsed,{},options)}var typebox_exports={};__export(typebox_exports,{Any:()=>Any,Array:()=>_Array_,BigInt:()=>BigInt2,Boolean:()=>Boolean2,Call:()=>Call2,Capitalize:()=>Capitalize,Codec:()=>Codec,Conditional:()=>Conditional,Constructor:()=>Constructor,ConstructorParameters:()=>ConstructorParameters,Cyclic:()=>Cyclic,Decode:()=>Decode,DecodeBuilder:()=>DecodeBuilder,Dependent:()=>Dependent,Encode:()=>Encode,EncodeBuilder:()=>EncodeBuilder,Enum:()=>Enum,Evaluate:()=>Evaluate2,Exclude:()=>Exclude,Extends:()=>Extends,ExtendsResult:()=>result_exports,Extract:()=>Extract,Function:()=>_Function_,Generic:()=>Generic,Identifier:()=>Identifier,Immutable:()=>Immutable,Index:()=>Index,Infer:()=>Infer,InstanceType:()=>InstanceType,Instantiate:()=>Instantiate,Integer:()=>Integer,Interface:()=>Interface,Intersect:()=>Intersect,IsAny:()=>IsAny,IsArray:()=>IsArray3,IsBigInt:()=>IsBigInt3,IsBoolean:()=>IsBoolean4,IsCall:()=>IsCall,IsCodec:()=>IsCodec,IsConstructor:()=>IsConstructor3,IsCyclic:()=>IsCyclic,IsDependent:()=>IsDependent,IsEnum:()=>IsEnum,IsEnumValue:()=>IsEnumValue,IsFunction:()=>IsFunction3,IsGeneric:()=>IsGeneric,IsIdentifier:()=>IsIdentifier2,IsImmutable:()=>IsImmutable,IsInfer:()=>IsInfer,IsInteger:()=>IsInteger3,IsIntersect:()=>IsIntersect,IsKind:()=>IsKind,IsLiteral:()=>IsLiteral,IsNever:()=>IsNever,IsNull:()=>IsNull3,IsNumber:()=>IsNumber4,IsObject:()=>IsObject3,IsOptional:()=>IsOptional,IsParameter:()=>IsParameter,IsReadonly:()=>IsReadonly,IsRecord:()=>IsRecord,IsRef:()=>IsRef,IsRefine:()=>IsRefine,IsRest:()=>IsRest,IsSchema:()=>IsSchema,IsString:()=>IsString4,IsSymbol:()=>IsSymbol3,IsTemplateLiteral:()=>IsTemplateLiteral,IsThis:()=>IsThis,IsTuple:()=>IsTuple,IsUndefined:()=>IsUndefined3,IsUnion:()=>IsUnion,IsUnknown:()=>IsUnknown,IsUnsafe:()=>IsUnsafe,IsVoid:()=>IsVoid,KeyOf:()=>KeyOf2,Literal:()=>Literal,Lowercase:()=>Lowercase,Mapped:()=>Mapped,Module:()=>Module2,Never:()=>Never,NonNullable:()=>NonNullable,Null:()=>Null,Number:()=>Number2,Object:()=>_Object_,Omit:()=>Omit,Optional:()=>Optional,Parameter:()=>Parameter,Parameters:()=>Parameters,Partial:()=>Partial,Pick:()=>Pick,Readonly:()=>Readonly,ReadonlyObject:()=>ReadonlyObject,ReadonlyType:()=>ReadonlyType,Record:()=>Record,RecordKey:()=>RecordKey,RecordPattern:()=>RecordPattern,RecordValue:()=>RecordValue,Ref:()=>Ref,Refine:()=>Refine,Required:()=>Required,Rest:()=>Rest,ReturnType:()=>ReturnType,Script:()=>Script2,String:()=>String2,Symbol:()=>Symbol,TemplateLiteral:()=>TemplateLiteral2,This:()=>This,Tuple:()=>Tuple,Uncapitalize:()=>Uncapitalize,Undefined:()=>Undefined,Union:()=>Union,Unknown:()=>Unknown,Unsafe:()=>Unsafe,Uppercase:()=>Uppercase,Void:()=>Void,With:()=>With2});var build_default=typebox_exports;function buildProviderErrorPattern(patterns){return new RegExp(patterns.join("|"),"i")}var NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN=buildProviderErrorPattern(["GoUsageLimitError","FreeUsageLimitError","Monthly usage limit reached","available balance","insufficient_quota","out of budget","quota exceeded","billing","subscription_sharing_usage_limit_exceeded","subscription_sharing_workplace_individual_usage_limit_exceeded"]),RETRYABLE_PROVIDER_ERROR_PATTERN=buildProviderErrorPattern(["overloaded","server_busy","servers are currently busy","currently experiencing high demand","model is at capacity","rate.?limit","too many requests","\\b(?:429|500|502|503|504|520|524)\\b","service.?(?:is.?)?(?:temporarily.?)?unavailable","server.?error","internal.?error","provider.?returned.?(?:an.?)?error","exceeded request buffer limit while retrying upstream","unable to forward upstream","upstream.?request.?failed","upstream_stream_read_error","stream was interrupted","http/?2 stream failed","network.?error","connection.?error","connection.?refused","connection.?lost","other side closed","fetch failed","request to \\S+ failed, reason:","getaddrinfo","ENOTFOUND","EAI_AGAIN","upstream.?connect","reset before headers","socket hang up","socket connection was closed","timed? out","timeout","terminated","websocket.?closed","websocket.?error","ended without","stream ended before message_stop","stream ended before a terminal response event","http2 request did not get a response","stream disconnected before completion","pending stream has been canceled","retry delay","you can retry your request","try your request again","please retry your request","ResourceExhausted","subscription_sharing_usage_unavailable","subscription_sharing_user_unavailable"]),DEFAULT_MAX_AGENT_RETRY_DELAY_MS=6e4;function retryDelayMs(policy,attempt){let delay=policy.baseDelayMs*2**Math.max(0,attempt-1),safeDelay=Number.isSafeInteger(delay)?delay:Number.MAX_SAFE_INTEGER;return Math.min(safeDelay,policy.maxAgentDelayMs??DEFAULT_MAX_AGENT_RETRY_DELAY_MS)}var RetrySleepAbortError=class extends Error{constructor(){super("Aborted")}};function sleep(ms,signal){return new Promise((resolve,reject)=>{if(signal?.aborted){reject(new RetrySleepAbortError);return}let timeout=setTimeout(resolve,ms);signal?.addEventListener("abort",()=>{clearTimeout(timeout),reject(new RetrySleepAbortError)},{once:!0})})}async function retryAssistantCall(produce,policy,signal,callbacks){let maxAttempts=policy?.enabled?policy.maxRetries:0,attempt=0,lastRetry;for(;;){let response=await produce();if(response.stopReason==="aborted")return lastRetry&&await callbacks?.onRetryFinished?.(!1,lastRetry.attempt),response;if(response.stopReason!=="error")return lastRetry&&await callbacks?.onRetryFinished?.(!0,lastRetry.attempt),response;if(attempt>=maxAttempts||!isRetryableAssistantError(response))return lastRetry&&await callbacks?.onRetryFinished?.(!1,lastRetry.attempt,response.errorMessage),response;attempt++,lastRetry={attempt,errorMessage:response.errorMessage||"Unknown error"};let delayMs=retryDelayMs(policy,attempt);await callbacks?.onRetryScheduled?.(attempt,maxAttempts,delayMs,lastRetry.errorMessage);try{await sleep(delayMs,signal)}catch(error){if(await callbacks?.onRetryFinished?.(!1,attempt,lastRetry.errorMessage),error instanceof RetrySleepAbortError){let{errorMessage:_errorMessage,...rest}=response;return{...rest,stopReason:"aborted"}}throw error}await callbacks?.onRetryAttemptStart?.()}}function isRetryableAssistantError(message){if(message.stopReason!=="error"||!message.errorMessage)return!1;let errorMessage=message.errorMessage;return NON_RETRYABLE_PROVIDER_LIMIT_ERROR_PATTERN.test(errorMessage)?!1:RETRYABLE_PROVIDER_ERROR_PATTERN.test(errorMessage)}export{guard_exports,emit_exports,globals_exports,guard_default,settings_exports,Clone,IsSchema,_Array_,IsArray3 as IsArray,ArrayOptions,IsConstructor3 as IsConstructor,IsFunction3 as IsFunction,Ref,IsRef,IsNever,IsOptional,_Object_,IsObject3 as IsObject,Unknown,IsCyclic,arguments_exports,IsEnum,Intersect,IsIntersect,environment_exports,Unreachable,hash_exports,Get2 as Get,IsCodec,IsRefine,IsBigInt3 as IsBigInt,IsBoolean4 as IsBoolean,IsInteger3 as IsInteger,Literal,IsLiteralBigInt,IsLiteralBoolean,IsLiteralNumber,IsLiteralString,IsLiteral,IsNull3 as IsNull,IsNumber4 as IsNumber,IsSymbol3 as IsSymbol,String2 as String,IsString4 as IsString,Union,IsUnion,TemplateLiteralDecode,Tuple,IsTuple,Flatten,Record,RecordPattern,RecordKey,RecordValue,IsRecord,IsUndefined3 as IsUndefined,IsVoid,IsTemplateLiteral,With2 as With,Instantiate,Evaluate2 as Evaluate,Priority,typebox_exports,build_exports,DEFAULT_MAX_AGENT_RETRY_DELAY_MS,retryDelayMs,retryAssistantCall,isRetryableAssistantError};