2022-11-10 19:34:10 -06:00
let wasm ;
2022-11-15 10:31:45 -06:00
const cachedTextDecoder = new TextDecoder ( 'utf-8' , { ignoreBOM : true , fatal : true } ) ;
cachedTextDecoder . decode ( ) ;
let cachedUint8Memory0 = new Uint8Array ( ) ;
function getUint8Memory0 ( ) {
if ( cachedUint8Memory0 . byteLength === 0 ) {
cachedUint8Memory0 = new Uint8Array ( wasm . memory . buffer ) ;
}
return cachedUint8Memory0 ;
}
function getStringFromWasm0 ( ptr , len ) {
return cachedTextDecoder . decode ( getUint8Memory0 ( ) . subarray ( ptr , ptr + len ) ) ;
}
2022-11-10 19:34:10 -06:00
const heap = new Array ( 32 ) . fill ( undefined ) ;
heap . push ( undefined , null , true , false ) ;
let heap _next = heap . length ;
2022-11-15 10:31:45 -06:00
function addHeapObject ( obj ) {
if ( heap _next === heap . length ) heap . push ( heap . length + 1 ) ;
const idx = heap _next ;
heap _next = heap [ idx ] ;
heap [ idx ] = obj ;
return idx ;
}
function getObject ( idx ) { return heap [ idx ] ; }
2022-11-10 19:34:10 -06:00
function dropObject ( idx ) {
if ( idx < 36 ) return ;
heap [ idx ] = heap _next ;
heap _next = idx ;
}
function takeObject ( idx ) {
const ret = getObject ( idx ) ;
dropObject ( idx ) ;
return ret ;
}
let WASM _VECTOR _LEN = 0 ;
const cachedTextEncoder = new TextEncoder ( 'utf-8' ) ;
const encodeString = ( typeof cachedTextEncoder . encodeInto === 'function'
? function ( arg , view ) {
return cachedTextEncoder . encodeInto ( arg , view ) ;
}
: function ( arg , view ) {
const buf = cachedTextEncoder . encode ( arg ) ;
view . set ( buf ) ;
return {
read : arg . length ,
written : buf . length
} ;
} ) ;
function passStringToWasm0 ( arg , malloc , realloc ) {
if ( realloc === undefined ) {
const buf = cachedTextEncoder . encode ( arg ) ;
const ptr = malloc ( buf . length ) ;
getUint8Memory0 ( ) . subarray ( ptr , ptr + buf . length ) . set ( buf ) ;
WASM _VECTOR _LEN = buf . length ;
return ptr ;
}
let len = arg . length ;
let ptr = malloc ( len ) ;
const mem = getUint8Memory0 ( ) ;
let offset = 0 ;
for ( ; offset < len ; offset ++ ) {
const code = arg . charCodeAt ( offset ) ;
if ( code > 0x7F ) break ;
mem [ ptr + offset ] = code ;
}
if ( offset !== len ) {
if ( offset !== 0 ) {
arg = arg . slice ( offset ) ;
}
ptr = realloc ( ptr , len , len = offset + arg . length * 3 ) ;
const view = getUint8Memory0 ( ) . subarray ( ptr + offset , ptr + len ) ;
const ret = encodeString ( arg , view ) ;
offset += ret . written ;
}
WASM _VECTOR _LEN = offset ;
return ptr ;
}
/ * *
* @ param { string } name
* /
export function greet ( name ) {
const ptr0 = passStringToWasm0 ( name , wasm . _ _wbindgen _malloc , wasm . _ _wbindgen _realloc ) ;
const len0 = WASM _VECTOR _LEN ;
wasm . greet ( ptr0 , len0 ) ;
}
2022-11-15 10:31:45 -06:00
/ * *
* @ returns { Array < any > }
* /
export function send _phase ( ) {
const ret = wasm . send _phase ( ) ;
return takeObject ( ret ) ;
}
2022-11-10 19:34:10 -06:00
let cachedInt32Memory0 = new Int32Array ( ) ;
function getInt32Memory0 ( ) {
if ( cachedInt32Memory0 . byteLength === 0 ) {
cachedInt32Memory0 = new Int32Array ( wasm . memory . buffer ) ;
}
return cachedInt32Memory0 ;
}
async function load ( module , imports ) {
if ( typeof Response === 'function' && module instanceof Response ) {
if ( typeof WebAssembly . instantiateStreaming === 'function' ) {
try {
return await WebAssembly . instantiateStreaming ( module , imports ) ;
} catch ( e ) {
if ( module . headers . get ( 'Content-Type' ) != 'application/wasm' ) {
console . warn ( "`WebAssembly.instantiateStreaming` failed because your server does not serve wasm with `application/wasm` MIME type. Falling back to `WebAssembly.instantiate` which is slower. Original error:\n" , e ) ;
} else {
throw e ;
}
}
}
const bytes = await module . arrayBuffer ( ) ;
return await WebAssembly . instantiate ( bytes , imports ) ;
} else {
const instance = await WebAssembly . instantiate ( module , imports ) ;
if ( instance instanceof WebAssembly . Instance ) {
return { instance , module } ;
} else {
return instance ;
}
}
}
function getImports ( ) {
const imports = { } ;
imports . wbg = { } ;
imports . wbg . _ _wbg _alert _b29ee0fb3216154d = function ( arg0 , arg1 ) {
alert ( getStringFromWasm0 ( arg0 , arg1 ) ) ;
} ;
2022-11-15 10:31:45 -06:00
imports . wbg . _ _wbindgen _string _new = function ( arg0 , arg1 ) {
const ret = getStringFromWasm0 ( arg0 , arg1 ) ;
return addHeapObject ( ret ) ;
} ;
2022-11-10 19:34:10 -06:00
imports . wbg . _ _wbg _new _abda76e883ba8a5f = function ( ) {
const ret = new Error ( ) ;
return addHeapObject ( ret ) ;
} ;
imports . wbg . _ _wbg _stack _658279fe44541cf6 = function ( arg0 , arg1 ) {
const ret = getObject ( arg1 ) . stack ;
const ptr0 = passStringToWasm0 ( ret , wasm . _ _wbindgen _malloc , wasm . _ _wbindgen _realloc ) ;
const len0 = WASM _VECTOR _LEN ;
getInt32Memory0 ( ) [ arg0 / 4 + 1 ] = len0 ;
getInt32Memory0 ( ) [ arg0 / 4 + 0 ] = ptr0 ;
} ;
imports . wbg . _ _wbg _error _f851667af71bcfc6 = function ( arg0 , arg1 ) {
try {
console . error ( getStringFromWasm0 ( arg0 , arg1 ) ) ;
} finally {
wasm . _ _wbindgen _free ( arg0 , arg1 ) ;
}
} ;
imports . wbg . _ _wbindgen _object _drop _ref = function ( arg0 ) {
takeObject ( arg0 ) ;
} ;
2022-11-15 10:31:45 -06:00
imports . wbg . _ _wbg _newwithlength _7c42f7e738a9d5d3 = function ( arg0 ) {
const ret = new Array ( arg0 >>> 0 ) ;
return addHeapObject ( ret ) ;
} ;
imports . wbg . _ _wbg _set _a68214f35c417fa9 = function ( arg0 , arg1 , arg2 ) {
getObject ( arg0 ) [ arg1 >>> 0 ] = takeObject ( arg2 ) ;
} ;
2022-11-10 19:34:10 -06:00
imports . wbg . _ _wbg _now _58886682b7e790d7 = function ( ) {
const ret = Date . now ( ) ;
return ret ;
} ;
imports . wbg . _ _wbindgen _throw = function ( arg0 , arg1 ) {
throw new Error ( getStringFromWasm0 ( arg0 , arg1 ) ) ;
} ;
return imports ;
}
function initMemory ( imports , maybe _memory ) {
}
function finalizeInit ( instance , module ) {
wasm = instance . exports ;
init . _ _wbindgen _wasm _module = module ;
cachedInt32Memory0 = new Int32Array ( ) ;
cachedUint8Memory0 = new Uint8Array ( ) ;
return wasm ;
}
function initSync ( module ) {
const imports = getImports ( ) ;
initMemory ( imports ) ;
if ( ! ( module instanceof WebAssembly . Module ) ) {
module = new WebAssembly . Module ( module ) ;
}
const instance = new WebAssembly . Instance ( module , imports ) ;
return finalizeInit ( instance , module ) ;
}
async function init ( input ) {
if ( typeof input === 'undefined' ) {
input = new URL ( 'moon_phase_wasm_bg.wasm' , import . meta . url ) ;
}
const imports = getImports ( ) ;
if ( typeof input === 'string' || ( typeof Request === 'function' && input instanceof Request ) || ( typeof URL === 'function' && input instanceof URL ) ) {
input = fetch ( input ) ;
}
initMemory ( imports ) ;
const { instance , module } = await load ( await input , imports ) ;
return finalizeInit ( instance , module ) ;
}
export { initSync }
export default init ;