add getter for internal PromiseIO socket in RPCServer

package.json

     "ts-mocha": "^6.0.0",
     "typedoc": "^0.15.0",
     "typedoc-plugin-markdown": "^2.2.6",
-    "typescript": "^3.5.3",
-    "webpack": "^4.40.2",
+    "typescript": "^4.6.3",
+    "webpack": "^5.71.0",
     "webpack-cli": "^3.3.9",
     "why-is-node-running": "^2.1.2"
   },

src/Backend.ts

             }
             return infos
         })
-
-
     }
 
+    public getSocket(): PromiseIO{
+        return this.pio
+    } 
+
     close(): void {
         this.pio.close()
     }

src/Decorator.ts

         DeserializerFactory.entityClasses[clazz.name] = clazz
         
         return clazz
-        /*
-        return class extends clazz{
-            constructor(...args: any[]) {
-                super(...args)
-            }
-        }
-        */
     }
 }

src/Frontend.ts

         const destroy_prefix = DESTROY_PREFIX
 
         const frontendHookStr = `
-        async (${headerArgs} ${CALLBACK_NAME}) => {
+        async (${CALLBACK_NAME}, ${headerArgs}) => {
             const r = await this.call("${fnName}", ${sesame} ${argParams})
             try{
                 if(r){

src/PromiseIO/Server.ts

         this.httpServer!.listen(port)
     }
 
-    on(eventName: string, listener: T.AnyFunction) {
+    on(eventName: string, listener: T.GenericFunction) {
         if (this.listeners[eventName] == null) {
             this.listeners[eventName] = []
         }

src/Types.ts

 export type BackendHook<Func extends GenericFunction> =
     GenericFunction<
         [
-            ...Head<Parameters<Func>>,
             GenericFunction<
                 Parameters<
                     AsFunction<
-                        Last<Parameters<Func>>
+                        Parameters<Func>[0]
                     >
                 >,
                 void
-            >
+            >,
+            ...Tail<Parameters<Func>>
         ],
         ReturnType<Func>
     >
     ? ((...args: Parameters<F>) => R extends Promise<any> ? R : Promise<R>)
     : Promise<any>
 
-
 type Destroyable = { destroy: () => void }
 export type Callback<Params extends any[] = []> =
     (this: Destroyable, ...args: Params) => void
 type AsFunction<F> = F extends GenericFunction ? F : GenericFunction
 
 type Last<Tuple extends any[]> = Tuple[ Subtract<Length<Tuple>, 1> ]
-type Head<T extends any[]> = T extends [ ...infer Head, any ] ? Head : any[]
-type Tail<T extends any[]> = T extends [any, ...infer Tail] ? Tail: []
+type Tail<T extends any[]> = T extends [any, ...infer R] ? R : any[]
 
 type Length<T extends any[]> = 
     T extends { length: infer L } ? L : never;

src/Utils.ts

 const hookGenerator = (rpc: T.HookRPC<any, any>, errorHandler: T.ErrorHandler, sesameFn?: T.SesameFunction, injectSocket?: boolean): T.HookInfo['generator'] => {
     const deserializer = DeserializerFactory 
     let argsArr = extractArgs(rpc.hook)
-    argsArr.pop() //remove callback param
+    argsArr.shift()//remove callback param
 
     let callArgs = argsArr.join(',')
     const args = sesameFn ? (['sesame', ...argsArr].join(','))
         try{
             if(sesameFn && !sesameFn(sesame)) return
             const uuid = uuidv4()
-            const res = await rpc.hook(${callArgs} (...cbargs) => {
+            const res = await rpc.hook((...cbargs) => {
                 ${rpc.onCallback ? `rpc.onCallback.apply({}, cbargs)` : ``}
                 cbargs = cbargs.map(deserializer.makeDeserializable)
                 $__socket__$.call.apply($__socket__$, [uuid, ...cbargs])
-            })
+            },${callArgs})
             ${rpc.onDestroy ? `$__socket__$.bind(destroy_prefix+uuid, () => {
                 rpc.onDestroy(res, rpc)
             })` : ``}

test/Test.ts

 var chaiAsPromised = require("chai-as-promised");
 
 chai.use(chaiAsPromised);
-const noop = (...args) => { }
+const noop = (...args: any[]) => { }
 
 const add = (...args: number[]) => { return args.reduce((a, b) => a + b, 0) }
 function makeServer(onCallback = noop, connectionHandler = noop, hookCloseHandler = noop, closeHandler = noop, errorHandler = noop) {
-    let subcallback
+    let subcallback: GenericFunction
     const serv = new RPCServer([{
         name: 'test',
         RPCs: [
         const server = new PromiseIO()
         server.attach(new http.Server())
         server.on("socket", clientSocket => {
-            clientSocket.bind("test123", (p1, p2) => {
+            clientSocket.bind("test123", (p1: string, p2:string) => {
                 server.close()
                 if (p1 === "p1" && p2 === "p2")
                     done()
             },
             {
                 name: 'subscribeWithParam',
-                hook: async (param, callback): Promise<{ uuid: string }> => {
+                hook: async (callback, param): Promise<{ uuid: string }> => {
 
                     if (param != "OK") {
                         console.log("param was" + param);
     })
 
     it('Subscribe with param', async () => {
-        const res = await client['test'].subscribeWithParam("OK", noop)
+        const res = await client['test'].subscribeWithParam(noop, "OK")
         expect(res.uuid).to.be.equal(candy)
     })
 
     let server: RPCServer<SesameTestIfc>
     let cb: Function = (...args) => { }
 
+
     before((done) => {
         server = new RPCServer<SesameTestIfc>([{
             name: "test",
         })
 
         it("receives class object in hook response", async function () {
-            const obj: TestClass = await mySocket.Test.classCallback(noop)
+            const obj: TestClass = await mySocket.Test.classCallback(function(x){
+                x
+            })
             verifyObject(obj)
         })
 
             })
         })
     })
-})
+})

tsconfig.json

       "strict": true,
       "experimentalDecorators": true
     },
-    "include": ["src/**/*.ts", "test/**/*.ts", "Index.ts", "demo.ts", "wat.ts"],
+    "include": ["src/**/*.ts", "test/**/*.ts", "Index.ts"],
     "exclude": ["node_modules"]
   }