☰

APM

Standard for hooking into the client -> server connection in arras.io

  1. // ==UserScript==
  2. // @name         APM
  3. // @version      1.0.2
  4. // @author       ABC & Ray Adams
  5. // @namespace    github.com/ABCxFF
  6. // @description  Standard for hooking into the client -> server connection in arras.io
  7. // @match        *://arras.io/
  8. // @match        *://arras.netlify.app/
  9. // @grant        none
  10. // @run-at       document-start
  11. // @license      GPL-3.0
  12. // ==/UserScript==
  13.  
  14. /*
  15.  * Copyright (C) 2021  ABC & Ray Adams
  16.  * Licensed under GNU General Public License v3.0
  17.  */
  18.  
  19. const arras = (() => {
  20.     const u32 = new Uint32Array(1);
  21.     const u16 = new Uint16Array(1);
  22.     const c16 = new Uint8Array(u16.buffer);
  23.     const c32 = new Uint8Array(u32.buffer);
  24.     const f32 = new Float32Array(u32.buffer);
  25.  
  26.     Array.prototype.remove = function (index) {
  27.         if (index === this.length - 1) return this.pop();
  28.         this[index] = this.pop();
  29.     };
  30.  
  31.     function encode(message) {
  32.         let headers = []
  33.         let headerCodes = []
  34.         let contentSize = 0
  35.         let lastTypeCode = 0b1111
  36.         let repeatTypeCount = 0
  37.         for (let block of message) {
  38.             let typeCode = 0
  39.             if (block === 0 || block === false) {
  40.                 typeCode = 0b0000
  41.             } else if (block === 1 || block === true) {
  42.                 typeCode = 0b0001
  43.             } else if (typeof block === 'number') {
  44.                 if (!Number.isInteger(block) || block < -0x100000000 || block >= 0x100000000) {
  45.                     typeCode = 0b1000
  46.                     contentSize += 4
  47.                 } else if (block >= 0) {
  48.                     if (block < 0x100) {
  49.                         typeCode = 0b0010
  50.                         contentSize++
  51.                     } else if (block < 0x10000) {
  52.                         typeCode = 0b0100
  53.                         contentSize += 2
  54.                     } else if (block < 0x100000000) {
  55.                         typeCode = 0b0110
  56.                         contentSize += 4
  57.                     }
  58.                 } else {
  59.                     if (block >= -0x100) {
  60.                         typeCode = 0b0011
  61.                         contentSize++
  62.                     } else if (block >= -0x10000) {
  63.                         typeCode = 0b0101
  64.                         contentSize += 2
  65.                     } else if (block >= -0x100000000) {
  66.                         typeCode = 0b0111
  67.                         contentSize += 4
  68.                     }
  69.                 }
  70.             } else if (typeof block === 'string') {
  71.                 let hasUnicode = false
  72.                 for (let i = 0; i < block.length; i++) {
  73.                     if (block.charAt(i) > '\xff') {
  74.                         hasUnicode = true
  75.                     } else if (block.charAt(i) === '\x00') {
  76.                         console.error('Null containing string', block)
  77.                         throw new Error('Null containing string')
  78.                     }
  79.                 }
  80.                 if (!hasUnicode && block.length <= 1) {
  81.                     typeCode = 0b1001
  82.                     contentSize++
  83.                 } else if (hasUnicode) {
  84.                     typeCode = 0b1011
  85.                     contentSize += block.length * 2 + 2
  86.                 } else {
  87.                     typeCode = 0b1010
  88.                     contentSize += block.length + 1
  89.                 }
  90.             } else {
  91.                 console.error('Unencodable data type', block)
  92.                 throw new Error('Unencodable data type')
  93.             }
  94.             headers.push(typeCode)
  95.             if (typeCode === lastTypeCode) {
  96.                 repeatTypeCount++
  97.             } else {
  98.                 headerCodes.push(lastTypeCode)
  99.                 if (repeatTypeCount >= 1) {
  100.                     while (repeatTypeCount > 19) {
  101.                         headerCodes.push(0b1110)
  102.                         headerCodes.push(15)
  103.                         repeatTypeCount -= 19
  104.                     }
  105.                     if (repeatTypeCount === 1)
  106.                         headerCodes.push(lastTypeCode)
  107.                     else if (repeatTypeCount === 2)
  108.                         headerCodes.push(0b1100)
  109.                     else if (repeatTypeCount === 3)
  110.                         headerCodes.push(0b1101)
  111.                     else if (repeatTypeCount < 20) {
  112.                         headerCodes.push(0b1110)
  113.                         headerCodes.push(repeatTypeCount - 4)
  114.                     }
  115.                 }
  116.                 repeatTypeCount = 0
  117.                 lastTypeCode = typeCode
  118.             }
  119.         }
  120.         headerCodes.push(lastTypeCode)
  121.         if (repeatTypeCount >= 1) {
  122.             while (repeatTypeCount > 19) {
  123.                 headerCodes.push(0b1110)
  124.                 headerCodes.push(15)
  125.                 repeatTypeCount -= 19
  126.             }
  127.             if (repeatTypeCount === 1)
  128.                 headerCodes.push(lastTypeCode)
  129.             else if (repeatTypeCount === 2)
  130.                 headerCodes.push(0b1100)
  131.             else if (repeatTypeCount === 3)
  132.                 headerCodes.push(0b1101)
  133.             else if (repeatTypeCount < 20) {
  134.                 headerCodes.push(0b1110)
  135.                 headerCodes.push(repeatTypeCount - 4)
  136.             }
  137.         }
  138.         headerCodes.push(0b1111)
  139.         if (headerCodes.length % 2 === 1)
  140.             headerCodes.push(0b1111)
  141.     
  142.         let output = new Uint8Array((headerCodes.length >> 1) + contentSize)
  143.         for (let i = 0; i < headerCodes.length; i += 2) {
  144.             let upper = headerCodes[i]
  145.             let lower = headerCodes[i + 1]
  146.             output[i >> 1] = (upper << 4) | lower
  147.         }
  148.         let index = headerCodes.length >> 1
  149.         for (let i = 0; i < headers.length; i++) {
  150.             let block = message[i]
  151.             switch (headers[i]) {
  152.                 case 0b0000:
  153.                 case 0b0001:
  154.                     break
  155.                 case 0b0010:
  156.                 case 0b0011:
  157.                     output[index++] = block
  158.                     break
  159.                 case 0b0100:
  160.                 case 0b0101:
  161.                     u16[0] = block
  162.                     output.set(c16, index)
  163.                     index += 2
  164.                     break
  165.                 case 0b0110:
  166.                 case 0b0111:
  167.                     u32[0] = block
  168.                     output.set(c32, index)
  169.                     index += 4
  170.                     break
  171.                 case 0b1000:
  172.                     f32[0] = block
  173.                     output.set(c32, index)
  174.                     index += 4
  175.                     break
  176.                 case 0b1001:
  177.                     {
  178.                         let byte = block.length === 0 ? 0 : block.charCodeAt(0)
  179.                         output[index++] = byte
  180.                     }
  181.                     break
  182.                 case 0b1010:
  183.                     for (let i = 0; i < block.length; i++) {
  184.                         output[index++] = block.charCodeAt(i)
  185.                     }
  186.                     output[index++] = 0
  187.                     break
  188.                 case 0b1011:
  189.                     for (let i = 0; i < block.length; i++) {
  190.                         let charCode = block.charCodeAt(i)
  191.                         output[index++] = charCode & 0xff
  192.                         output[index++] = charCode >> 8
  193.                     }
  194.                     output[index++] = 0
  195.                     output[index++] = 0
  196.                     break
  197.             }
  198.         }
  199.     
  200.         return output
  201.     };
  202.  
  203.     function decode(packet) {
  204.         let data = new Uint8Array(packet)
  205.         if (data[0] >> 4 !== 0b1111)
  206.             return null
  207.     
  208.         let headers = []
  209.         let lastTypeCode = 0b1111
  210.         let index = 0
  211.         let consumedHalf = true
  212.         while (true) {
  213.             if (index >= data.length)
  214.                 return null
  215.             let typeCode = data[index]
  216.     
  217.             if (consumedHalf) {
  218.                 typeCode &= 0b1111
  219.                 index++
  220.             } else {
  221.                 typeCode >>= 4
  222.             }
  223.             consumedHalf = !consumedHalf
  224.     
  225.             if ((typeCode & 0b1100) === 0b1100) {
  226.                 if (typeCode === 0b1111) {
  227.                     if (consumedHalf)
  228.                         index++
  229.                     break
  230.                 }
  231.     
  232.                 let repeat = typeCode - 10 // 0b1100 - 2
  233.                 if (typeCode === 0b1110) {
  234.                     if (index >= data.length)
  235.                         return null
  236.                     let repeatCode = data[index]
  237.     
  238.                     if (consumedHalf) {
  239.                         repeatCode &= 0b1111
  240.                         index++
  241.                     } else {
  242.                         repeatCode >>= 4
  243.                     }
  244.                     consumedHalf = !consumedHalf
  245.     
  246.                     repeat += repeatCode
  247.                 }
  248.     
  249.                 for (let i = 0; i < repeat; i++)
  250.                     headers.push(lastTypeCode)
  251.             } else {
  252.                 headers.push(typeCode)
  253.                 lastTypeCode = typeCode
  254.             }
  255.         }
  256.     
  257.         let output = []
  258.         for (let header of headers) {
  259.             switch (header) {
  260.                 case 0b0000:
  261.                     output.push(0)
  262.                     break
  263.                 case 0b0001:
  264.                     output.push(1)
  265.                     break
  266.                 case 0b0010:
  267.                     output.push(data[index++])
  268.                     break
  269.                 case 0b0011:
  270.                     output.push(data[index++] - 0x100)
  271.                     break
  272.                 case 0b0100:
  273.                     c16[0] = data[index++]
  274.                     c16[1] = data[index++]
  275.                     output.push(u16[0])
  276.                     break
  277.                 case 0b0101:
  278.                     c16[0] = data[index++]
  279.                     c16[1] = data[index++]
  280.                     output.push(u16[0] - 0x10000)
  281.                     break
  282.                 case 0b0110:
  283.                     c32[0] = data[index++]
  284.                     c32[1] = data[index++]
  285.                     c32[2] = data[index++]
  286.                     c32[3] = data[index++]
  287.                     output.push(u32[0])
  288.                     break
  289.                 case 0b0111:
  290.                     c32[0] = data[index++]
  291.                     c32[1] = data[index++]
  292.                     c32[2] = data[index++]
  293.                     c32[3] = data[index++]
  294.                     output.push(u32[0] - 0x100000000)
  295.                     break
  296.                 case 0b1000:
  297.                     c32[0] = data[index++]
  298.                     c32[1] = data[index++]
  299.                     c32[2] = data[index++]
  300.                     c32[3] = data[index++]
  301.                     output.push(f32[0])
  302.                     break
  303.                 case 0b1001:
  304.                     {
  305.                         let byte = data[index++]
  306.                         output.push(byte === 0 ? '' : String.fromCharCode(byte))
  307.                     }
  308.                     break
  309.                 case 0b1010:
  310.                     {
  311.                         let string = ''
  312.                         let byte = 0
  313.                         while (byte = data[index++]) {
  314.                             string += String.fromCharCode(byte)
  315.                         }
  316.                         output.push(string)
  317.                     }
  318.                     break
  319.                 case 0b1011:
  320.                     {
  321.                         let string = ''
  322.                         let byte = 0
  323.                         while (byte = data[index++] | (data[index++] << 8)) {
  324.                             string += String.fromCharCode(byte)
  325.                         }
  326.                         output.push(string)
  327.                     }
  328.                     break
  329.             }
  330.         }
  331.     
  332.         return output
  333.     };
  334.     
  335.     function rotator(packet) {
  336.         return {
  337.             i: 0,
  338.             arr: packet,
  339.             get(index) {
  340.                 return packet[index];
  341.             },
  342.             set(index, value) {
  343.                 return (packet[index] = value);
  344.             },
  345.             nex() {
  346.                 if (this.i === this.arr.length) {
  347.                     console.error(new Error('End reached'), this.arr)
  348.                     return -1;
  349.                 }
  350.                 return packet[this.i++];
  351.             }
  352.         }
  353.     };
  354.  
  355.     class BroadcastParser {
  356.         constructor() {
  357.             this.leaderboard = [];
  358.             this.teamMinimap = [];
  359.             this.globalMinimap = [];
  360.         }
  361.     
  362.         parse(packet) {
  363.             const rot = rotator(packet);
  364.     
  365.             if (rot.nex() !== 'b') throw new TypeError('Invalid packet header; expected packet `b`');
  366.     
  367.             this._array(rot, () => {
  368.                 const del = rot.nex();
  369.     
  370.                 this.globalMinimap.remove(this.globalMinimap.findIndex(({ id }) => id === del));
  371.             });
  372.     
  373.             this._array(rot, () => {
  374.                 const dot = {
  375.                     id: rot.nex(),
  376.                     type: rot.nex(),
  377.                     x: rot.nex(),
  378.                     y: rot.nex(),
  379.                     color: rot.nex(),
  380.                     size: rot.nex()
  381.                 };
  382.     
  383.                 let index = this.globalMinimap.findIndex(({ id }) => id === dot.id);
  384.                 if (index === -1) index = this.globalMinimap.length;
  385.     
  386.                 this.globalMinimap[index] = dot;
  387.             });
  388.     
  389.             this._array(rot, () => {
  390.                 const del = rot.nex();
  391.     
  392.                 this.teamMinimap.remove(this.teamMinimap.findIndex(({ id }) => id === del));
  393.             });
  394.     
  395.             this._array(rot, () => {
  396.                 const dot = {
  397.                     id: rot.nex(),
  398.                     x: rot.nex(),
  399.                     y: rot.nex(),
  400.                     size: rot.nex()
  401.                 };
  402.     
  403.                 let index = this.teamMinimap.findIndex(({ id }) => id === dot.id);
  404.                 if (index === -1) index = this.teamMinimap.length;
  405.     
  406.                 this.teamMinimap[index] = dot;
  407.             });
  408.     
  409.             this._array(rot, () => {
  410.                 const del = rot.nex();
  411.     
  412.                 this.leaderboard.remove(this.leaderboard.findIndex(({ id }) => id === del));
  413.             });
  414.     
  415.             this._array(rot, () => {
  416.                 const champ = {
  417.                     id: rot.nex(),
  418.                     score: rot.nex(),
  419.                     index: rot.nex(),
  420.                     name: rot.nex(),
  421.                     color: rot.nex(),
  422.                     barColor: rot.nex()
  423.                 };
  424.     
  425.                 let index = this.leaderboard.findIndex(({ id }) => id === champ.id);
  426.                 if (index === -1) index = this.leaderboard.length;
  427.     
  428.                 this.leaderboard[index] = champ;
  429.             });
  430.     
  431.             this.leaderboard.sort((c1, c2) => c2.score - c1.score);
  432.     
  433.             return this;
  434.         }
  435.     
  436.         _array(rot, read, length = rot.nex()) {
  437.             const out = Array(Math.max(0, length));
  438.     
  439.             for (let i = 0; i < length; ++i) out[i] = read.call(this, i, rot);
  440.     
  441.             return out;
  442.         }
  443.     };
  444.  
  445.     class RecordParser {
  446.         constructor() {
  447.             this.score = null;
  448.             this.seconds = null;
  449.             this.killCount = {
  450.                 players: null,
  451.                 assists: null,
  452.                 bosses: null
  453.             };
  454.             this.killersLength = null;
  455.             this.killers = [];
  456.         }
  457.     
  458.         parse(packet) {
  459.             if (packet.shift() !== 'F') throw new TypeError('Invalid packet header; expected packet `F`');
  460.     
  461.             this.score = packet.shift();
  462.             this.seconds = packet.shift();
  463.     
  464.             this.killCount.players = packet.shift();
  465.             this.killCount.assists = packet.shift();
  466.             this.killCount.bosses = packet.shift();
  467.     
  468.             this.killersLength = packet.shift();
  469.             this.killers = packet.slice(0, this.killersLength);
  470.     
  471.             return this;
  472.         }
  473.     };
  474.  
  475.     class UpdateParser {
  476.         constructor(doEntities = true) {
  477.             this.camera = { x: null, y: null, vx: null, vy: null, fov: null };
  478.             this.now = 0;
  479.             this.player = {
  480.                 fps: 1,
  481.                 body: {
  482.                     type: null,
  483.                     color: null,
  484.                     id: null,
  485.                 },
  486.                 score: null,
  487.                 points: null,
  488.                 upgrades: [],
  489.                 stats: [],
  490.                 skills: null,
  491.                 accel: null,
  492.                 top: null,
  493.                 party: null
  494.             }
  495.             this.entities = doEntities ? [] : false;
  496.         }
  497.         parse(packet) {
  498.             const rot = rotator(packet);
  499.     
  500.             if (rot.nex() !== 'u') throw new TypeError('Invalid packet header; expected packet `u`');
  501.     
  502.             this.now = rot.nex();
  503.     
  504.             const version = this.now === 0 ? 2 : 1;
  505.     
  506.             this.camera.x = rot.nex();
  507.             this.camera.y = rot.nex();
  508.             this.camera.fov = rot.nex();
  509.             this.camera.vx = rot.nex();
  510.             this.camera.vy = rot.nex();
  511.     
  512.             const flags = rot.nex();
  513.             if (flags & 0x0001) this.player.fps = rot.nex();
  514.             if (flags & 0x0002) {
  515.                 this.player.body.type = rot.nex();
  516.                 this.player.body.color = rot.nex();
  517.                 this.player.body.id = rot.nex();
  518.             }
  519.             if (flags & 0x0004) this.player.score = rot.nex();
  520.             if (flags & 0x0008) this.player.points = rot.nex();
  521.             if (flags & 0x0010) this.player.upgrades = Array(Math.max(0, rot.nex())).fill(-1).map(() => rot.nex());
  522.             if (flags & 0x0020) this.player.stats = Array(30).fill(0).map(() => rot.nex());
  523.             if (flags & 0x0040) {
  524.                 const result = rot.nex();
  525.     
  526.                 this.player.skills = [
  527.                     (result / 0x1000000000 & 15),
  528.                     (result / 0x0100000000 & 15),
  529.                     (result / 0x0010000000 & 15),
  530.                     (result / 0x0001000000 & 15),
  531.                     (result / 0x0000100000 & 15),
  532.                     (result / 0x0000010000 & 15),
  533.                     (result / 0x0000001000 & 15),
  534.                     (result / 0x0000000100 & 15),
  535.                     (result / 0x0000000010 & 15),
  536.                     (result / 0x0000000001 & 15)
  537.                 ]
  538.             }
  539.             if (flags & 0x0080) this.player.accel = rot.nex();
  540.             if (flags & 0x0100) this.player.top = rot.nex();
  541.             if (flags & 0x0200) this.player.party = rot.nex();
  542.             if (flags & 0x0400) this.player.speed = rot.nex();
  543.     
  544.             if (version === 2 && this.entities !== false) {
  545.                 this._parseEnts(rot)
  546.             } else if (version !== 2 && this.entities !== false) {
  547.                 this.entities = false;
  548.                 console.error('Invalid version, expected version 2. Disabling entities');
  549.             }
  550.             return this;
  551.         }
  552.         _table(rot, read) {
  553.             const out = [];
  554.             for (let id = rot.nex(); id !== -1; id = rot.nex()) {
  555.                 out[out.length] = read.call(this, id, rot)
  556.             }
  557.             return out
  558.         }
  559.         _parseEnts(rot) {
  560.             if (rot.nex() !== -1) return console.warn('uhhhh-cancelling', rot.arr);
  561.     
  562.             this._table(rot, (id) => {
  563.                 const index = this.entities.findIndex(ent => ent.id === id);
  564.                 if (index === -1) {
  565.                     return console.warn('Possible desync, deletion of non existant entity ' + id, this.entities.findIndex(ent => ent.id2 === id), JSON.stringify(this.entities));
  566.                 }
  567.                 this.entities[index] = this.entities[this.entities.length - 1]
  568.                 --this.entities.length;
  569.             });
  570.  
  571.             this._table(rot, (id) => {
  572.                 let index = this.entities.findIndex(ent => ent.id === id)
  573.                 if (index === -1) this.entities[index = this.entities.length] = { id };
  574.     
  575.                 const ent = this.entities[index];
  576.                 this._parseEnt(ent, rot)
  577.             });
  578.         }
  579.  
  580.         _parseEnt(ent, rot) {
  581.             const flags = rot.nex();
  582.             if (!ent) console.log(this.entities.length, rot.get(rot.i - 1));
  583.             if (flags & 0x0001) {
  584.                 let { x: lastX, y: lastY } = ent;
  585.                 ent.x = rot.nex() * 0.0625;
  586.                 ent.y = rot.nex() * 0.0625;
  587.                 if (typeof lastX !== 'undefined') {
  588.                     ent.vx = (ent.x - lastX);
  589.                     ent.vy = (ent.y - lastY);
  590.                 } else ent.vx = ent.vy = 0;
  591.             }
  592.             if (flags & 0x0002) ent.facing = rot.nex() * (360 / 256);
  593.             if (flags & 0x0004) ent.flags = rot.nex();
  594.             if (flags & 0x0008) ent.health = rot.nex() / 255;
  595.             if (flags & 0x0010) ent.shield = Math.max(0, rot.nex() / 255);
  596.             if (flags & 0x0020) ent.alpha = rot.nex() / 255;
  597.             if (flags & 0x0040) ent.size = rot.nex() * 0.0625;
  598.             if (flags & 0x0080) ent.score = rot.nex();
  599.             if (flags & 0x0100) ent.name = rot.nex();
  600.             if (flags & 0x0200) ent.id2 = rot.nex();
  601.             if (flags & 0x0400) ent.color = rot.nex();
  602.             if (flags & 0x0800) ent.layer = rot.nex();
  603.             if (flags & 0x1000) {
  604.                 if (!ent.guns) ent.guns = []
  605.     
  606.                 this._table(rot, (index) => {
  607.                     const flag = rot.nex();
  608.                     if (!ent.guns[index]) ent.guns[index] = {};
  609.                     if (flag & 1) ent.guns[index].time = rot.nex();
  610.                     if (flag & 2) ent.guns[index].power = Math.sqrt(rot.nex()) / 20;
  611.                 });
  612.             }
  613.             if (flags & 0x2000) {
  614.                 if (!ent.turrets) ent.turrets = [];
  615.     
  616.                 ent.turrets = this._table(rot, (index) => {
  617.                     let i = ent.turrets.findIndex(ent => ent.index === index)
  618.                     if (i === -1) ent.turrets[i = ent.turrets.length] = { index };
  619.                     const turret = ent.turrets[i];
  620.     
  621.                     return this._parseEnt(turret, rot);
  622.                 });
  623.             }
  624.     
  625.             return ent;
  626.         }
  627.     };
  628.  
  629.     const coder = { encode, decode };
  630.  
  631.     const hijack = () => {
  632.         if (window['%arras']) return window['%arras'];
  633.         
  634.         window['%arras'] = new Promise(r => {
  635.             const _send = WebSocket.prototype.send;
  636.             window.WebSocket = class ArrasSocket extends WebSocket {
  637.                 constructor(...args) {
  638.                     super(...args);
  639.                     this.isntArras = true;
  640.                     if (Array.isArray(args[1])) {
  641.                         this.isntArras = false;
  642.                         this._hook();
  643.                         
  644.                         this.onopen = () => r(this);
  645.                         this.sendHooks = [];
  646.                         this.msgHooks = [];
  647.                     }
  648.                 }
  649.                 
  650.                 _hook() {
  651.                     if (this.isntArras) throw 'sus';
  652.                     
  653.                     let send = this.send;
  654.                     this.send = function(buf) {
  655.                         return send.call(this, coder.encode(this.sendHooks.reduce((data, hook) => hook(data) || data, coder.decode(buf))));
  656.                     }
  657.                     
  658.                     let adv = this.addEventListener;
  659.                     this.addEventListener = function(type, cb, pro=false) {
  660.                         if (pro) return adv.call(this, type, cb, pro);
  661.                         
  662.                         if (type === 'message') {
  663.                             adv.call(this, 'message', (event) => {
  664.                                 cb(new MessageEvent('message', {
  665.                                     data: coder.encode(this.msgHooks.reduce((data, hook) => hook(data) || data, coder.decode(new Uint8Array(event.data)))).buffer
  666.                                 }));
  667.                             });
  668.                         } else return adv.call(this, type, cb, pro);
  669.                     }
  670.                 }
  671.                 
  672.                 hookSend(...funcs) {
  673.                     this.sendHooks.push.apply(this.sendHooks, funcs)
  674.                 }
  675.                 hookMsg(...funcs) {
  676.                     this.msgHooks.push.apply(this.msgHooks, funcs)
  677.                 }
  678.                 
  679.                 directTalk(...data) {
  680.                     _send.call(this, coder.encode(data));
  681.                 }
  682.                 
  683.                 talk(...data) {
  684.                     this.send(coder.encode(data));
  685.                 }
  686.             }
  687.         });
  688.         
  689.         return window['%arras']
  690.     };
  691.     
  692.     return { encode, decode, BroadcastParser, RecordParser, UpdateParser, hijack };
  693. })()