push browser build
Diff
src/lib.js | 657 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 657 insertions(+)
@@ -1,0 +1,657 @@
(function ($hx_exports, $global) { "use strict";
$hx_exports["eci"] = $hx_exports["eci"] || {};
var $estr = function() { return js_Boot.__string_rec(this,''); },$hxEnums = $hxEnums || {},$_;
function $extend(from, fields) {
var proto = Object.create(from);
for (var name in fields) proto[name] = fields[name];
if( fields.toString !== Object.prototype.toString ) proto.toString = fields.toString;
return proto;
}
var HxOverrides = function() { };
HxOverrides.__name__ = true;
HxOverrides.cca = function(s,index) {
var x = s.charCodeAt(index);
if(x != x) {
return undefined;
}
return x;
};
HxOverrides.substr = function(s,pos,len) {
if(len == null) {
len = s.length;
} else if(len < 0) {
if(pos == 0) {
len = s.length + len;
} else {
return "";
}
}
return s.substr(pos,len);
};
HxOverrides.now = function() {
return Date.now();
};
Math.__name__ = true;
var haxe_crypto_Aes = function(key,iv) {
haxe_crypto_Aes.initTable();
if(key != null) {
this.init(key,iv);
}
};
haxe_crypto_Aes.__name__ = true;
haxe_crypto_Aes.initTable = function() {
haxe_crypto_Aes.SBOX = new Array(256);
haxe_crypto_Aes.RSBOX = new Array(256);
haxe_crypto_Aes.SUB_BYTES_MIX_COLUMN_0 = new Array(256);
haxe_crypto_Aes.SUB_BYTES_MIX_COLUMN_1 = new Array(256);
haxe_crypto_Aes.SUB_BYTES_MIX_COLUMN_2 = new Array(256);
haxe_crypto_Aes.SUB_BYTES_MIX_COLUMN_3 = new Array(256);
haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_0 = new Array(256);
haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_1 = new Array(256);
haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_2 = new Array(256);
haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_3 = new Array(256);
haxe_crypto_Aes.RCON = new Array(11);
var d = new Array(256);
var _g = 0;
while(_g < 256) {
var i = _g++;
if(i < 128) {
d[i] = i << 1;
} else {
d[i] = i << 1 ^ 283;
}
}
var x = 0;
var xi = 0;
var _g = 0;
while(_g < 256) {
var i = _g++;
var sx = xi ^ xi << 1 ^ xi << 2 ^ xi << 3 ^ xi << 4;
sx = sx >>> 8 ^ sx & 255 ^ 99;
haxe_crypto_Aes.SBOX[x] = sx;
haxe_crypto_Aes.RSBOX[sx] = x;
var x2 = d[x];
var x4 = d[x2];
var x8 = d[x4];
var t = d[sx] * 257 ^ sx * 16843008;
haxe_crypto_Aes.SUB_BYTES_MIX_COLUMN_0[x] = t << 24 | t >>> 8;
haxe_crypto_Aes.SUB_BYTES_MIX_COLUMN_1[x] = t << 16 | t >>> 16;
haxe_crypto_Aes.SUB_BYTES_MIX_COLUMN_2[x] = t << 8 | t >>> 24;
haxe_crypto_Aes.SUB_BYTES_MIX_COLUMN_3[x] = t;
t = x8 * 16843009 ^ x4 * 65537 ^ x2 * 257 ^ x * 16843008;
haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_0[sx] = t << 24 | t >>> 8;
haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_1[sx] = t << 16 | t >>> 16;
haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_2[sx] = t << 8 | t >>> 24;
haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_3[sx] = t;
if(x == 0) {
xi = 1;
x = xi;
} else {
x = x2 ^ d[d[d[x8 ^ x2]]];
xi ^= d[d[xi]];
}
}
haxe_crypto_Aes.RCON[0] = 0;
haxe_crypto_Aes.RCON[1] = 1;
haxe_crypto_Aes.RCON[2] = 2;
haxe_crypto_Aes.RCON[3] = 4;
haxe_crypto_Aes.RCON[4] = 8;
haxe_crypto_Aes.RCON[5] = 16;
haxe_crypto_Aes.RCON[6] = 32;
haxe_crypto_Aes.RCON[7] = 64;
haxe_crypto_Aes.RCON[8] = 128;
haxe_crypto_Aes.RCON[9] = 27;
haxe_crypto_Aes.RCON[10] = 54;
};
haxe_crypto_Aes.prototype = {
set_iv: function(vector) {
this.iv = vector;
if(this.iv == null) {
this.iv = new haxe_io_Bytes(new ArrayBuffer(16));
this.iv.fill(0,16,0);
}
return this.iv;
}
,init: function(key,iv) {
this.Nk = key.length >> 2;
this.Nr = this.Nk + 6;
this.keyRows = (this.Nr + 1) * 4;
this.state = new Array(this.Nk);
this.set_iv(iv);
this.keyExpansion(key);
}
,keyExpansion: function(key) {
this.roundKey = new Array(this.keyRows);
var _g = 0;
var _g1 = this.keyRows;
while(_g < _g1) {
var ksRow = _g++;
if(ksRow < this.Nk) {
this.roundKey[ksRow] = this.bytesToInt32(key,ksRow << 2);
} else {
var t = this.roundKey[ksRow - 1];
if(ksRow % this.Nk == 0) {
t = t << 8 | t >>> 24;
t = haxe_crypto_Aes.SBOX[t >>> 24] << 24 | haxe_crypto_Aes.SBOX[t >>> 16 & 255] << 16 | haxe_crypto_Aes.SBOX[t >>> 8 & 255] << 8 | haxe_crypto_Aes.SBOX[t & 255];
t ^= haxe_crypto_Aes.RCON[Math.floor(ksRow / this.Nk) | 0] << 24;
} else if(this.Nk > 6 && ksRow % this.Nk == 4) {
t = haxe_crypto_Aes.SBOX[t >>> 24] << 24 | haxe_crypto_Aes.SBOX[t >>> 16 & 255] << 16 | haxe_crypto_Aes.SBOX[t >>> 8 & 255] << 8 | haxe_crypto_Aes.SBOX[t & 255];
}
this.roundKey[ksRow] = this.roundKey[ksRow - this.Nk] ^ t;
}
}
this.rRoundKey = new Array(this.keyRows);
var keyRow;
var t;
var _g = 0;
var _g1 = this.keyRows;
while(_g < _g1) {
var i = _g++;
keyRow = this.keyRows - i;
if(i % 4 != 0) {
t = this.roundKey[keyRow];
} else {
t = this.roundKey[keyRow - 4];
}
if(i < 4 || keyRow <= 4) {
this.rRoundKey[i] = t;
} else {
this.rRoundKey[i] = haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_0[haxe_crypto_Aes.SBOX[t >>> 24]] ^ haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_1[haxe_crypto_Aes.SBOX[t >>> 16 & 255]] ^ haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_2[haxe_crypto_Aes.SBOX[t >>> 8 & 255]] ^ haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_3[haxe_crypto_Aes.SBOX[t & 255]];
}
}
}
,decryptBlock: function(src,srcIndex,dst,dstIndex) {
if(dstIndex == null) {
dstIndex = 0;
}
this.state[0] = this.bytesToInt32(src,srcIndex);
this.state[1] = this.bytesToInt32(src,srcIndex + 4);
this.state[2] = this.bytesToInt32(src,srcIndex + 8);
this.state[3] = this.bytesToInt32(src,srcIndex + 12);
var t = this.state[1];
this.state[1] = this.state[3];
this.state[3] = t;
this.generateBlock(this.rRoundKey,haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_0,haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_1,haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_2,haxe_crypto_Aes.RSUB_BYTES_MIX_COLUMN_3,haxe_crypto_Aes.RSBOX);
t = this.state[1];
this.state[1] = this.state[3];
this.state[3] = t;
this.int32ToBytes(this.state[0],dst,dstIndex);
this.int32ToBytes(this.state[1],dst,dstIndex + 4);
this.int32ToBytes(this.state[2],dst,dstIndex + 8);
this.int32ToBytes(this.state[3],dst,dstIndex + 12);
}
,generateBlock: function(keySchedule,SUB_MIX_0,SUB_MIX_1,SUB_MIX_2,SUB_MIX_3,SBOX) {
var state0 = this.state[0] ^ keySchedule[0];
var state1 = this.state[1] ^ keySchedule[1];
var state2 = this.state[2] ^ keySchedule[2];
var state3 = this.state[3] ^ keySchedule[3];
var ksRow = 4;
var tmp0;
var tmp1;
var tmp2;
var tmp3;
var _g = 1;
var _g1 = this.Nr;
while(_g < _g1) {
var round = _g++;
tmp0 = SUB_MIX_0[state0 >>> 24] ^ SUB_MIX_1[state1 >>> 16 & 255] ^ SUB_MIX_2[state2 >>> 8 & 255] ^ SUB_MIX_3[state3 & 255] ^ keySchedule[ksRow++];
tmp1 = SUB_MIX_0[state1 >>> 24] ^ SUB_MIX_1[state2 >>> 16 & 255] ^ SUB_MIX_2[state3 >>> 8 & 255] ^ SUB_MIX_3[state0 & 255] ^ keySchedule[ksRow++];
tmp2 = SUB_MIX_0[state2 >>> 24] ^ SUB_MIX_1[state3 >>> 16 & 255] ^ SUB_MIX_2[state0 >>> 8 & 255] ^ SUB_MIX_3[state1 & 255] ^ keySchedule[ksRow++];
tmp3 = SUB_MIX_0[state3 >>> 24] ^ SUB_MIX_1[state0 >>> 16 & 255] ^ SUB_MIX_2[state1 >>> 8 & 255] ^ SUB_MIX_3[state2 & 255] ^ keySchedule[ksRow++];
state0 = tmp0;
state1 = tmp1;
state2 = tmp2;
state3 = tmp3;
}
tmp0 = (SBOX[state0 >>> 24] << 24 | SBOX[state1 >>> 16 & 255] << 16 | SBOX[state2 >>> 8 & 255] << 8 | SBOX[state3 & 255]) ^ keySchedule[ksRow++];
tmp1 = (SBOX[state1 >>> 24] << 24 | SBOX[state2 >>> 16 & 255] << 16 | SBOX[state3 >>> 8 & 255] << 8 | SBOX[state0 & 255]) ^ keySchedule[ksRow++];
tmp2 = (SBOX[state2 >>> 24] << 24 | SBOX[state3 >>> 16 & 255] << 16 | SBOX[state0 >>> 8 & 255] << 8 | SBOX[state1 & 255]) ^ keySchedule[ksRow++];
tmp3 = (SBOX[state3 >>> 24] << 24 | SBOX[state0 >>> 16 & 255] << 16 | SBOX[state1 >>> 8 & 255] << 8 | SBOX[state2 & 255]) ^ keySchedule[ksRow++];
this.state[0] = tmp0;
this.state[1] = tmp1;
this.state[2] = tmp2;
this.state[3] = tmp3;
}
,bytesToInt32: function(bs,off) {
var n = (bs.b[off] & 255) << 24;
n |= (bs.b[++off] & 255) << 16;
n |= (bs.b[++off] & 255) << 8;
n |= bs.b[++off] & 255;
return n;
}
,int32ToBytes: function(n,bs,off) {
bs.b[off] = n >> 24;
bs.b[++off] = n >> 16;
bs.b[++off] = n >> 8;
bs.b[++off] = n;
}
};
var eci_Crypto = function(key,iv) {
haxe_crypto_Aes.call(this,key,iv);
};
eci_Crypto.__name__ = true;
eci_Crypto.__super__ = haxe_crypto_Aes;
eci_Crypto.prototype = $extend(haxe_crypto_Aes.prototype,{
decrypt: function(cipherMode,data,padding) {
if(padding == null) {
padding = "PKCS7";
}
var out = data.sub(0,data.length);
haxe_crypto_mode_CBC.decrypt(out,this.iv,16,$bind(this,this.decryptBlock));
return haxe_crypto_padding_PKCS7.unpad(out);
}
});
var eci_EpicQR = $hx_exports["eci"]["EpicQR"] = function() { };
eci_EpicQR.__name__ = true;
eci_EpicQR.decode = function(input) {
var cipherText = haxe_crypto_Base64.decode(input);
var c = new eci_Crypto();
var key = haxe_io_Bytes.ofString("X_4k$uq23FSwI.qT");
var iv = haxe_io_Bytes.ofString("H76$suq23_po(8sD");
c.init(key,iv);
var jsonString = c.decrypt("cbc",cipherText).toString();
var _d = JSON.parse(jsonString);
return new eci_Result(_d.epic_no,_d.unique_generated_id);
};
var eci_Result = function(epic,id) {
this.epic = epic;
this.id = id;
};
eci_Result.__name__ = true;
var haxe_Exception = function(message,previous,native) {
Error.call(this,message);
this.message = message;
this.__previousException = previous;
this.__nativeException = native != null ? native : this;
};
haxe_Exception.__name__ = true;
haxe_Exception.thrown = function(value) {
if(((value) instanceof haxe_Exception)) {
return value.get_native();
} else if(((value) instanceof Error)) {
return value;
} else {
var e = new haxe_ValueException(value);
return e;
}
};
haxe_Exception.__super__ = Error;
haxe_Exception.prototype = $extend(Error.prototype,{
get_native: function() {
return this.__nativeException;
}
});
var haxe_ValueException = function(value,previous,native) {
haxe_Exception.call(this,String(value),previous,native);
this.value = value;
};
haxe_ValueException.__name__ = true;
haxe_ValueException.__super__ = haxe_Exception;
haxe_ValueException.prototype = $extend(haxe_Exception.prototype,{
});
var haxe_io_Bytes = function(data) {
this.length = data.byteLength;
this.b = new Uint8Array(data);
this.b.bufferValue = data;
data.hxBytes = this;
data.bytes = this.b;
};
haxe_io_Bytes.__name__ = true;
haxe_io_Bytes.ofString = function(s,encoding) {
if(encoding == haxe_io_Encoding.RawNative) {
var buf = new Uint8Array(s.length << 1);
var _g = 0;
var _g1 = s.length;
while(_g < _g1) {
var i = _g++;
var c = s.charCodeAt(i);
buf[i << 1] = c & 255;
buf[i << 1 | 1] = c >> 8;
}
return new haxe_io_Bytes(buf.buffer);
}
var a = [];
var i = 0;
while(i < s.length) {
var c = s.charCodeAt(i++);
if(55296 <= c && c <= 56319) {
c = c - 55232 << 10 | s.charCodeAt(i++) & 1023;
}
if(c <= 127) {
a.push(c);
} else if(c <= 2047) {
a.push(192 | c >> 6);
a.push(128 | c & 63);
} else if(c <= 65535) {
a.push(224 | c >> 12);
a.push(128 | c >> 6 & 63);
a.push(128 | c & 63);
} else {
a.push(240 | c >> 18);
a.push(128 | c >> 12 & 63);
a.push(128 | c >> 6 & 63);
a.push(128 | c & 63);
}
}
return new haxe_io_Bytes(new Uint8Array(a).buffer);
};
haxe_io_Bytes.prototype = {
fill: function(pos,len,value) {
var _g = 0;
var _g1 = len;
while(_g < _g1) {
var i = _g++;
this.b[pos++] = value;
}
}
,sub: function(pos,len) {
if(pos < 0 || len < 0 || pos + len > this.length) {
throw haxe_Exception.thrown(haxe_io_Error.OutsideBounds);
}
return new haxe_io_Bytes(this.b.buffer.slice(pos + this.b.byteOffset,pos + this.b.byteOffset + len));
}
,getString: function(pos,len,encoding) {
if(pos < 0 || len < 0 || pos + len > this.length) {
throw haxe_Exception.thrown(haxe_io_Error.OutsideBounds);
}
if(encoding == null) {
encoding = haxe_io_Encoding.UTF8;
}
var s = "";
var b = this.b;
var i = pos;
var max = pos + len;
switch(encoding._hx_index) {
case 0:
var debug = pos > 0;
while(i < max) {
var c = b[i++];
if(c < 128) {
if(c == 0) {
break;
}
s += String.fromCodePoint(c);
} else if(c < 224) {
var code = (c & 63) << 6 | b[i++] & 127;
s += String.fromCodePoint(code);
} else if(c < 240) {
var c2 = b[i++];
var code1 = (c & 31) << 12 | (c2 & 127) << 6 | b[i++] & 127;
s += String.fromCodePoint(code1);
} else {
var c21 = b[i++];
var c3 = b[i++];
var u = (c & 15) << 18 | (c21 & 127) << 12 | (c3 & 127) << 6 | b[i++] & 127;
s += String.fromCodePoint(u);
}
}
break;
case 1:
while(i < max) {
var c = b[i++] | b[i++] << 8;
s += String.fromCodePoint(c);
}
break;
}
return s;
}
,toString: function() {
return this.getString(0,this.length);
}
};
var haxe_io_Encoding = $hxEnums["haxe.io.Encoding"] = { __ename__:true,__constructs__:null
,UTF8: {_hx_name:"UTF8",_hx_index:0,__enum__:"haxe.io.Encoding",toString:$estr}
,RawNative: {_hx_name:"RawNative",_hx_index:1,__enum__:"haxe.io.Encoding",toString:$estr}
};
haxe_io_Encoding.__constructs__ = [haxe_io_Encoding.UTF8,haxe_io_Encoding.RawNative];
var haxe_crypto_Base64 = function() { };
haxe_crypto_Base64.__name__ = true;
haxe_crypto_Base64.decode = function(str,complement) {
if(complement == null) {
complement = true;
}
if(complement) {
while(HxOverrides.cca(str,str.length - 1) == 61) str = HxOverrides.substr(str,0,-1);
}
return new haxe_crypto_BaseCode(haxe_crypto_Base64.BYTES).decodeBytes(haxe_io_Bytes.ofString(str));
};
var haxe_crypto_BaseCode = function(base) {
var len = base.length;
var nbits = 1;
while(len > 1 << nbits) ++nbits;
if(nbits > 8 || len != 1 << nbits) {
throw haxe_Exception.thrown("BaseCode : base length must be a power of two.");
}
this.base = base;
this.nbits = nbits;
};
haxe_crypto_BaseCode.__name__ = true;
haxe_crypto_BaseCode.prototype = {
initTable: function() {
var tbl = [];
var _g = 0;
while(_g < 256) {
var i = _g++;
tbl[i] = -1;
}
var _g = 0;
var _g1 = this.base.length;
while(_g < _g1) {
var i = _g++;
tbl[this.base.b[i]] = i;
}
this.tbl = tbl;
}
,decodeBytes: function(b) {
var nbits = this.nbits;
var base = this.base;
if(this.tbl == null) {
this.initTable();
}
var tbl = this.tbl;
var size = b.length * nbits >> 3;
var out = new haxe_io_Bytes(new ArrayBuffer(size));
var buf = 0;
var curbits = 0;
var pin = 0;
var pout = 0;
while(pout < size) {
while(curbits < 8) {
curbits += nbits;
buf <<= nbits;
var i = tbl[b.b[pin++]];
if(i == -1) {
throw haxe_Exception.thrown("BaseCode : invalid encoded char");
}
buf |= i;
}
curbits -= 8;
out.b[pout++] = buf >> curbits & 255;
}
return out;
}
};
var haxe_crypto_mode_CBC = function() { };
haxe_crypto_mode_CBC.__name__ = true;
haxe_crypto_mode_CBC.decrypt = function(src,iv,blockSize,decryptBlock) {
var vpos = src.length - blockSize;
var i = src.length;
while(i > 0) {
i -= blockSize;
vpos -= blockSize;
decryptBlock(src,i,src,i);
if(vpos < 0) {
var _g = 0;
var _g1 = blockSize;
while(_g < _g1) {
var j = _g++;
src.b[j] ^= iv.b[j];
}
} else {
var _g2 = 0;
var _g3 = blockSize;
while(_g2 < _g3) {
var j1 = _g2++;
src.b[i + j1] ^= src.b[vpos + j1];
}
}
}
};
var haxe_crypto_padding_PKCS7 = function() { };
haxe_crypto_padding_PKCS7.__name__ = true;
haxe_crypto_padding_PKCS7.unpad = function(encrypt) {
var padding = encrypt.b[encrypt.length - 1];
if(padding > encrypt.length) {
throw haxe_Exception.thrown("Cannot remove " + padding + " bytes, because message is " + encrypt.length + " bytes");
}
var block = encrypt.length - padding;
var _g = block;
var _g1 = encrypt.length;
while(_g < _g1) {
var i = _g++;
if(encrypt.b[i] != padding) {
throw haxe_Exception.thrown("Invalid padding value. Got " + encrypt.b[i] + ", expected " + padding + " at position " + i);
}
}
return encrypt.sub(0,block);
};
var haxe_io_Error = $hxEnums["haxe.io.Error"] = { __ename__:true,__constructs__:null
,Blocked: {_hx_name:"Blocked",_hx_index:0,__enum__:"haxe.io.Error",toString:$estr}
,Overflow: {_hx_name:"Overflow",_hx_index:1,__enum__:"haxe.io.Error",toString:$estr}
,OutsideBounds: {_hx_name:"OutsideBounds",_hx_index:2,__enum__:"haxe.io.Error",toString:$estr}
,Custom: ($_=function(e) { return {_hx_index:3,e:e,__enum__:"haxe.io.Error",toString:$estr}; },$_._hx_name="Custom",$_.__params__ = ["e"],$_)
};
haxe_io_Error.__constructs__ = [haxe_io_Error.Blocked,haxe_io_Error.Overflow,haxe_io_Error.OutsideBounds,haxe_io_Error.Custom];
var haxe_iterators_ArrayIterator = function(array) {
this.current = 0;
this.array = array;
};
haxe_iterators_ArrayIterator.__name__ = true;
haxe_iterators_ArrayIterator.prototype = {
hasNext: function() {
return this.current < this.array.length;
}
,next: function() {
return this.array[this.current++];
}
};
var js_Boot = function() { };
js_Boot.__name__ = true;
js_Boot.__string_rec = function(o,s) {
if(o == null) {
return "null";
}
if(s.length >= 5) {
return "<...>";
}
var t = typeof(o);
if(t == "function" && (o.__name__ || o.__ename__)) {
t = "object";
}
switch(t) {
case "function":
return "<function>";
case "object":
if(o.__enum__) {
var e = $hxEnums[o.__enum__];
var con = e.__constructs__[o._hx_index];
var n = con._hx_name;
if(con.__params__) {
s = s + "\t";
return n + "(" + ((function($this) {
var $r;
var _g = [];
{
var _g1 = 0;
var _g2 = con.__params__;
while(true) {
if(!(_g1 < _g2.length)) {
break;
}
var p = _g2[_g1];
_g1 = _g1 + 1;
_g.push(js_Boot.__string_rec(o[p],s));
}
}
$r = _g;
return $r;
}(this))).join(",") + ")";
} else {
return n;
}
}
if(((o) instanceof Array)) {
var str = "[";
s += "\t";
var _g = 0;
var _g1 = o.length;
while(_g < _g1) {
var i = _g++;
str += (i > 0 ? "," : "") + js_Boot.__string_rec(o[i],s);
}
str += "]";
return str;
}
var tostr;
try {
tostr = o.toString;
} catch( _g ) {
return "???";
}
if(tostr != null && tostr != Object.toString && typeof(tostr) == "function") {
var s2 = o.toString();
if(s2 != "[object Object]") {
return s2;
}
}
var str = "{\n";
s += "\t";
var hasp = o.hasOwnProperty != null;
var k = null;
for( k in o ) {
if(hasp && !o.hasOwnProperty(k)) {
continue;
}
if(k == "prototype" || k == "__class__" || k == "__super__" || k == "__interfaces__" || k == "__properties__") {
continue;
}
if(str.length != 2) {
str += ", \n";
}
str += s + k + " : " + js_Boot.__string_rec(o[k],s);
}
s = s.substring(1);
str += "\n" + s + "}";
return str;
case "string":
return o;
default:
return String(o);
}
};
var js_lib__$ArrayBuffer_ArrayBufferCompat = function() { };
js_lib__$ArrayBuffer_ArrayBufferCompat.__name__ = true;
js_lib__$ArrayBuffer_ArrayBufferCompat.sliceImpl = function(begin,end) {
var u = new Uint8Array(this,begin,end == null ? null : end - begin);
var resultArray = new Uint8Array(u.byteLength);
resultArray.set(u);
return resultArray.buffer;
};
function $bind(o,m) { if( m == null ) return null; if( m.__id__ == null ) m.__id__ = $global.$haxeUID++; var f; if( o.hx__closures__ == null ) o.hx__closures__ = {}; else f = o.hx__closures__[m.__id__]; if( f == null ) { f = m.bind(o); o.hx__closures__[m.__id__] = f; } return f; }
$global.$haxeUID |= 0;
if(typeof(performance) != "undefined" ? typeof(performance.now) == "function" : false) {
HxOverrides.now = performance.now.bind(performance);
}
if( String.fromCodePoint == null ) String.fromCodePoint = function(c) { return c < 0x10000 ? String.fromCharCode(c) : String.fromCharCode((c>>10)+0xD7C0)+String.fromCharCode((c&0x3FF)+0xDC00); }
String.__name__ = true;
Array.__name__ = true;
js_Boot.__toStr = ({ }).toString;
if(ArrayBuffer.prototype.slice == null) {
ArrayBuffer.prototype.slice = js_lib__$ArrayBuffer_ArrayBufferCompat.sliceImpl;
}
eci_EpicQR.IV = "H76$suq23_po(8sD";
eci_EpicQR.KEY = "X_4k$uq23FSwI.qT";
haxe_crypto_Base64.CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
haxe_crypto_Base64.BYTES = haxe_io_Bytes.ofString(haxe_crypto_Base64.CHARS);
})(typeof exports != "undefined" ? exports : typeof window != "undefined" ? window : typeof self != "undefined" ? self : this, typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : this);