(function(e,t){'object'==typeof exports&&'object'==typeof module?module.exports=t(function(){try{return require('assemblyscript')}catch(t){}}(),require('./assemblyscript')):'function'==typeof define&&define.amd?define(['assemblyscript'],t):'object'==typeof exports?exports.asc=t(function(){try{return require('assemblyscript')}catch(t){}}(),require('./assemblyscript')):e.asc=t(e._,e[void 0])})('undefined'==typeof self?this:self,function(t,e){var r=Math.floor,n=Math.pow,s=Math.min;return function(e){function t(r){if(i[r])return i[r].exports;var n=i[r]={i:r,l:!1,exports:{}};return e[r].call(n.exports,n,n.exports,t),n.l=!0,n.exports}var i={};return t.m=e,t.c=i,t.d=function(e,i,r){t.o(e,i)||Object.defineProperty(e,i,{configurable:!1,enumerable:!0,get:r})},t.n=function(e){var i=e&&e.__esModule?function(){return e['default']}:function(){return e};return t.d(i,'a',i),i},t.o=function(e,t){return Object.prototype.hasOwnProperty.call(e,t)},t.p='',t(t.s=3)}([function(e,t,i){t.nextTick=function(e){setTimeout(e,0)},t.platform=t.arch=t.execPath=t.title='browser',t.pid=1,t.browser=!0,t.env={},t.argv=[],t.binding=function(){throw new Error('No such module. (Possibly not yet loaded)')},function(){var e,r='/';t.cwd=function(){return r},t.chdir=function(t){e||(e=i(1)),r=e.resolve(t,r)}}(),t.exit=t.kill=t.umask=t.dlopen=t.uptime=t.memoryUsage=t.uvCounters=function(){},t.features={}},function(e,t,i){(function(e){function r(e,t){for(var r,n=0,s=e.length-1;0<=s;s--)r=e[s],'.'===r?e.splice(s,1):'..'===r?(e.splice(s,1),n++):n&&(e.splice(s,1),n--);if(t)for(;n--;n)e.unshift('..');return e}function n(e,t){if(e.filter)return e.filter(t);for(var r=[],n=0;ni?[]:e.slice(t,i-t+1)}e=t.resolve(e).substr(1),r=t.resolve(r).substr(1);for(var o=n(e.split('/')),a=n(r.split('/')),l=s(o.length,a.length),u=l,c=0;c{const i=t.options[e];i.aliases&&((r.alias||(r.alias={}))[e]=i.aliases),void 0!==i.default&&((r.default||(r.default={}))[e]=i.default),'string'===i.type?(r.string||(r.string=[])).push(e):'boolean'===i.type&&(r.boolean||(r.boolean=[])).push(e)}),i(14)(e,r)}function s(e,t){for(var i,r=!1;null!=(i=f.nextDiagnostic(e));)t.write(f.formatDiagnostic(i,t.isTTY,!0)+d.EOL+d.EOL),f.isError(i)&&(r=!0);return r}function o(){return{readTime:0,readCount:0,writeTime:0,writeCount:0,parseTime:0,parseCount:0,compileTime:0,compileCount:0,emitTime:0,emitCount:0,validateTime:0,validateCount:0,optimizeTime:0,optimizeCount:0}}function a(t){const i=e.hrtime();t();const r=e.hrtime(i);return 1e9*r[0]+r[1]}function l(t,i){function r(e){return e?(e/1e6).toFixed(3)+' ms':'N/A'}(i||e.stdout).write(['I/O Read : '+r(t.readTime,t.readCount),'I/O Write : '+r(t.writeTime,t.writeCount),'Parse : '+r(t.parseTime,t.parseCount),'Compile : '+r(t.compileTime,t.compileCount),'Emit : '+r(t.emitTime,t.emitCount),'Validate : '+r(t.validateTime,t.validateCount),'Optimize : '+r(t.optimizeTime,t.optimizeCount)].join(d.EOL)+d.EOL)}const u=i(9),c=i(1),d=i(10);var f,p;try{f=i(11),p=!1;try{i(!function(){var t=new Error('Cannot find module "source-map-support"');throw t.code='MODULE_NOT_FOUND',t}()).install()}catch(t){}}catch(t){try{i(!function(){var t=new Error('Cannot find module "ts-node"');throw t.code='MODULE_NOT_FOUND',t}()).register({project:c.join('.','..','src')}),i(!function(){var t=new Error('Cannot find module "../src/glue/js"');throw t.code='MODULE_NOT_FOUND',t}()),f=i(!function(){var t=new Error('Cannot find module "../src"');throw t.code='MODULE_NOT_FOUND',t}()),p=!0}catch(t){f=i(12),p=!1}}t.isBundle=!0,t.isDev=p,t.version=t.isBundle?'0.5.0':i(!function(){var t=new Error('Cannot find module "../package.json"');throw t.code='MODULE_NOT_FOUND',t}()).version,t.options=i(13),t.sourceMapRoot='assemblyscript:///',t.libraryPrefix=f.LIBRARY_PREFIX,t.defaultOptimizeLevel=2,t.defaultShrinkLevel=1,t.libraryFiles=t.isBundle?{"(lib)/allocator/arena":'/////////////// A simple yet effective Arena Memory Allocator /////////////////\n\n// Provides a `reset_memory` function to reset the heap to its initial state. A\n// user has to make sure that there are no more references to cleared memory\n// afterwards. Always aligns to 8 bytes.\n\nconst ALIGN_LOG2: usize = 3;\nconst ALIGN_SIZE: usize = 1 << ALIGN_LOG2;\nconst ALIGN_MASK: usize = ALIGN_SIZE - 1;\n\nvar HEAP_OFFSET: usize = HEAP_BASE;\n\nexport function allocate_memory(size: usize): usize {\n if (!size) return 0;\n var ptr = HEAP_OFFSET;\n var off = (ptr + size + ALIGN_MASK) & ~ALIGN_MASK;\n var avail = current_memory() << 16;\n if (off > avail && grow_memory(\n max(\n (((off + 0xffff) & ~0xffff) - avail) >> 16, // minimum required pages\n avail >> 16 // at least double memory\n )\n ) < 0) unreachable(); // out of memory\n HEAP_OFFSET = off;\n return ptr;\n}\n\nexport function free_memory(ptr: usize): void {\n // nop\n}\n\nexport function reset_memory(): void {\n HEAP_OFFSET = HEAP_BASE;\n}\n',"(lib)/allocator/emscripten":'///////////////////////// Emscripten Memory Allocator //////////////////////////\n\n// Uses Emscripten\'s exported _malloc and _free implementations, i.e., when\n// linking with Emscripten-compiled programs that already provide these.\n// Differs from \'system\' in that their names are prefixed with an underscore.\n\ndeclare function _malloc(size: usize): usize;\ndeclare function _free(ptr: usize): void;\n\nexport function allocate_memory(size: usize): usize {\n return _malloc(size);\n}\n\nexport function free_memory(ptr: usize): void {\n _free(ptr);\n}\n\nexport function reset_memory(): void {\n throw new Error("not supported");\n}\n',"(lib)/allocator/system":'/////////////////////////// System Memory Allocator ////////////////////////////\n\n// Uses the environment\'s malloc and free implementations, i.e., when linking\n// with other C-like programs that already provide these.\n\ndeclare function malloc(size: usize): usize;\ndeclare function free(ptr: usize): void;\n\nexport function allocate_memory(size: usize): usize {\n return malloc(size);\n}\n\nexport function free_memory(ptr: usize): void {\n free(ptr);\n}\n\nexport function reset_memory(): void {\n throw new Error("not supported");\n}\n',"(lib)/allocator/tlsf":'////////////// TLSF (Two-Level Segregate Fit) Memory Allocator ////////////////\n\n// Re-export for now, so there\'s just one source file being worked on\n\nexport {\n allocate_memory,\n free_memory\n} from "../../../examples/tlsf/assembly/tlsf";\n\nexport function reset_memory(): void {\n throw new Error("not supported");\n}\n',"(lib)/array":'export class Array {\n\n private __memory: usize;\n private __capacity: i32; // capped to [0, 0x7fffffff]\n private __length: i32; // capped to [0, __capacity]\n\n private __grow(newCapacity: i32): void {\n assert(newCapacity > this.__capacity);\n var newMemory = allocate_memory(newCapacity * sizeof());\n if (this.__memory) {\n move_memory(newMemory, this.__memory, this.__capacity * sizeof());\n free_memory(this.__memory);\n }\n this.__memory = newMemory;\n this.__capacity = newCapacity;\n }\n\n constructor(capacity: i32 = 0) {\n if (capacity < 0)\n throw new RangeError("Invalid array length");\n this.__memory = capacity ? allocate_memory(capacity * sizeof()) : 0;\n this.__capacity = this.__length = capacity;\n }\n\n get length(): i32 {\n return this.__length;\n }\n\n set length(length: i32) {\n if (length < 0)\n throw new RangeError("Invalid array length");\n if (length > this.__capacity)\n this.__grow(max(length, this.__capacity << 1));\n this.__length = length;\n }\n\n @operator("[]")\n private __get(index: i32): T {\n if (index >= this.__capacity)\n throw new Error("Index out of bounds"); // return changetype(0) ?\n return load(this.__memory + index * sizeof());\n }\n\n @operator("[]=")\n private __set(index: i32, value: T): void {\n if (index < 0)\n throw new Error("Index out of bounds");\n if (index >= this.__capacity)\n this.__grow(max(index + 1, this.__capacity << 1));\n store(this.__memory + index * sizeof(), value);\n }\n\n indexOf(searchElement: T, fromIndex: i32 = 0): i32 {\n if (fromIndex < 0)\n fromIndex = this.__length + fromIndex;\n while (fromIndex < this.__length) {\n if (load(this.__memory + fromIndex * sizeof()) == searchElement)\n return fromIndex;\n ++fromIndex;\n }\n return -1;\n }\n\n lastIndexOf(searchElement: T, fromIndex: i32 = 0): i32 {\n if (fromIndex < 0)\n fromIndex = this.__length + fromIndex;\n else if (fromIndex >= this.__length)\n fromIndex = this.__length - 1;\n while (fromIndex >= 0) {\n if (load(this.__memory + fromIndex * sizeof()) == searchElement)\n return fromIndex;\n --fromIndex;\n }\n return -1;\n }\n\n push(element: T): i32 {\n if (this.__length == this.__capacity)\n this.__grow(this.__capacity ? this.__capacity << 1 : 1);\n store(this.__memory + this.__length * sizeof(), element);\n return ++this.__length;\n }\n\n pop(): T {\n if (this.__length < 1)\n throw new RangeError("Array is empty"); // return changetype(0) ?\n return load(this.__memory + --this.__length * sizeof());\n }\n\n shift(): T {\n if (this.__length < 1)\n throw new RangeError("Array is empty"); // return changetype(0) ?\n var element = load(this.__memory);\n move_memory(this.__memory, this.__memory + sizeof(), (this.__capacity - 1) * sizeof());\n set_memory(this.__memory + (this.__capacity - 1) * sizeof(), 0, sizeof());\n --this.__length;\n return element;\n }\n\n unshift(element: T): i32 {\n var oldCapacity = this.__capacity;\n if (this.__length == oldCapacity) {\n // inlined __grow (avoids moving twice)\n var newCapacity: i32 = oldCapacity ? oldCapacity << 1 : 1;\n assert(newCapacity > this.__capacity);\n var newMemory = allocate_memory(newCapacity * sizeof());\n if (this.__memory) {\n move_memory(newMemory + sizeof(), this.__memory, oldCapacity * sizeof());\n free_memory(this.__memory);\n }\n this.__memory = newMemory;\n this.__capacity = newCapacity;\n } else\n move_memory(this.__memory + sizeof(), this.__memory, oldCapacity * sizeof());\n store(this.__memory, element);\n return ++this.__length;\n }\n\n slice(begin: i32 = 0, end: i32 = i32.MAX_VALUE): Array {\n if (begin < 0) {\n begin = this.__length + begin;\n if (begin < 0)\n begin = 0;\n } else if (begin > this.__length)\n begin = this.__length;\n if (end < 0)\n end = this.__length + end;\n else if (end > this.__length)\n end = this.__length;\n if (end < begin)\n end = begin;\n var capacity = end - begin;\n assert(capacity >= 0);\n var sliced = new Array(capacity);\n if (capacity)\n move_memory(sliced.__memory, this.__memory + begin * sizeof(), capacity * sizeof());\n return sliced;\n }\n\n splice(start: i32, deleteCount: i32 = i32.MAX_VALUE): void {\n if (deleteCount < 1)\n return;\n if (start < 0) {\n start = this.__length + start;\n if (start < 0)\n start = 0;\n else if (start >= this.__length)\n return;\n } else if (start >= this.__length)\n return;\n deleteCount = min(deleteCount, this.__length - start);\n move_memory(this.__memory + start * sizeof(), this.__memory + (start + deleteCount) * sizeof(), deleteCount * sizeof());\n this.__length -= deleteCount;\n }\n\n reverse(): Array {\n for (var front: usize = 0, back: usize = this.__length - 1; front < back; ++front, --back) {\n var temp = load(this.__memory + front * sizeof());\n store(this.__memory + front * sizeof(), load(this.__memory + back * sizeof()));\n store(this.__memory + back * sizeof(), temp);\n }\n return this;\n }\n}\n\n@unmanaged\nexport class CArray {\n\n private constructor() {}\n\n @operator("[]")\n private __get(index: i32): T {\n if (index < 0)\n throw new RangeError("Index out of range");\n return load(changetype(this) + index * sizeof());\n }\n\n @operator("[]=")\n private __set(index: i32, value: T): void {\n if (index < 0)\n throw new RangeError("Index out of range");\n store(changetype(this) + index * sizeof(), value);\n }\n}\n',"(lib)/builtins":'@builtin\nexport declare const NaN: f64; // | f32\n\n@builtin\nexport declare const Infinity: f64; // | f32\n\n@builtin\nexport declare function isNaN(value: T): bool;\n\n@builtin\nexport declare function isFinite(value: T): bool;\n\n@builtin\nexport declare function clz(value: T): T;\n\n@builtin\nexport declare function ctz(value: T): T;\n\n@builtin\nexport declare function popcnt(value: T): T;\n\n@builtin\nexport declare function rotl(value: T, shift: T): T;\n\n@builtin\nexport declare function rotr(value: T, shift: T): T;\n\n@builtin\nexport declare function abs(value: T): T;\n\n@builtin\nexport declare function max(left: T, right: T): T;\n\n@builtin\nexport declare function min(left: T, right: T): T;\n\n@builtin\nexport declare function ceil(value: T): T;\n\n@builtin\nexport declare function floor(value: T): T;\n\n@builtin\nexport declare function copysign(left: T, right: T): T;\n\n@builtin\nexport declare function nearest(left: T, right: T): T;\n\n@builtin\nexport declare function reinterpret(value: void): T;\n\n@builtin\nexport declare function sqrt(value: T): T;\n\n@builtin\nexport declare function trunc(value: T): T;\n\n@builtin\nexport declare function load(offset: usize, constantOffset?: usize): T;\n\n@builtin\nexport declare function store(offset: usize, value: void, constantOffset?: usize): T;\n\n@builtin\nexport declare function sizeof(): usize;\n\n@builtin\nexport declare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n\n@builtin\nexport declare function unreachable(): void;\n\n@builtin\nexport declare function current_memory(): i32;\n\n@builtin\nexport declare function grow_memory(pages: i32): i32;\n\n// @builtin\n// export declare function move_memory(dest: usize, src: usize: n: usize): void;\n\n// @builtin\n// export declare function set_memory(dest: usize, value: u32, n: usize): void;\n\n@builtin\nexport declare function changetype(value: void): T;\n\n@builtin\nexport declare function assert(isTrueish: T, message?: string): T;\n\n@builtin\nexport declare function abort(message?: string | null, fileName?: string | null, lineNumber?: u32, columnNumber?: u32): void;\n\n@builtin\ndeclare function i8(value: void): i8;\nnamespace i8 {\n export const MIN_VALUE: i8 = -128;\n export const MAX_VALUE: i8 = 127;\n}\nexport { i8 };\n\n@builtin\ndeclare function i16(value: void): i16;\nnamespace i16 {\n export const MIN_VALUE: i16 = -32768;\n export const MAX_VALUE: i16 = 32767;\n}\nexport { i16 };\n\n@builtin\ndeclare function i32(value: void): i32;\nnamespace i32 {\n export const MIN_VALUE: i32 = -2147483648;\n export const MAX_VALUE: i32 = 2147483647;\n}\nexport { i32 };\n\n@builtin\ndeclare function i64(value: void): i64;\nnamespace i64 {\n export const MIN_VALUE: i64 = -9223372036854775808;\n export const MAX_VALUE: i64 = 9223372036854775807;\n}\nexport { i64 };\n\n@builtin\ndeclare function isize(value: void): isize;\nnamespace isize {\n export const MIN_VALUE: isize = sizeof() == sizeof() ? -2147483648 : -9223372036854775808;\n export const MAX_VALUE: isize = sizeof() == sizeof() ? 2147483647 : 9223372036854775807;\n}\nexport { isize };\n\n@builtin\ndeclare function u8(value: void): u8;\nnamespace u8 {\n export const MIN_VALUE: u8 = 0;\n export const MAX_VALUE: u8 = 255;\n}\nexport { u8 };\n\n@builtin\ndeclare function u16(value: void): u16;\nnamespace u16 {\n export const MIN_VALUE: u16 = 0;\n export const MAX_VALUE: u16 = 65535;\n}\nexport { u16 };\n\n@builtin\ndeclare function u32(value: void): u32;\nnamespace u32 {\n export const MIN_VALUE: u32 = 0;\n export const MAX_VALUE: u32 = 4294967295;\n}\nexport { u32 };\n\n@builtin\ndeclare function u64(value: void): u64;\nnamespace u64 {\n export const MIN_VALUE: u64 = 0;\n export const MAX_VALUE: u64 = 18446744073709551615;\n}\nexport { u64 };\n\n@builtin\ndeclare function usize(value: void): usize;\nnamespace usize {\n export const MIN_VALUE: usize = 0;\n export const MAX_VALUE: usize = sizeof() == sizeof() ? 4294967295 : 18446744073709551615;\n}\nexport { usize };\n\n@builtin\ndeclare function bool(value: void): bool;\nnamespace bool {\n export const MIN_VALUE: bool = 0;\n export const MAX_VALUE: bool = 1;\n}\nexport { bool };\n\n@builtin\ndeclare function f32(value: void): f32;\nnamespace f32 {\n export const MIN_VALUE: f32 = -3.40282347e+38;\n export const MAX_VALUE: f32 = 3.40282347e+38;\n export const MIN_SAFE_INTEGER: f32 = -16777215;\n export const MAX_SAFE_INTEGER: f32 = 16777215;\n export const EPSILON: f32 = 1.19209290e-07;\n}\nexport { f32 };\n\n@builtin\ndeclare function f64(value: void): f64;\nnamespace f64 {\n export const MIN_VALUE: f64 = -1.7976931348623157e+308;\n export const MAX_VALUE: f64 = 1.7976931348623157e+308;\n export const MIN_SAFE_INTEGER: f64 = -9007199254740991;\n export const MAX_SAFE_INTEGER: f64 = 9007199254740991;\n export const EPSILON: f64 = 2.2204460492503131e-16;\n}\nexport{ f64 };\n\n@builtin\nexport declare const HEAP_BASE: usize;\n\n@builtin\nexport declare function start(): void;\n',"(lib)/error":'export class Error {\n\n name: string = "Error";\n message: string;\n stack: string = ""; // TODO\n\n constructor(message: string = "") {\n this.message = message;\n }\n}\n\nexport class RangeError extends Error {\n name: string = "RangeError";\n}\n',"(lib)/iterator":'// export abstract class Iterator {\n// abstract get done(): bool;\n// abstract next(): T;\n// }\n',"(lib)/map":'export class Map {\n\n private __keys: K[] = [];\n private __values: V[] = [];\n\n // FIXME: not a proper map implementation, just a filler\n\n get size(): i32 {\n return this.__keys.length;\n }\n\n get(key: K): V | null {\n var keys = this.__keys;\n for (var i = 0, k = keys.length; i < k; ++i)\n if (keys[i] == key)\n return this.__values[i];\n return null;\n }\n\n has(key: K): bool {\n var keys = this.__keys;\n for (var i = 0, k = keys.length; i < k; ++i)\n if (keys[i] == key)\n return true;\n return false;\n }\n\n set(key: K, value: V): void {\n this.__keys.push(key);\n this.__values.push(value);\n }\n\n clear(): void {\n this.__keys.length = 0;\n this.__values.length = 0;\n }\n}\n',"(lib)/memory":'function copy_memory(dest: usize, src: usize, n: usize): void {\n // based on musl\'s implementation of memcpy\n // not a future instruction and sufficiently covered by the upcoming move_memory intrinsic\n\n var w: u32, x: u32;\n\n // copy 1 byte each until src is aligned to 4 bytes\n while (n && (src & 3)) {\n store(dest++, load(src++));\n n--;\n }\n\n // if dst is aligned to 4 bytes as well, copy 4 bytes each\n if ((dest & 3) == 0) {\n while (n >= 16) {\n store(dest , load(src ));\n store(dest + 4, load(src + 4));\n store(dest + 8, load(src + 8));\n store(dest + 12, load(src + 12));\n src += 16; dest += 16; n -= 16;\n }\n if (n & 8) {\n store(dest , load(src ));\n store(dest + 4, load(src + 4));\n dest += 8; src += 8;\n }\n if (n & 4) {\n store(dest, load(src));\n dest += 4; src += 4;\n }\n if (n & 2) { // drop to 2 bytes each\n store(dest, load(src));\n dest += 2; src += 2;\n }\n if (n & 1) { // drop to 1 byte\n store(dest++, load(src++));\n }\n return;\n }\n\n // if dst is not aligned to 4 bytes, use alternating shifts to copy 4 bytes each\n // doing shifts if faster when copying enough bytes (here: 32 or more)\n if (n >= 32) {\n switch (dest & 3) {\n // known to be != 0\n case 1:\n w = load(src);\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n n -= 3;\n while (n >= 17) {\n x = load(src + 1);\n store(dest, w >> 24 | x << 8);\n w = load(src + 5);\n store(dest + 4, x >> 24 | w << 8);\n x = load(src + 9);\n store(dest + 8, w >> 24 | x << 8);\n w = load(src + 13);\n store(dest + 12, x >> 24 | w << 8);\n src += 16; dest += 16; n -= 16;\n }\n break;\n case 2:\n w = load(src);\n store(dest++, load(src++));\n store(dest++, load(src++));\n n -= 2;\n while (n >= 18) {\n x = load(src + 2);\n store(dest, w >> 16 | x << 16);\n w = load(src + 6);\n store(dest + 4, x >> 16 | w << 16);\n x = load(src + 10);\n store(dest + 8, w >> 16 | x << 16);\n w = load(src + 14);\n store(dest + 12, x >> 16 | w << 16);\n src += 16; dest += 16; n -= 16;\n }\n break;\n case 3:\n w = load(src);\n store(dest++, load(src++));\n n -= 1;\n while (n >= 19) {\n x = load(src + 3);\n store(dest, w >> 8 | x << 24);\n w = load(src + 7);\n store(dest + 4, x >> 8 | w << 24);\n x = load(src + 11);\n store(dest + 8, w >> 8 | x << 24);\n w = load(src + 15);\n store(dest + 12, x >> 8 | w << 24);\n src += 16; dest += 16; n -= 16;\n }\n break;\n }\n }\n\n // copy remaining bytes one by one\n if (n & 16) {\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n }\n if (n & 8) {\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n }\n if (n & 4) {\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n store(dest++, load(src++));\n }\n if (n & 2) {\n store(dest++, load(src++));\n store(dest++, load(src++));\n }\n if (n & 1) {\n store(dest++, load(src++));\n }\n}\n\nexport function move_memory(dest: usize, src: usize, n: usize): void {\n // based on musl\'s implementation of memmove\n // becomes obsolete once https://github.com/WebAssembly/bulk-memory-operations lands\n\n if (dest == src)\n return;\n if (src + n <= dest || dest + n <= src) {\n copy_memory(dest, src, n);\n return;\n }\n if (dest < src) {\n if ((src & 7) == (dest & 7)) {\n while (dest & 7) {\n if (!n)\n return;\n --n;\n store(dest++, load(src++));\n }\n while (n >= 8) {\n store(dest, load(src));\n n -= 8;\n dest += 8;\n src += 8;\n }\n }\n while (n) {\n store(dest++, load(src++));\n --n;\n }\n } else {\n if ((src & 7) == (dest & 7)) {\n while ((dest + n) & 7) {\n if (!n)\n return;\n store(dest + --n, load(src + n));\n }\n while (n >= 8) {\n n -= 8;\n store(dest + n, load(src + n));\n }\n }\n while (n) {\n store(dest + --n, load(src + n));\n }\n }\n}\n\nexport function set_memory(dest: usize, c: u8, n: usize): void {\n // based on musl\'s implementation of memset\n // becomes obsolete once https://github.com/WebAssembly/bulk-memory-operations lands\n\n // fill head and tail with minimal branching\n if (!n)\n return;\n store(dest, c);\n store(dest + n - 1, c);\n if (n <= 2)\n return;\n\n store(dest + 1, c);\n store(dest + 2, c);\n store(dest + n - 2, c);\n store(dest + n - 3, c);\n if (n <= 6)\n return;\n store(dest + 3, c);\n store(dest + n - 4, c);\n if (n <= 8)\n return;\n\n // advance pointer to align it at 4-byte boundary\n var k: usize = -dest & 3;\n dest += k;\n n -= k;\n n &= -4;\n\n var c32: u32 = (-1 / 255) * c;\n\n // fill head/tail up to 28 bytes each in preparation\n store(dest, c32);\n store(dest + n - 4, c32);\n if (n <= 8)\n return;\n store(dest + 4, c32);\n store(dest + 8, c32);\n store(dest + n - 12, c32);\n store(dest + n - 8, c32);\n if (n <= 24)\n return;\n store(dest + 12, c32);\n store(dest + 16, c32);\n store(dest + 20, c32);\n store(dest + 24, c32);\n store(dest + n - 28, c32);\n store(dest + n - 24, c32);\n store(dest + n - 20, c32);\n store(dest + n - 16, c32);\n\n // align to a multiple of 8\n k = 24 + (dest & 4);\n dest += k;\n n -= k;\n\n // copy 32 bytes each\n var c64: u64 = c32 | (c32 << 32);\n while (n >= 32) {\n store(dest, c64);\n store(dest + 8, c64);\n store(dest + 16, c64);\n store(dest + 24, c64);\n n -= 32;\n dest += 32;\n }\n}\n\nexport function compare_memory(vl: usize, vr: usize, n: usize): i32 {\n // based on musl\'s implementation of memcmp\n // provided because there\'s no proposed alternative\n if (vl == vr)\n return 0;\n while (n && load(vl) == load(vr)) {\n n--;\n vl++;\n vr++;\n }\n return n ? load(vl) - load(vr) : 0;\n}\n',"(lib)/regexp":'export class RegExp {\n\n // @binding(CALL_NEW, [ STRING, STRING], OBJECT_HANDLE)\n constructor(pattern: string, flags: string = "") { throw new Error("unreachable"); }\n\n // @binding(CALL_THIS, [ STRING ], PASS_THRU)\n test(search: string): bool { throw new Error("unreachable"); }\n\n // @binding(CALL_THIS, [], STRING)\n toString(): string { throw new Error("unreachable"); }\n\n}\n',"(lib)/set":'// const prime1: u32 = 73;\n// const prime2: u32 = 5009;\n\nexport class Set {\n\n private __memory: usize;\n private __capacity: u32;\n private __size: u32;\n\n constructor() {\n this.__memory = 0;\n this.__capacity = this.__size = 0;\n }\n\n get size(): i32 {\n return this.__size;\n }\n\n // FIXME: not a proper set implementation, just a filler\n\n has(value: T): bool {\n assert(this != null);\n\n for (var index: usize = 0, limit: usize = this.__size; index < limit; ++index)\n if (load(this.__memory + index * sizeof()) == value)\n return true;\n return false;\n }\n\n add(value: T): Set {\n assert(this != null);\n\n if (this.__size >= this.__capacity) {\n var newCapacity = max(this.__capacity << 1, 8);\n var newMemory = allocate_memory(newCapacity * sizeof());\n if (this.__memory) {\n move_memory(newMemory, this.__memory, this.__capacity * sizeof());\n free_memory(this.__memory);\n }\n this.__capacity = newCapacity;\n this.__memory = newMemory;\n }\n store(this.__memory + this.__size * sizeof(), value);\n ++this.__size;\n return this;\n }\n\n delete(value: T): bool {\n assert(this != null);\n\n for (var index: usize = 0, limit: usize = this.__size; index < limit; ++index)\n if (load(this.__memory + index * sizeof()) == value) {\n if (index + 1 < this.__size)\n move_memory(this.__memory + index * sizeof(), this.__memory + (index + 1) * sizeof(), this.__size - index - 1);\n --this.__size;\n return true;\n }\n return false;\n }\n\n clear(): void {\n assert(this != null);\n\n this.__size = 0;\n }\n\n // TODO: think about iterators\n}\n\n// class SetIterator extends Iterator {\n\n// get done(): bool {\n// throw new Error("not implemented");\n// }\n\n// next(): T {\n// throw new Error("not implemented");\n// }\n// }\n',"(lib)/string":'// singleton empty string\nconst EMPTY: String = changetype("");\n\n// number of bytes preceeding string data\nconst HEAD: usize = 4;\n\nfunction allocate(length: i32): String {\n assert(length > 0); // 0 -> EMPTY\n var ptr = allocate_memory(HEAD + (length << 1));\n store(ptr, length);\n return changetype(ptr);\n}\n\nexport class String {\n\n readonly length: i32;\n\n @operator("[]")\n charAt(pos: i32): String {\n assert(this != null);\n\n if (pos >= this.length)\n return EMPTY;\n\n var out = allocate(1);\n store(\n changetype(out),\n load(\n changetype(this) + (pos << 1),\n HEAD\n ),\n HEAD\n );\n return out;\n }\n\n charCodeAt(pos: i32): i32 {\n assert(this != null);\n\n if (pos >= this.length)\n return -1; // (NaN)\n\n return load(\n changetype(this) + (pos << 1),\n HEAD\n );\n }\n\n codePointAt(pos: i32): i32 {\n assert(this != null);\n\n if (pos >= this.length)\n return -1; // (undefined)\n var first = load(\n changetype(this) + (pos << 1),\n HEAD\n );\n if (first < 0xD800 || first > 0xDBFF || pos + 1 == this.length)\n return first;\n var second = load(\n changetype(this) + ((pos + 1) << 1),\n HEAD\n );\n if (second < 0xDC00 || second > 0xDFFF)\n return first;\n return ((first - 0xD800) << 10) + (second - 0xDC00) + 0x10000;\n }\n\n @operator("+")\n private static __concat(left: String, right: String): String {\n if (left == null)\n left = changetype("null");\n return left.concat(right);\n }\n\n concat(other: String): String {\n assert(this != null);\n\n if (other == null)\n other = changetype("null");\n\n var thisLen: isize = this.length;\n var otherLen: isize = other.length;\n var outLen: usize = thisLen + otherLen;\n if (outLen == 0)\n return EMPTY;\n\n var out = allocate(outLen);\n move_memory(\n changetype(out) + HEAD,\n changetype(this) + HEAD,\n thisLen << 1\n );\n move_memory(\n changetype(out) + HEAD + (thisLen << 1),\n changetype(other) + HEAD,\n otherLen << 1\n );\n return out;\n }\n\n endsWith(searchString: String, endPosition: i32 = 0x7fffffff): bool {\n assert(this != null);\n\n if (searchString == null)\n return false;\n\n var end: isize = min(max(endPosition, 0), this.length);\n var searchLength: isize = searchString.length;\n var start: isize = end - searchLength;\n if (start < 0)\n return false;\n\n return !compare_memory(\n changetype(this) + HEAD + (start << 1),\n changetype(searchString) + HEAD,\n searchLength << 1\n );\n }\n\n @operator("==")\n private static __eq(left: String, right: String): bool {\n if (left == null)\n return right == null;\n else if (right == null)\n return false;\n\n var leftLength = left.length;\n if (leftLength != right.length)\n return false;\n\n return !compare_memory(\n changetype(left) + HEAD,\n changetype(right) + HEAD,\n (leftLength << 1)\n );\n }\n\n includes(searchString: String, position: i32 = 0): bool {\n return this.indexOf(searchString, position) != -1;\n }\n\n indexOf(searchString: String, position: i32 = 0): i32 {\n assert(this != null);\n\n if (searchString == null)\n searchString = changetype("null");\n\n var pos: isize = position;\n var len: isize = this.length;\n var start: isize = min(max(pos, 0), len);\n var searchLen: isize = searchString.length;\n\n // TODO: two-way, multiple char codes\n for (var k: usize = start; k + searchLen <= len; ++k)\n if (!compare_memory(\n changetype(this) + HEAD + (k << 1),\n changetype(searchString) + HEAD,\n searchLen << 1)\n )\n return k;\n return -1;\n }\n\n startsWith(searchString: String, position: i32 = 0): bool {\n assert(this != null);\n\n if (searchString == null)\n searchString = changetype("null");\n\n var pos: isize = position;\n var len: isize = this.length;\n var start: isize = min(max(position, 0), len);\n var searchLength: isize = searchString.length;\n if (searchLength + start > len)\n return false;\n\n return !compare_memory(\n changetype(this) + HEAD + (start << 1),\n changetype(searchString) + HEAD,\n searchLength << 1\n );\n }\n\n substr(start: i32, length: i32 = i32.MAX_VALUE): String {\n assert(this != null);\n\n var intStart: isize = start;\n var end: isize = length;\n var size: isize = this.length;\n if (intStart < 0)\n intStart = max(size + intStart, 0);\n\n var resultLength: isize = min(max(end, 0), size - intStart);\n if (resultLength <= 0)\n return EMPTY;\n\n var out = allocate(resultLength);\n move_memory(\n changetype(out) + HEAD,\n changetype(this) + HEAD + (intStart << 1),\n resultLength << 1\n );\n return out;\n }\n\n substring(start: i32, end: i32 = i32.MAX_VALUE): String {\n assert(this != null);\n\n var len = this.length;\n var finalStart = min(max(start, 0), len);\n var finalEnd = min(max(end, 0), len);\n var from = min(finalStart, finalEnd);\n var to = max(finalStart, finalEnd);\n len = to - from;\n if (!len)\n return EMPTY;\n\n if (!from && to == this.length)\n return this;\n\n var out = allocate(len);\n move_memory(\n changetype(out) + HEAD,\n changetype(this) + HEAD + (from << 1),\n len << 1\n );\n return out;\n }\n\n trim(): String {\n assert(this != null);\n\n var length: usize = this.length;\n while (length && isWhiteSpaceOrLineTerminator(load(changetype(this) + (length << 1), HEAD)))\n --length;\n\n var start: usize = 0;\n while (start < length && isWhiteSpaceOrLineTerminator(load(changetype(this) + (start << 1), HEAD)))\n ++start, --length;\n\n if (!length)\n return EMPTY;\n\n if (!start && length == this.length)\n return this;\n\n var out = allocate(length);\n move_memory(\n changetype(out) + HEAD,\n changetype(this) + HEAD + (start << 1),\n length << 1\n );\n return out;\n }\n\n trimLeft(): String {\n assert(this != null);\n\n var start: isize = 0;\n var len: isize = this.length;\n while (start < len && isWhiteSpaceOrLineTerminator(load(changetype(this) + (start << 1), HEAD)))\n ++start;\n\n if (!start)\n return this;\n\n var outLen = len - start;\n if (!outLen)\n return EMPTY;\n\n var out = allocate(outLen);\n move_memory(\n changetype(out) + HEAD,\n changetype(this) + HEAD + (start << 1),\n outLen << 1\n );\n return out;\n }\n\n trimRight(): String {\n assert(this != null);\n\n var len: isize = this.length;\n while (len > 0 && isWhiteSpaceOrLineTerminator(load(changetype(this) + (len << 1), HEAD)))\n --len;\n\n if (len <= 0)\n return EMPTY;\n\n if (len == this.length)\n return this;\n\n var out = allocate(len);\n move_memory(\n changetype(out) + HEAD,\n changetype(this) + HEAD,\n len << 1\n );\n return out;\n }\n}\n\nfunction isWhiteSpaceOrLineTerminator(c: u16): bool {\n switch (c) {\n\n case 10: // \n case 13: // \n case 8232: // \n case 8233: // \n\n case 9: // \n case 11: // \n case 12: // \n case 32: // \n case 160: // \n case 65279: // \n\n return true;\n default:\n return false;\n }\n}\n\nconst enum CharCode {\n PLUS = 0x2B,\n MINUS = 0x2D,\n DOT = 0x2E,\n _0 = 0x30,\n _1 = 0x31,\n _2 = 0x32,\n _3 = 0x33,\n _4 = 0x34,\n _5 = 0x35,\n _6 = 0x36,\n _7 = 0x37,\n _8 = 0x38,\n _9 = 0x39,\n A = 0x41,\n B = 0x42,\n E = 0x45,\n O = 0x4F,\n X = 0x58,\n Z = 0x5a,\n a = 0x61,\n b = 0x62,\n e = 0x65,\n o = 0x6F,\n x = 0x78,\n z = 0x7A\n}\n\nexport function parseInt(str: String, radix: i32 = 0): f64 {\n return parse(str, radix);\n}\n\nexport function parseI32(str: String, radix: i32 = 0): i32 {\n return parse(str, radix);\n}\n\nexport function parseI64(str: String, radix: i32 = 0): i64 {\n return parse(str, radix);\n}\n\nfunction parse(str: String, radix: i32 = 0): T {\n var len: i32 = str.length;\n if (!len)\n return NaN;\n var ptr = changetype(str) /* + HEAD -> offset */;\n var code = load(ptr, HEAD);\n\n // determine sign\n var sign: T;\n if (code == CharCode.MINUS) {\n if (!--len)\n return NaN;\n code = load(ptr += 2, HEAD);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len)\n return NaN;\n code = load(ptr += 2, HEAD);\n sign = 1;\n } else\n sign = 1;\n\n // determine radix\n if (!radix) {\n if (code == CharCode._0 && len > 2) {\n switch (load(ptr + 2, HEAD)) {\n\n case CharCode.B:\n case CharCode.b:\n ptr += 4; len -= 2;\n radix = 2;\n break;\n\n case CharCode.O:\n case CharCode.o:\n ptr += 4; len -= 2;\n radix = 8;\n break;\n\n case CharCode.X:\n case CharCode.x:\n ptr += 4; len -= 2;\n radix = 16;\n break;\n\n default:\n radix = 10;\n }\n } else radix = 10;\n } else if (radix < 2 || radix > 36)\n return NaN;\n\n // calculate value\n var num: T = 0;\n while (len--) {\n code = load(ptr, HEAD);\n if (code >= CharCode._0 && code <= CharCode._9)\n code -= CharCode._0;\n else if (code >= CharCode.A && code <= CharCode.Z)\n code -= CharCode.A - 10;\n else if (code >= CharCode.a && code <= CharCode.z)\n code -= CharCode.a - 10;\n else\n break;\n if (code >= radix)\n break;\n num = (num * radix) + code;\n ptr += 2;\n }\n return sign * num;\n}\n\nexport function parseFloat(str: String): f64 {\n var len: i32 = str.length;\n if (!len)\n return NaN;\n var ptr = changetype(str) /* + HEAD -> offset */;\n var code = load(ptr, HEAD);\n\n // determine sign\n var sign: f64;\n if (code == CharCode.MINUS) {\n if (!--len)\n return NaN;\n code = load(ptr += 2, HEAD);\n sign = -1;\n } else if (code == CharCode.PLUS) {\n if (!--len)\n return NaN;\n code = load(ptr += 2, HEAD);\n sign = 1;\n } else\n sign = 1;\n\n // calculate value\n var num: f64 = 0;\n while (len--) {\n code = load(ptr, HEAD);\n if (code == CharCode.DOT) {\n ptr += 2;\n var fac: f64 = 0.1; // precision :(\n while (len--) {\n code = load(ptr, HEAD);\n if (code == CharCode.E || code == CharCode.e)\n assert(false); // TODO\n code -= CharCode._0;\n if (code > 9)\n break;\n num += code * fac;\n fac *= 0.1;\n ptr += 2;\n }\n break;\n }\n code -= CharCode._0;\n if (code >= 10)\n break;\n num = (num * 10) + code;\n ptr += 2;\n }\n return sign * num;\n}\n'}:{},t.definitionFiles=t.isBundle?{assembly:'// Definitions for the "AssemblyScript" subset.\n\n// Types\n\n/** An 8-bit signed integer. */\ndeclare type i8 = number;\n/** A 16-bit signed integer. */\ndeclare type i16 = number;\n/** A 32-bit signed integer. */\ndeclare type i32 = number;\n/** A 64-bit signed integer. */\ndeclare type i64 = number;\n/** A 32-bit signed integer when targeting 32-bit WebAssembly or a 64-bit signed integer when targeting 64-bit WebAssembly. */\ndeclare type isize = number;\n/** An 8-bit unsigned integer. */\ndeclare type u8 = number;\n/** A 16-bit unsigned integer. */\ndeclare type u16 = number;\n/** A 32-bit unsigned integer. */\ndeclare type u32 = number;\n/** A 64-bit unsigned integer. */\ndeclare type u64 = number;\n/** A 32-bit unsigned integer when targeting 32-bit WebAssembly or a 64-bit unsigned integer when targeting 64-bit WebAssembly. */\ndeclare type usize = number;\n/** A 1-bit unsigned integer. */\ndeclare type bool = any; // sic\n/** A 32-bit float. */\ndeclare type f32 = number;\n/** A 64-bit float. */\ndeclare type f64 = number;\n\n/** Converts any other numeric value to an 8-bit signed integer. */\ndeclare function i8(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i8;\ndeclare namespace i8 {\n export const MIN_VALUE: i8;\n export const MAX_VALUE: i8;\n}\n/** Converts any other numeric value to a 16-bit signed integer. */\ndeclare function i16(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i8;\ndeclare namespace i16 {\n export const MIN_VALUE: i16;\n export const MAX_VALUE: i16;\n}\n/** Converts any other numeric value to a 32-bit signed integer. */\ndeclare function i32(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i32;\ndeclare namespace i32 {\n export const MIN_VALUE: i32;\n export const MAX_VALUE: i32;\n}\n/** Converts any other numeric value to a 64-bit signed integer. */\ndeclare function i64(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i64;\ndeclare namespace i64 {\n export const MIN_VALUE: i64;\n export const MAX_VALUE: i64;\n}\n/** Converts any other numeric value to a 32-bit (in WASM32) respectivel 64-bit (in WASM64) signed integer. */\ndeclare function isize(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): isize;\ndeclare namespace isize {\n export const MIN_VALUE: isize;\n export const MAX_VALUE: isize;\n}\n/** Converts any other numeric value to an 8-bit unsigned integer. */\ndeclare function u8(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i8;\ndeclare namespace u8 {\n export const MIN_VALUE: u8;\n export const MAX_VALUE: u8;\n}\n/** Converts any other numeric value to a 16-bit unsigned integer. */\ndeclare function u16(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i8;\ndeclare namespace u16 {\n export const MIN_VALUE: u16;\n export const MAX_VALUE: u16;\n}\n/** Converts any other numeric value to a 32-bit unsigned integer. */\ndeclare function u32(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i32;\ndeclare namespace u32 {\n export const MIN_VALUE: u32;\n export const MAX_VALUE: u32;\n}\n/** Converts any other numeric value to a 64-bit unsigned integer. */\ndeclare function u64(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): i64;\ndeclare namespace u64 {\n export const MIN_VALUE: u64;\n export const MAX_VALUE: u64;\n}\n/** Converts any other numeric value to a 32-bit (in WASM32) respectivel 64-bit (in WASM64) unsigned integer. */\ndeclare function usize(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): isize;\ndeclare namespace usize {\n export const MIN_VALUE: usize;\n export const MAX_VALUE: usize;\n}\n/** Converts any other numeric value to a 1-bit unsigned integer. */\ndeclare function bool(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): bool;\ndeclare namespace bool {\n export const MIN_VALUE: bool;\n export const MAX_VALUE: bool;\n}\n/** Converts any other numeric value to a 32-bit float. */\ndeclare function f32(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): f32;\ndeclare namespace f32 {\n export const MIN_VALUE: f32;\n export const MAX_VALUE: f32;\n /** Smallest safely representable integer value. */\n export const MIN_SAFE_INTEGER: f32;\n /** Largest safely representable integer value. */\n export const MAX_SAFE_INTEGER: f32;\n /** Difference between 1 and the smallest representable value greater than 1. */\n export const EPSILON: f32;\n}\n/** Converts any other numeric value to a 64-bit float. */\ndeclare function f64(value: i8 | i16 | i32 | i64 | isize | u8 | u16 | u32 | u64 | usize | bool | f32 | f64): f64;\ndeclare namespace f64 {\n export const MIN_VALUE: f64;\n export const MAX_VALUE: f64;\n /** Smallest safely representable integer value. */\n export const MIN_SAFE_INTEGER: f64;\n /** Largest safely representable integer value. */\n export const MAX_SAFE_INTEGER: f64;\n /** Difference between 1 and the smallest representable value greater than 1. */\n export const EPSILON: f64;\n}\n\n// Built-ins\n\n/** Performs the sign-agnostic count leading zero bits operation on a 32-bit or 64-bit integer. All zero bits are considered leading if the value is zero. */\ndeclare function clz(value: T): T;\n/** Performs the sign-agnostic count tailing zero bits operation on a 32-bit or 64-bit integer. All zero bits are considered trailing if the value is zero. */\ndeclare function ctz(value: T): T;\n/** Performs the sign-agnostic count number of one bits operation on a 32-bit or 64-bit integer. */\ndeclare function popcnt(value: T): T;\n/** Performs the sign-agnostic rotate left operation on a 32-bit or 64-bit integer. */\ndeclare function rotl(value: T, shift: T): T;\n/** Performs the sign-agnostic rotate right operation on a 32-bit or 64-bit integer. */\ndeclare function rotr(value: T, shift: T): T;\n/** Computes the absolute value of an integer or float. */\ndeclare function abs(value: T): T;\n/** Determines the maximum of two integers or floats. If either operand is `NaN`, returns `NaN`. */\ndeclare function max(left: T, right: T): T;\n/** Determines the minimum of two integers or floats. If either operand is `NaN`, returns `NaN`. */\ndeclare function min(left: T, right: T): T;\n/** Performs the ceiling operation on a 32-bit or 64-bit float. */\ndeclare function ceil(value: T): T;\n/** Composes a 32-bit or 64-bit float from the magnitude of `x` and the sign of `y`. */\ndeclare function copysign(x: T, y: T): T;\n/** Performs the floor operation on a 32-bit or 64-bit float. */\ndeclare function floor(value: T): T;\n/** Rounds to the nearest integer tied to even of a 32-bit or 64-bit float. */\ndeclare function nearest(value: T): T;\n/** Reinterprets the bits of the specified value as type `T`. Valid reinterpretations are u32/i32 to/from f32 and u64/i64 to/from f64. */\ndeclare function reinterpret(value: number): T;\n/** Selects one of two pre-evaluated values depending on the condition. */\ndeclare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n/** Calculates the square root of a 32-bit or 64-bit float. */\ndeclare function sqrt(value: T): T;\n/** Rounds to the nearest integer towards zero of a 32-bit or 64-bit float. */\ndeclare function trunc(value: T): T;\n/** Loads a value of the specified type from memory. Equivalent to dereferncing a pointer in other languages. */\ndeclare function load(ptr: usize, constantOffset?: usize): any;\n/** Stores a value of the specified type to memory. Equivalent to dereferencing a pointer in other languages when assigning a value. */\ndeclare function store(ptr: usize, value: any, constantOffset?: usize): void;\n/** Returns the current memory size in units of pages. One page is 64kb. */\ndeclare function current_memory(): i32;\n/** Grows linear memory by a given unsigned delta of pages. One page is 64kb. Returns the previous memory size in units of pages or `-1` on failure. */\ndeclare function grow_memory(value: i32): i32;\n/** Copies n bytes from the specified source to the specified destination in memory. These regions may overlap. */\ndeclare function move_memory(destination: usize, source: usize, n: usize): void;\n/** Sets n bytes beginning at the specified destination in memory to the specified byte value. */\ndeclare function set_memory(destination: usize, value: u8, count: usize): void;\n/** Compares two chunks of memory. Returns `0` if equal, otherwise the difference of the first differing bytes. */\ndeclare function compare_memory(vl: usize, vr: usize, n: usize): i32;\n/** Allocates a chunk of memory of the specified size and returns a pointer to it. */\ndeclare function allocate_memory(size: usize): usize;\n/** Disposes a chunk of memory by its pointer. */\ndeclare function free_memory(ptr: usize): void;\n/** Emits an unreachable operation that results in a runtime error when executed. Both a statement and an expression of any type. */\ndeclare function unreachable(): any; // sic\n\n/** NaN (not a number) as a 32-bit or 64-bit float depending on context. */\ndeclare const NaN: f32 | f64;\n/** Positive infinity as a 32-bit or 64-bit float depending on context. */\ndeclare const Infinity: f32 | f64;\n/** Heap base offset. */\ndeclare const HEAP_BASE: usize;\n/** Determines the byte size of the specified core or class type. Compiles to a constant. */\ndeclare function sizeof(): usize;\n/** Changes the type of any value of `usize` kind to another one of `usize` kind. Useful for casting class instances to their pointer values and vice-versa. Beware that this is unsafe.*/\ndeclare function changetype(value: any): T;\n/** Tests if a 32-bit or 64-bit float is `NaN`. */\ndeclare function isNaN(value: T): bool;\n/** Tests if a 32-bit or 64-bit float is finite, that is not `NaN` or +/-`Infinity`. */\ndeclare function isFinite(value: T): bool;\n/** Traps if the specified value is not true-ish, otherwise returns the (non-nullable) value. */\ndeclare function assert(isTrueish: T, message?: string): T & object; // any better way to model `: T != null`?\n/** Parses an integer string to a 64-bit float. */\ndeclare function parseInt(str: string, radix?: i32): f64;\n/** Parses an integer string to a 32-bit integer. */\ndeclare function parseI32(str: string, radix?: i32): i32;\n/** Parses an integer string to a 64-bit integer. */\ndeclare function parseI64(str: string, radix?: i32): i64;\n/** Parses a string to a 64-bit float. */\ndeclare function parseFloat(str: string): f64;\n\n// Standard library (not yet implemented)\n\n/** Class representing a sequence of values of type `T`. */\ndeclare class Array {\n [key: number]: T;\n /** Current length of the array. */\n length: i32;\n /** Constructs a new array. */\n constructor(capacity?: i32);\n indexOf(searchElement: T, fromIndex?: i32): i32;\n lastIndexOf(searchElement: T, fromIndex?: i32): i32;\n push(element: T): void;\n pop(): T;\n shift(): T;\n unshift(element: T): i32;\n slice(from: i32, to?: i32): T[];\n splice(start: i32, deleteCount?: i32): void;\n reverse(): T[];\n}\n\n/** Class representing a C-like array of values of type `T` with limited capabilities. */\ndeclare class CArray {\n [key: number]: T;\n private constructor();\n}\n\n/** Class representing a sequence of characters. */\ndeclare class String {\n\n static fromCharCode(ls: i32, hs?: i32): string;\n static fromCharCodes(arr: u16[]): string;\n static fromCodePoint(cp: i32): string;\n static fromCodePoints(arr: i32[]): string;\n\n readonly length: u32;\n\n charAt(index: u32): string;\n charCodeAt(index: u32): u16;\n concat(other: string): string;\n endsWith(other: string): bool;\n indexOf(other: string): u32;\n includes(other: string): bool;\n startsWith(other: string): bool;\n substr(start: u32, length?: u32): string;\n substring(start: u32, end?: u32): string;\n trim(): string;\n trimLeft(): string;\n trimRight(): string;\n}\n\n/** Class for representing a runtime error. Base class of all errors. */\ndeclare class Error {\n\n /** Error name. */\n name: string;\n\n /** Message provided on construction. */\n message: string;\n\n /** Stack trace. */\n stack: string;\n\n /** Constructs a new error, optionally with a message. */\n constructor(message?: string);\n}\n\n/** Class for indicating an error when a value is not in the set or range of allowed values. */\ndeclare class RangeError extends Error { }\n\ninterface Boolean {}\ninterface Function {}\ninterface IArguments {}\ninterface Number {}\ninterface Object {}\ninterface RegExp {}\n\ndeclare class Set {\n readonly size: i32;\n has(value: T): bool;\n add(value: T): void;\n delete(value: T): bool;\n clear(): void;\n}\n\n// Internal decorators\n\n/** Annotates an element as a program global. */\ndeclare function global(target: Function): any;\n\n/** Annotates a method as an operator overload. */\ndeclare function operator(token: string): any;\n\n/** Annotates a class as being unmanaged with limited capabilities. */\ndeclare function unmanaged(target: Function): any;\n\n/** Annotates a class field with an explicit offset. */\ndeclare function offset(offset: usize): any;\n\n/** Annotates an element as begin built-in. */\ndeclare function builtin(target: Function): any;\n',portable:'// Definitions for the "portable AssemblyScript" subset.\n\n// Portable types\n\n// Note that semantic differences require additional explicit conversions for full compatibility.\n// For example, when casting an i32 to an u8, doing `(someI32 & 0xff)` will yield the same\n// result when compiling to WebAssembly or JS while `someI32` alone does nothing in JS.\n\n// Note that i64\'s are not portable (JS numbers are IEEE754 doubles with a maximum safe integer value\n// of 2^53-1) and instead require a compatibility layer to work in JS as well. See: src/util/i64.ts\n\ndeclare type i8 = number;\ndeclare type i16 = number;\ndeclare type i32 = number;\ndeclare type isize = number;\ndeclare type u8 = number;\ndeclare type u16 = number;\ndeclare type u32 = number;\ndeclare type bool = boolean;\ndeclare type usize = number;\ndeclare type f32 = number;\ndeclare type f64 = number;\n\n/** Converts any other numeric value to an 8-bit signed integer. */\ndeclare function i8(value: i8 | i16 | i32 | isize | u8 | u16 | u32 | usize | bool | f32 | f64): i8;\ndeclare namespace i8 {\n export const MIN_VALUE: i8;\n export const MAX_VALUE: i8;\n}\n/** Converts any other numeric value to a 16-bit signed integer. */\ndeclare function i16(value: i8 | i16 | i32 | isize | u8 | u16 | u32 | usize | bool | f32 | f64): i8;\ndeclare namespace i16 {\n export const MIN_VALUE: i16;\n export const MAX_VALUE: i16;\n}\n/** Converts any other numeric value to a 32-bit signed integer. */\ndeclare function i32(value: i8 | i16 | i32 | isize | u8 | u16 | u32 | usize | bool | f32 | f64): i32;\ndeclare namespace i32 {\n export const MIN_VALUE: i32;\n export const MAX_VALUE: i32;\n}\n/** Converts any other numeric value to a 32-bit (in WASM32) respectivel 64-bit (in WASM64) signed integer. */\ndeclare function isize(value: i8 | i16 | i32 | isize | u8 | u16 | u32 | usize | bool | f32 | f64): isize;\ndeclare namespace isize {\n export const MIN_VALUE: isize;\n export const MAX_VALUE: isize;\n}\n/** Converts any other numeric value to an 8-bit unsigned integer. */\ndeclare function u8(value: i8 | i16 | i32 | isize | u8 | u16 | u32 | usize | bool | f32 | f64): i8;\ndeclare namespace u8 {\n export const MIN_VALUE: u8;\n export const MAX_VALUE: u8;\n}\n/** Converts any other numeric value to a 16-bit unsigned integer. */\ndeclare function u16(value: i8 | i16 | i32 | isize | u8 | u16 | u32 | usize | bool | f32 | f64): i8;\ndeclare namespace u16 {\n export const MIN_VALUE: u16;\n export const MAX_VALUE: u16;\n}\n/** Converts any other numeric value to a 32-bit unsigned integer. */\ndeclare function u32(value: i8 | i16 | i32 | isize | u8 | u16 | u32 | usize | bool | f32 | f64): i32;\ndeclare namespace u32 {\n export const MIN_VALUE: u32;\n export const MAX_VALUE: u32;\n}\n/** Converts any other numeric value to a 32-bit (in WASM32) respectivel 64-bit (in WASM64) unsigned integer. */\ndeclare function usize(value: i8 | i16 | i32 | isize | u8 | u16 | u32 | usize | bool | f32 | f64): isize;\ndeclare namespace usize {\n export const MIN_VALUE: usize;\n export const MAX_VALUE: usize;\n}\n/** Converts any other numeric value to a 1-bit unsigned integer. */\ndeclare function bool(value: i8 | i16 | i32 | isize | u8 | u16 | u32 | usize | bool | f32 | f64): bool;\ndeclare namespace bool {\n export const MIN_VALUE: bool;\n export const MAX_VALUE: bool;\n}\n/** Converts any other numeric value to a 32-bit float. */\ndeclare function f32(value: i8 | i16 | i32 | isize | u8 | u16 | u32 | usize | bool | f32 | f64): f32;\ndeclare namespace f32 {\n /** Smallest safely representable integer value. */\n export const MIN_SAFE_INTEGER: f32;\n /** Largest safely representable integer value. */\n export const MAX_SAFE_INTEGER: f32;\n /** Difference between 1 and the smallest representable value greater than 1. */\n export const EPSILON: f32;\n}\n/** Converts any other numeric value to a 64-bit float. */\ndeclare function f64(value: i8 | i16 | i32 | isize | u8 | u16 | u32 | usize | bool | f32 | f64): f64;\ndeclare namespace f64 {\n /** Smallest safely representable integer value. */\n export const MIN_SAFE_INTEGER: f64;\n /** Largest safely representable integer value. */\n export const MAX_SAFE_INTEGER: f64;\n /** Difference between 1 and the smallest representable value greater than 1. */\n export const EPSILON: f64;\n}\n\n// Portable built-ins\n\n/** Performs the sign-agnostic count leading zero bits operation on a 32-bit integer. All zero bits are considered leading if the value is zero. */\ndeclare function clz(value: T): T;\n/** Computes the absolute value of an integer or float. */\ndeclare function abs(value: T): T;\n/** Determines the maximum of two integers or floats. If either operand is `NaN`, returns `NaN`. */\ndeclare function max(left: T, right: T): T;\n/** Determines the minimum of two integers or floats. If either operand is `NaN`, returns `NaN`. */\ndeclare function min(left: T, right: T): T;\n/** Performs the ceiling operation on a 32-bit or 64-bit float. */\ndeclare function ceil(value: T): T;\n/** Performs the floor operation on a 32-bit or 64-bit float. */\ndeclare function floor(value: T): T;\n/** Selects one of two pre-evaluated values depending on the condition. */\ndeclare function select(ifTrue: T, ifFalse: T, condition: bool): T;\n/** Calculates the square root of a 32-bit or 64-bit float. */\ndeclare function sqrt(value: T): T;\n/** Rounds to the nearest integer towards zero of a 32-bit or 64-bit float. */\ndeclare function trunc(value: T): T;\n/** Allocates a chunk of memory of the specified size and returns a pointer to it. */\ndeclare function allocate_memory(size: usize): usize;\n/** Disposes a chunk of memory by its pointer. */\ndeclare function free_memory(ptr: usize): void;\n/** Copies n bytes from the specified source to the specified destination in memory. These regions may overlap. */\ndeclare function move_memory(destination: usize, source: usize, n: usize): void;\n/** Loads a value of the specified type from memory. Type must be `u8`. */\ndeclare function load(ptr: usize, constantOffset?: usize): T;\n/** Stores a value of the specified type to memory. Type must be `u8`. */\ndeclare function store(ptr: usize, value: T, constantOffset?: usize): void;\n/** Emits an unreachable operation that results in a runtime error when executed. */\ndeclare function unreachable(): any; // sic\n\n/** Changes the type of any value of `usize` kind to another one of `usize` kind. Useful for casting class instances to their pointer values and vice-versa. Beware that this is unsafe.*/\ndeclare function changetype(value: any): T;\n/** Traps if the specified value is not true-ish, otherwise returns the value. */\ndeclare function assert(isTrueish: T, message?: string): T & object; // any better way to model `: T != null`?\n/** Parses an integer string to a 64-bit float. */\ndeclare function parseInt(str: string, radix?: i32): f64;\n/** Parses an integer string to a 32-bit integer. */\ndeclare function parseI32(str: string, radix?: i32): i32;\n/** Parses a floating point string to a 64-bit float. */\ndeclare function parseFloat(str: string): f64;\n\n// Portable standard library\n// Everything marked @deprecated is a temporary filler. Do not use.\n\ndeclare const NaN: f32 | f64;\ndeclare const Infinity: f32 | f64;\n\ndeclare class Array {\n [key: number]: T;\n length: i32;\n constructor(capacity?: i32);\n indexOf(searchElement: T, fromIndex?: i32): i32;\n lastIndexOf(searchElement: T, fromIndex?: i32): i32;\n push(element: T): void;\n pop(): T;\n shift(): T;\n unshift(element: T): i32;\n slice(from: i32, to?: i32): T[];\n splice(start: i32, deleteCount?: i32): void;\n reverse(): T[];\n\n join(delim: string): string;\n}\n\ndeclare class Uint8Array extends Array {}\ndeclare class Uint16Array extends Array {}\ndeclare class Uint32Array extends Array {}\ndeclare class Int8Array extends Array {}\ndeclare class Int16Array extends Array {}\ndeclare class Int32Array extends Array {}\ndeclare class Float32Array extends Array {}\ndeclare class Float64Array extends Array {}\n\ndeclare class String {\n static fromCharCode(ls: i32, hs?: i32): string;\n static fromCharCodes(arr: u16[]): string;\n static fromCodePoint(cp: i32): string;\n static fromCodePoints(arr: i32[]): string;\n readonly length: i32;\n private constructor();\n indexOf(subject: string): i32;\n includes(other: string): bool;\n lastIndexOf(subject: string): i32;\n charAt(index: i32): string;\n charCodeAt(index: i32): i32;\n substring(from: i32, to?: i32): string;\n startsWith(subject: string): bool;\n endsWith(subject: string): bool;\n replace(search: string, replacement: string): string;\n toString(): string;\n}\n\ninterface Boolean {}\n\ndeclare class Number {\n private constructor();\n toString(radix?: i32): string;\n}\n\ninterface Object {}\n\ninterface Function {}\n\ninterface RegExp {}\n\ninterface IArguments {}\n\ndeclare class Error {\n constructor(message: string);\n message: string;\n stack: string | null;\n}\n\ndeclare class Symbol {\n private constructor();\n static readonly iterator: symbol;\n}\n\ndeclare class Set {\n constructor(entries?: T[]);\n has(value: T): bool;\n add(value: T): void;\n delete(value: T): bool;\n clear(): void;\n [Symbol.iterator](): Iterator;\n}\n\ndeclare class Map {\n constructor(entries?: [K, V][]);\n readonly size: i32;\n set(key: K, value: V): void;\n has(key: K): bool;\n get(key: K): V | null;\n clear(): void;\n entries(): Iterable<[K, V]>;\n keys(): Iterable;\n values(): Iterable;\n [Symbol.iterator](): Iterator<[K,V]>;\n}\n\ninterface Iterable {\n [Symbol.iterator](): Iterator;\n}\n\ninterface Iterator {}\n\ndeclare namespace console {\n /** @deprecated */\n function log(message: string): void;\n}\n'}:{},t.main=function(r,h,m){function g(e){try{var t;return E.readCount++,E.readTime+=a(()=>{t=u.readFileSync(e,{encoding:'utf8'})}),t}catch(t){return null}}function y(e,t){try{return E.writeCount++,E.writeTime+=a(()=>{'string'==typeof t?u.writeFileSync(e,t,{encoding:'utf8'}):u.writeFileSync(e,t)}),!0}catch(t){return!1}}function b(e){var t;try{return E.readTime+=a(()=>{t=i(!function(){var t=new Error('Cannot find module "glob"');throw t.code='MODULE_NOT_FOUND',t}()).sync('*.ts',{cwd:e})}),t}catch(t){return[]}}function _(e){_.used||(E.writeCount++,_.used=!0),E.writeTime+=a(()=>{'string'==typeof e?v.write(e,{encoding:'utf8'}):v.write(e)})}'function'==typeof h?(m=h,h={}):!h&&(h={});const v=h.stdout||e.stdout,T=h.stderr||e.stderr,x=h.readFile||g,z=h.writeFile||y,A=h.listFiles||b,E=h.stats||o();if(!v)throw Error('\'options.stdout\' must be specified');if(!T)throw Error('\'options.stderr\' must be specified');if(!u.readFileSync){if(x===g)throw Error('\'options.readFile\' must be specified');if(z===y)throw Error('\'options.writeFile\' must be specified');if(A===b)throw Error('\'options.listFiles\' must be specified')}const w=n(r),L=24;if(m||(m=function(e){var t=0;return e&&(T.write(e.stack+d.EOL),t=1),t}),w.version)return v.write('Version '+t.version+(p?'-dev':'')+d.EOL),m(null);if(w.help||1>w._.length){const e=[];return Object.keys(t.options).forEach((i)=>{var r=t.options[i],n=' ';for(n+='--'+i,r.aliases&&1===r.aliases[0].length&&(n+=', -'+r.aliases[0]);n.length{for(let t=0;t hello.wasm','','Options:'].concat(e).join(d.EOL)+d.EOL),m(null)}const S=w.baseDir?c.resolve(w.baseDir):e.cwd(),C=c.join('.','..','std','assembly'),I=w.noLib?[]:[C];w.lib&&('string'==typeof w.lib&&(w.lib=w.lib.split(',')),Array.prototype.push.apply(I,w.lib.map(trim)));var k=null;for(let e=0,i=w._.length;e{k=f.parseFile(n,r,k,!0)});null!=(r=k.nextFile());){if(r.startsWith(t.libraryPrefix)){for(let e=0,i=I.length;e{f.parseFile(n,r,k)})}if(s(k,T))return m(Error('Parse error'))}var P=!1;w.noLib||Object.keys(t.libraryFiles).forEach((e)=>{e.lastIndexOf('/')>=t.libraryPrefix.length||(E.parseCount++,E.parseTime+=a(()=>{k=f.parseFile(t.libraryFiles[e],e+'.ts',k)}),P=!0)});for(let e=0,i=I.length;e{k=f.parseFile(s,t.libraryPrefix+n,k)})}}const N=f.createOptions();f.setTarget(N,0),f.setNoTreeShaking(N,!!w.noTreeShaking),f.setNoAssert(N,!!w.noAssert),f.setNoMemory(N,!!w.noMemory),f.setSourceMap(N,null!=w.sourceMap);var M;E.compileCount++;try{E.compileTime+=a(()=>{M=f.compile(k,N)})}catch(t){return m(t)}if(s(k,T))return M&&M.dispose(),m(Error('Compile error'));if(w.validate&&(E.validateCount++,E.validateTime+=a(()=>{if(!M.validate())return M.dispose(),m(Error('Validate error'))})),'clamp'===w.trapMode)E.optimizeCount++,E.optimizeTime+=a(()=>{M.runPasses(['trap-mode-clamp'])});else if('js'===w.trapMode)E.optimizeCount++,E.optimizeTime+=a(()=>{M.runPasses(['trap-mode-js'])});else if('allow'!==w.trapMode)return M.dispose(),m(Error('Unsupported trap mode'));var U=-1,O=0,D=!w.noDebug;!1!==w.optimize&&('number'==typeof w.optimize?U=w.optimize:w[0]?U=0:w[1]?U=1:w[2]?U=2:w[3]?U=3:!0===w.optimize?(U=t.defaultOptimizeLevel,O=t.defaultShrinkLevel):U=0),w.s?O=1:w.z&&(O=2),'number'==typeof w.optimizeLevel&&(U=w.optimizeLevel),'number'==typeof w.shrinkLevel?O=w.shrinkLevel:'s'===w.shrinkLevel?O=1:'z'===w.shrinkLevel&&(O=2),M.setOptimizeLevel(U),M.setShrinkLevel(O),M.setDebugInfo(D);var F=[];if(w.runPasses&&('string'==typeof w.runPasses&&(w.runPasses=w.runPasses.split(',')),w.runPasses.length&&w.runPasses.forEach((e)=>{0>F.indexOf(e)&&F.push(e)})),0<=U&&(E.optimizeCount++,E.optimizeTime+=a(()=>M.optimize())),F.length&&(E.optimizeCount++,E.optimizeTime+=a(()=>{M.runPasses(F.map((e)=>e.trim()))})),!w.noEmit){let e=!1;if(null!=w.outFile&&(/\.wast$/.test(w.outFile)&&null==w.textFile?w.textFile=w.outFile:/\.js$/.test(w.outFile)&&null==w.asmjsFile?w.asmjsFile=w.outFile:null==w.binaryFile&&(w.binaryFile=w.outFile)),null!=w.binaryFile){let i,r=null==w.sourceMap?null:w.sourceMap.length?w.sourceMap:c.basename(w.binaryFile)+'.map';if(E.emitCount++,E.emitTime+=a(()=>i=M.toBinary(r)),w.binaryFile.length?z(c.join(S,w.binaryFile),i.output):(_(i.output),e=!0),null!=i.sourceMap)if(w.binaryFile.length){let e=JSON.parse(i.sourceMap);e.sourceRoot=t.sourceMapRoot,e.sources.forEach((r,i)=>{let n=null;if(r.startsWith(t.libraryPrefix))for(let e=0,i=I.length;et=M.toText()),z(c.join(S,w.textFile),t)):!e&&(E.emitCount++,E.emitTime+=a(()=>t=M.toText()),_(t),e=!0)}if(null!=w.asmjsFile&&w.asmjsFile.length){let t;w.asmjsFile.length?(E.emitCount++,E.emitTime+=a(()=>t=M.toAsmjs()),z(c.join(S,w.asmjsFile),t)):!e&&(E.emitCount++,E.emitTime+=a(()=>t=M.toAsmjs()),_(t),e=!0)}}return M.dispose(),w.measure&&l(E,T),m(null)},t.parseArguments=n,t.checkDiagnostics=s,t.createStats=o,e.hrtime||(e.hrtime=i(15)),t.measure=a,t.printStats=l,t.createMemoryStream=function(e){var t=[];return t.write=function(t){'string'==typeof t?this.push(r.from(t,'utf8')):this.push(t),e&&e(t)},t.toBuffer=function(){return r.concat(this)},t.toString=function(){return this.toBuffer().toString('utf8')},t},t.tscOptions={alwaysStrict:!0,noImplicitAny:!0,noImplicitReturns:!0,noImplicitThis:!0,noEmitOnError:!0,strictNullChecks:!0,experimentalDecorators:!0,target:'esnext',module:'commonjs',noLib:!0,types:[],allowJs:!1}}).call(t,i(0),i(5).Buffer)},function(e,t,i){'use strict';(function(e){function o(){return l.TYPED_ARRAY_SUPPORT?2147483647:1073741823}function a(e,t){if(o()e)throw new RangeError('"size" argument must not be negative')}function d(e,t,i,r){return c(t),0>=t?a(e,t):void 0===i?a(e,t):'string'==typeof r?a(e,t).fill(i,r):a(e,t).fill(i)}function f(e,t){if(c(t),e=a(e,0>t?0:0|y(t)),!l.TYPED_ARRAY_SUPPORT)for(var r=0;rt.length?0:0|y(t.length);e=a(e,r);for(var n=0;ni||t.byteLength=o())throw new RangeError('Attempt to allocate Buffer larger than maximum size: 0x'+o().toString(16)+' bytes');return 0|e}function b(e,t){if(l.isBuffer(e))return e.length;if('undefined'!=typeof ArrayBuffer&&'function'==typeof ArrayBuffer.isView&&(ArrayBuffer.isView(e)||e instanceof ArrayBuffer))return e.byteLength;'string'!=typeof e&&(e=''+e);var i=e.length;if(0===i)return 0;for(var r=!1;;)switch(t){case'ascii':case'latin1':case'binary':return i;case'utf8':case'utf-8':case void 0:return W(e).length;case'ucs2':case'ucs-2':case'utf16le':case'utf-16le':return 2*i;case'hex':return i>>>1;case'base64':return K(e).length;default:if(r)return W(e).length;t=(''+t).toLowerCase(),r=!0;}}function _(e,t,i){var r=!1;if((void 0===t||0>t)&&(t=0),t>this.length)return'';if((void 0===i||i>this.length)&&(i=this.length),0>=i)return'';if(i>>>=0,t>>>=0,i<=t)return'';for(e||(e='utf8');;)switch(e){case'hex':return M(this,t,i);case'utf8':case'utf-8':return I(this,t,i);case'ascii':return P(this,t,i);case'latin1':case'binary':return N(this,t,i);case'base64':return C(this,t,i);case'ucs2':case'ucs-2':case'utf16le':case'utf-16le':return U(this,t,i);default:if(r)throw new TypeError('Unknown encoding: '+e);e=(e+'').toLowerCase(),r=!0;}}function v(e,t,r){var n=e[t];e[t]=e[r],e[r]=n}function T(e,t,i,r,n){if(0===e.length)return-1;if('string'==typeof i?(r=i,i=0):2147483647i&&(i=-2147483648),i=+i,isNaN(i)&&(i=n?0:e.length-1),0>i&&(i=e.length+i),i>=e.length){if(n)return-1;i=e.length-1}else if(0>i)if(n)i=0;else return-1;if('string'==typeof t&&(t=l.from(t,r)),l.isBuffer(t))return 0===t.length?-1:x(e,t,i,r,n);if('number'==typeof t)return t&=255,l.TYPED_ARRAY_SUPPORT&&'function'==typeof Uint8Array.prototype.indexOf?n?Uint8Array.prototype.indexOf.call(e,t,i):Uint8Array.prototype.lastIndexOf.call(e,t,i):x(e,[t],i,r,n);throw new TypeError('val must be string, number or Buffer')}function x(e,t,r,n,s){function o(e,t){return 1===a?e[t]:e.readUInt16BE(t*a)}var a=1,l=e.length,u=t.length;if(void 0!==n&&(n=(n+'').toLowerCase(),'ucs2'===n||'ucs-2'===n||'utf16le'===n||'utf-16le'===n)){if(2>e.length||2>t.length)return-1;a=2,l/=2,u/=2,r/=2}var c;if(s){var i=-1;for(c=r;cl&&(r=l-u),c=r;0<=c;c--){for(var d=!0,f=0;fs&&(n=s)):n=s;var o=t.length;if(0!=o%2)throw new TypeError('Invalid hex string');n>o/2&&(n=o/2);for(var a,l=0;li&&(a=i):2==l?(u=e[o+1],128==(192&u)&&(f=(31&i)<<6|63&u,127f||57343f&&(a=f))):void 0}null===a?(a=65533,l=1):65535>>10),a=56320|1023&a),n.push(a),o+=l}return k(n)}function k(e){var t=e.length;if(t<=ie)return Q.apply(String,e);for(var r='',n=0;nt)&&(t=0),(!r||0>r||r>n)&&(r=n);for(var s='',o=t;oe)throw new RangeError('offset is not uint');if(e+t>i)throw new RangeError('Trying to access beyond buffer length')}function D(e,t,i,r,n,s){if(!l.isBuffer(e))throw new TypeError('"buffer" argument must be a Buffer instance');if(t>n||te.length)throw new RangeError('Index out of range')}function F(e,t,r,n){0>t&&(t=65535+t+1);for(var o=0,i=s(e.length-r,2);o>>8*(n?o:1-o)}function R(e,t,r,n){0>t&&(t=4294967295+t+1);for(var o=0,i=s(e.length-r,4);o>>8*(n?o:3-o)}function V(e,t,i,r){if(i+r>e.length)throw new RangeError('Index out of range');if(0>i)throw new RangeError('Index out of range')}function B(e,t,i,r,n){return n||V(e,t,i,4,34028234663852886e22,-34028234663852886e22),ee.write(e,t,i,r,23,4),i+4}function j(e,t,i,r,n){return n||V(e,t,i,8,17976931348623157e292,-17976931348623157e292),ee.write(e,t,i,r,52,8),i+8}function H(e){if(e=Y(e).replace(re,''),2>e.length)return'';for(;0!=e.length%4;)e+='=';return e}function Y(e){return e.trim?e.trim():e.replace(/^\s+|\s+$/g,'')}function X(e){return 16>e?'0'+e.toString(16):e.toString(16)}function W(e,t){t=t||Infinity;for(var r,n=e.length,s=null,o=[],a=0;ar){if(!s){if(56319r){-1<(t-=3)&&o.push(239,191,189),s=r;continue}r=(s-55296<<10|r-56320)+65536}else s&&-1<(t-=3)&&o.push(239,191,189);if(s=null,128>r){if(0>(t-=1))break;o.push(r)}else if(2048>r){if(0>(t-=2))break;o.push(192|r>>6,128|63&r)}else if(65536>r){if(0>(t-=3))break;o.push(224|r>>12,128|63&r>>6,128|63&r)}else if(1114112>r){if(0>(t-=4))break;o.push(240|r>>18,128|63&r>>12,128|63&r>>6,128|63&r)}else throw new Error('Invalid code point')}return o}function G(e){for(var t=[],r=0;r(t-=2));++a)r=e.charCodeAt(a),n=r>>8,s=r%256,o.push(s),o.push(n);return o}function K(e){return $.toByteArray(H(e))}function J(e,t,r,n){for(var s=0;s=t.length||s>=e.length);++s)t[s+r]=e[s];return s}function Z(e){return e!==e}var Q=String.fromCharCode,$=i(6),ee=i(7),te=i(8);/*! * The buffer module from node.js, for the browser. * * @author Feross Aboukhadijeh * @license MIT */t.Buffer=l,t.SlowBuffer=function(e){return+e!=e&&(e=0),l.alloc(+e)},t.INSPECT_MAX_BYTES=50,l.TYPED_ARRAY_SUPPORT=e.TYPED_ARRAY_SUPPORT===void 0?function(){try{var e=new Uint8Array(1);return e.__proto__={__proto__:Uint8Array.prototype,foo:function(){return 42}},42===e.foo()&&'function'==typeof e.subarray&&0===e.subarray(1,1).byteLength}catch(t){return!1}}():e.TYPED_ARRAY_SUPPORT,t.kMaxLength=o(),l.poolSize=8192,l._augment=function(e){return e.__proto__=l.prototype,e},l.from=function(e,t,i){return u(null,e,t,i)},l.TYPED_ARRAY_SUPPORT&&(l.prototype.__proto__=Uint8Array.prototype,l.__proto__=Uint8Array,'undefined'!=typeof Symbol&&Symbol.species&&l[Symbol.species]===l&&Object.defineProperty(l,Symbol.species,{value:null,configurable:!0})),l.alloc=function(e,t,i){return d(null,e,t,i)},l.allocUnsafe=function(e){return f(null,e)},l.allocUnsafeSlow=function(e){return f(null,e)},l.isBuffer=function(e){return!!(null!=e&&e._isBuffer)},l.compare=function(e,t){if(!l.isBuffer(e)||!l.isBuffer(t))throw new TypeError('Arguments must be Buffers');if(e===t)return 0;for(var r=e.length,n=t.length,o=0,i=s(r,n);oi&&(e+=' ... ')),''},l.prototype.compare=function(e,t,r,n,o){if(!l.isBuffer(e))throw new TypeError('Argument must be a Buffer');if(void 0===t&&(t=0),void 0===r&&(r=e?e.length:0),void 0===n&&(n=0),void 0===o&&(o=this.length),0>t||r>e.length||0>n||o>this.length)throw new RangeError('out of range index');if(n>=o&&t>=r)return 0;if(n>=o)return-1;if(t>=r)return 1;if(t>>>=0,r>>>=0,n>>>=0,o>>>=0,this===e)return 0;for(var a=o-n,u=r-t,c=s(a,u),d=this.slice(n,o),f=e.slice(t,r),p=0;pn)&&(i=n),0i||0>t)||t>this.length)throw new RangeError('Attempt to write outside buffer bounds');r||(r='utf8');for(var s=!1;;)switch(r){case'hex':return z(this,e,t,i);case'utf8':case'utf-8':return A(this,e,t,i);case'ascii':return E(this,e,t,i);case'latin1':case'binary':return w(this,e,t,i);case'base64':return L(this,e,t,i);case'ucs2':case'ucs-2':case'utf16le':case'utf-16le':return S(this,e,t,i);default:if(s)throw new TypeError('Unknown encoding: '+r);r=(''+r).toLowerCase(),s=!0;}},l.prototype.toJSON=function(){return{type:'Buffer',data:Array.prototype.slice.call(this._arr||this,0)}};var ie=4096;l.prototype.slice=function(e,t){var r=this.length;e=~~e,t=t===void 0?r:~~t,0>e?(e+=r,0>e&&(e=0)):e>r&&(e=r),0>t?(t+=r,0>t&&(t=0)):t>r&&(t=r),t=o&&(s-=n(2,8*t)),s},l.prototype.readIntBE=function(e,t,r){e|=0,t|=0,r||O(e,t,this.length);for(var s=t,i=1,o=this[e+--s];0=i&&(o-=n(2,8*t)),o},l.prototype.readInt8=function(e,t){return t||O(e,1,this.length),128&this[e]?-1*(255-this[e]+1):this[e]},l.prototype.readInt16LE=function(e,t){t||O(e,2,this.length);var i=this[e]|this[e+1]<<8;return 32768&i?4294901760|i:i},l.prototype.readInt16BE=function(e,t){t||O(e,2,this.length);var i=this[e+1]|this[e]<<8;return 32768&i?4294901760|i:i},l.prototype.readInt32LE=function(e,t){return t||O(e,4,this.length),this[e]|this[e+1]<<8|this[e+2]<<16|this[e+3]<<24},l.prototype.readInt32BE=function(e,t){return t||O(e,4,this.length),this[e]<<24|this[e+1]<<16|this[e+2]<<8|this[e+3]},l.prototype.readFloatLE=function(e,t){return t||O(e,4,this.length),ee.read(this,e,!0,23,4)},l.prototype.readFloatBE=function(e,t){return t||O(e,4,this.length),ee.read(this,e,!1,23,4)},l.prototype.readDoubleLE=function(e,t){return t||O(e,8,this.length),ee.read(this,e,!0,52,8)},l.prototype.readDoubleBE=function(e,t){return t||O(e,8,this.length),ee.read(this,e,!1,52,8)},l.prototype.writeUIntLE=function(e,t,r,s){if(e=+e,t|=0,r|=0,!s){var o=n(2,8*r)-1;D(this,e,t,r,o,0)}var a=1,l=0;for(this[t]=255&e;++l>>8):F(this,e,t,!0),t+2},l.prototype.writeUInt16BE=function(e,t,i){return e=+e,t|=0,i||D(this,e,t,2,65535,0),l.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):F(this,e,t,!1),t+2},l.prototype.writeUInt32LE=function(e,t,i){return e=+e,t|=0,i||D(this,e,t,4,4294967295,0),l.TYPED_ARRAY_SUPPORT?(this[t+3]=e>>>24,this[t+2]=e>>>16,this[t+1]=e>>>8,this[t]=255&e):R(this,e,t,!0),t+4},l.prototype.writeUInt32BE=function(e,t,i){return e=+e,t|=0,i||D(this,e,t,4,4294967295,0),l.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):R(this,e,t,!1),t+4},l.prototype.writeIntLE=function(e,t,r,s){if(e=+e,t|=0,!s){var o=n(2,8*r-1);D(this,e,t,r,o-1,-o)}var a=0,i=1,l=0;for(this[t]=255&e;++ae&&0==l&&0!==this[t+a-1]&&(l=1),this[t+a]=255&(e/i>>0)-l;return t+r},l.prototype.writeIntBE=function(e,t,r,s){if(e=+e,t|=0,!s){var o=n(2,8*r-1);D(this,e,t,r,o-1,-o)}var a=r-1,i=1,l=0;for(this[t+a]=255&e;0<=--a&&(i*=256);)0>e&&0==l&&0!==this[t+a+1]&&(l=1),this[t+a]=255&(e/i>>0)-l;return t+r},l.prototype.writeInt8=function(e,t,i){return e=+e,t|=0,i||D(this,e,t,1,127,-128),l.TYPED_ARRAY_SUPPORT||(e=r(e)),0>e&&(e=255+e+1),this[t]=255&e,t+1},l.prototype.writeInt16LE=function(e,t,i){return e=+e,t|=0,i||D(this,e,t,2,32767,-32768),l.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8):F(this,e,t,!0),t+2},l.prototype.writeInt16BE=function(e,t,i){return e=+e,t|=0,i||D(this,e,t,2,32767,-32768),l.TYPED_ARRAY_SUPPORT?(this[t]=e>>>8,this[t+1]=255&e):F(this,e,t,!1),t+2},l.prototype.writeInt32LE=function(e,t,i){return e=+e,t|=0,i||D(this,e,t,4,2147483647,-2147483648),l.TYPED_ARRAY_SUPPORT?(this[t]=255&e,this[t+1]=e>>>8,this[t+2]=e>>>16,this[t+3]=e>>>24):R(this,e,t,!0),t+4},l.prototype.writeInt32BE=function(e,t,i){return e=+e,t|=0,i||D(this,e,t,4,2147483647,-2147483648),0>e&&(e=4294967295+e+1),l.TYPED_ARRAY_SUPPORT?(this[t]=e>>>24,this[t+1]=e>>>16,this[t+2]=e>>>8,this[t+3]=255&e):R(this,e,t,!1),t+4},l.prototype.writeFloatLE=function(e,t,i){return B(this,e,t,!0,i)},l.prototype.writeFloatBE=function(e,t,i){return B(this,e,t,!1,i)},l.prototype.writeDoubleLE=function(e,t,i){return j(this,e,t,!0,i)},l.prototype.writeDoubleBE=function(e,t,i){return j(this,e,t,!1,i)},l.prototype.copy=function(e,t,r,n){if(r||(r=0),n||0===n||(n=this.length),t>=e.length&&(t=e.length),t||(t=0),0t)throw new RangeError('targetStart out of bounds');if(0>r||r>=this.length)throw new RangeError('sourceStart out of bounds');if(0>n)throw new RangeError('sourceEnd out of bounds');n>this.length&&(n=this.length),e.length-ti||!l.TYPED_ARRAY_SUPPORT)for(s=0;ss&&(e=s)}if(void 0!==n&&'string'!=typeof n)throw new TypeError('encoding must be a string');if('string'==typeof n&&!l.isEncoding(n))throw new TypeError('Unknown encoding: '+n)}else'number'==typeof e&&(e&=255);if(0>t||this.length>>=0,r=r===void 0?this.length:r>>>0,e||(e=0);var o;if('number'==typeof e)for(o=t;o>16,o[l++]=255&n>>8,o[l++]=255&n;return 2===s?(n=u[e.charCodeAt(t)]<<2|u[e.charCodeAt(t+1)]>>4,o[l++]=255&n):1===s&&(n=u[e.charCodeAt(t)]<<10|u[e.charCodeAt(t+1)]<<4|u[e.charCodeAt(t+2)]>>2,o[l++]=255&n>>8,o[l++]=255&n),o}function s(e){return l[63&e>>18]+l[63&e>>12]+l[63&e>>6]+l[63&e]}function o(e,t,r){for(var n,o=[],a=t;ai?i:c+u));return 1==n?(t=e[r-1],s+=l[t>>2],s+=l[63&t<<4],s+='=='):2==n&&(t=(e[r-2]<<8)+e[r-1],s+=l[t>>10],s+=l[63&t>>4],s+=l[63&t<<2],s+='='),a.push(s),a.join('')}t.byteLength=function(e){return 3*e.length/4-r(e)},t.toByteArray=n,t.fromByteArray=a;for(var l=[],u=[],c='undefined'==typeof Uint8Array?Array:Uint8Array,d='ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',f=0,i=d.length;f>1,h=-7,m=o?l-1:0,i=o?-1:1,d=t[r+m];for(m+=i,u=d&(1<<-h)-1,d>>=-h,h+=c;0>=-h,h+=a;0>1,b=23===u?5.960464477539063e-8-6.617444900424222e-24:0,_=l?0:f-1,i=l?1:-1,d=0>o||0===o&&0>1/o?1:0;for(o=Math.abs(o),isNaN(o)||o===Infinity?(h=isNaN(o)?1:0,p=g):(p=r(Math.log(o)/Math.LN2),1>o*(m=n(2,-p))&&(p--,m*=2),o+=1<=p+y?b/m:b*n(2,1-y),2<=o*m&&(p++,m/=2),p+y>=g?(h=0,p=g):1<=p+y?(h=(o*m-1)*n(2,u),p+=y):(h=o*n(2,y-1)*n(2,u),p=0));8<=u;t[a+_]=255&h,_+=i,h/=256,u-=8);for(p=p<o&&(i--,o+=1e9)),[i,o]};var n=i.performance||{},s=n.now||n.mozNow||n.msNow||n.oNow||n.webkitNow||function(){return new Date().getTime()}}).call(t,i(0),i(2))}])});