@abaplint/transpiler-cli 2.3.110 → 2.3.112

package/output/cl_abap_unit_assert.clas.mjs

@@ -0,0 +1,323 @@
+await import("./cl_abap_unit_assert.clas.locals.mjs");
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cl_abap_unit_assert.clas.abap
+class cl_abap_unit_assert {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = [];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    return this;
+  }
+  async abort(INPUT) {
+    return cl_abap_unit_assert.abort(INPUT);
+  }
+  static async abort(INPUT) {
+    let msg = new abap.types.Character();
+    if (INPUT && INPUT.msg) {msg = INPUT.msg;}
+    let detail = new abap.types.Character();
+    if (INPUT && INPUT.detail) {detail = INPUT.detail;}
+    let quit = new abap.types.Integer({qualifiedName: "INT1"});
+    if (INPUT && INPUT.quit) {quit.set(INPUT.quit);}
+    if (INPUT === undefined || INPUT.quit === undefined) {quit = new abap.types.Integer().set(2);}
+    abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(4).set('todo')));
+  }
+  async assert_bound(INPUT) {
+    return cl_abap_unit_assert.assert_bound(INPUT);
+  }
+  static async assert_bound(INPUT) {
+    let act = new abap.types.Character(4);
+    if (INPUT && INPUT.act) {act = INPUT.act;}
+    let msg = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.msg) {msg.set(INPUT.msg);}
+    let quit = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.quit) {quit.set(INPUT.quit);}
+    let level = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.level) {level.set(INPUT.level);}
+    if (abap.compare.initial(act)) {
+      throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_({msg: new abap.types.String().set(`Expected value to be bound`)});
+    }
+  }
+  async assert_not_bound(INPUT) {
+    return cl_abap_unit_assert.assert_not_bound(INPUT);
+  }
+  static async assert_not_bound(INPUT) {
+    let act = new abap.types.Character(4);
+    if (INPUT && INPUT.act) {act = INPUT.act;}
+    let msg = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.msg) {msg.set(INPUT.msg);}
+    let quit = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.quit) {quit.set(INPUT.quit);}
+    let level = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.level) {level.set(INPUT.level);}
+    if (abap.compare.initial(act) === false) {
+      throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_({msg: new abap.types.String().set(`Expected value to not be bound`)});
+    }
+  }
+  async assert_char_cp(INPUT) {
+    return cl_abap_unit_assert.assert_char_cp(INPUT);
+  }
+  static async assert_char_cp(INPUT) {
+    let act = new abap.types.Character();
+    if (INPUT && INPUT.act) {act = INPUT.act;}
+    let exp = new abap.types.Character();
+    if (INPUT && INPUT.exp) {exp = INPUT.exp;}
+    let msg = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.msg) {msg.set(INPUT.msg);}
+    let quit = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.quit) {quit.set(INPUT.quit);}
+    let level = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.level) {level.set(INPUT.level);}
+    if (abap.compare.np(act, exp)) {
+      throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_({expected: exp, actual: act, msg: msg});
+    }
+  }
+  async assert_char_np(INPUT) {
+    return cl_abap_unit_assert.assert_char_np(INPUT);
+  }
+  static async assert_char_np(INPUT) {
+    let act = new abap.types.Character();
+    if (INPUT && INPUT.act) {act = INPUT.act;}
+    let exp = new abap.types.Character();
+    if (INPUT && INPUT.exp) {exp = INPUT.exp;}
+    let msg = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.msg) {msg.set(INPUT.msg);}
+    let quit = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.quit) {quit.set(INPUT.quit);}
+    let level = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.level) {level.set(INPUT.level);}
+    if (abap.compare.cp(act, exp)) {
+      throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_({msg: new abap.types.String().set(`Actual: ${abap.templateFormatting(act)}`)});
+    }
+  }
+  async fail(INPUT) {
+    return cl_abap_unit_assert.fail(INPUT);
+  }
+  static async fail(INPUT) {
+    let msg = new abap.types.Character();
+    if (INPUT && INPUT.msg) {msg = INPUT.msg;}
+    let quit = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.quit) {quit.set(INPUT.quit);}
+    let level = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.level) {level.set(INPUT.level);}
+    let detail = new abap.types.Character();
+    if (INPUT && INPUT.detail) {detail = INPUT.detail;}
+    throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_({msg: msg});
+  }
+  async skip(INPUT) {
+    return cl_abap_unit_assert.skip(INPUT);
+  }
+  static async skip(INPUT) {
+    let msg = new abap.types.Character();
+    if (INPUT && INPUT.msg) {msg = INPUT.msg;}
+    let detail = new abap.types.Character();
+    if (INPUT && INPUT.detail) {detail = INPUT.detail;}
+    return;
+  }
+  async assert_differs(INPUT) {
+    return cl_abap_unit_assert.assert_differs(INPUT);
+  }
+  static async assert_differs(INPUT) {
+    let act = new abap.types.Character(4);
+    if (INPUT && INPUT.act) {act = INPUT.act;}
+    let exp = new abap.types.Character(4);
+    if (INPUT && INPUT.exp) {exp = INPUT.exp;}
+    let msg = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.msg) {msg.set(INPUT.msg);}
+    let quit = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.quit) {quit.set(INPUT.quit);}
+    let level = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.level) {level.set(INPUT.level);}
+    try {
+      await this.assert_equals({act: act, exp: exp});
+      throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_({msg: new abap.types.String().set(`Expected different values`), act: act, exp: exp});
+    } catch (e) {
+      if (e instanceof abap.Classes['KERNEL_CX_ASSERT']) {
+        return;
+      } else {
+        throw e;
+      }
+    }
+  }
+  async assert_true(INPUT) {
+    return cl_abap_unit_assert.assert_true(INPUT);
+  }
+  static async assert_true(INPUT) {
+    let act = new abap.types.Character(1, {"qualifiedName":"ABAP_BOOL","ddicName":"ABAP_BOOL"});
+    if (INPUT && INPUT.act) {act = INPUT.act;}
+    let msg = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.msg) {msg.set(INPUT.msg);}
+    let quit = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.quit) {quit.set(INPUT.quit);}
+    let level = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.level) {level.set(INPUT.level);}
+    if (abap.compare.ne(act, abap.builtin.abap_true)) {
+      throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_({msg: new abap.types.String().set(`Expected abap_true`)});
+    }
+  }
+  async assert_false(INPUT) {
+    return cl_abap_unit_assert.assert_false(INPUT);
+  }
+  static async assert_false(INPUT) {
+    let act = new abap.types.Character(1, {"qualifiedName":"ABAP_BOOL","ddicName":"ABAP_BOOL"});
+    if (INPUT && INPUT.act) {act = INPUT.act;}
+    let msg = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.msg) {msg.set(INPUT.msg);}
+    let quit = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.quit) {quit.set(INPUT.quit);}
+    let level = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.level) {level.set(INPUT.level);}
+    if (abap.compare.ne(act, abap.builtin.abap_false)) {
+      throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_({msg: new abap.types.String().set(`Expected abap_false`)});
+    }
+  }
+  async assert_equals(INPUT) {
+    return cl_abap_unit_assert.assert_equals(INPUT);
+  }
+  static async assert_equals(INPUT) {
+    let act = new abap.types.Character(4);
+    if (INPUT && INPUT.act) {act = INPUT.act;}
+    let exp = new abap.types.Character(4);
+    if (INPUT && INPUT.exp) {exp = INPUT.exp;}
+    let msg = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.msg) {msg.set(INPUT.msg);}
+    let tol = new abap.types.Float({qualifiedName: "F"});
+    if (INPUT && INPUT.tol) {tol.set(INPUT.tol);}
+    let quit = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.quit) {quit.set(INPUT.quit);}
+    let level = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.level) {level.set(INPUT.level);}
+    let type1 = new abap.types.Character(1, {});
+    let type2 = new abap.types.Character(1, {});
+    let index = new abap.types.Integer({qualifiedName: "I"});
+    let diff = new abap.types.Float({qualifiedName: "F"});
+    let lv_exp = new abap.types.String({qualifiedName: "STRING"});
+    let lv_act = new abap.types.String({qualifiedName: "STRING"});
+    let lv_msg = new abap.types.String({qualifiedName: "STRING"});
+    let fs_tab1_ = new abap.types.FieldSymbol(new abap.types.Table(new abap.types.Character(4), {"withHeader":false}));
+    let fs_row1_ = new abap.types.FieldSymbol(new abap.types.Character(4));
+    let fs_tab2_ = new abap.types.FieldSymbol(new abap.types.Table(new abap.types.Character(4), {"withHeader":false}));
+    let fs_row2_ = new abap.types.FieldSymbol(new abap.types.Character(4));
+    abap.statements.describe({field: act, type: type1});
+    abap.statements.describe({field: exp, type: type2});
+    if (abap.compare.ca(type1, new abap.types.Character(10).set('CgyIFPDTXN'))) {
+      if (abap.compare.initial(type2) === false) {
+        if (abap.compare.na(type2, new abap.types.Character(10).set('CgyIFPDTXN'))) {
+          throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_({msg: new abap.types.String().set(`Unexpected types`)});
+        }
+      }
+    } else if (abap.compare.initial(type1) === false && abap.compare.initial(type2) === false) {
+      if (abap.compare.ne(type1, type2)) {
+        throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_({msg: new abap.types.String().set(`Unexpected types`)});
+      }
+    }
+    if (abap.compare.eq(type1, new abap.types.Character(1).set('h'))) {
+      if (abap.compare.ne(abap.builtin.lines({val: act}), abap.builtin.lines({val: exp}))) {
+        throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_({msg: new abap.types.String().set(`Expected table to contain ${abap.templateFormatting(abap.builtin.lines({val: exp}))} rows, got ${abap.templateFormatting(abap.builtin.lines({val: act}))}`)});
+      }
+      abap.statements.assign({target: fs_tab1_, source: act});
+      abap.statements.assign({target: fs_tab2_, source: exp});
+      const indexBackup1 = abap.builtin.sy.get().index.get();
+      const unique92 = abap.builtin.lines({val: act}).get();
+      for (let unique93 = 0; unique93 < unique92; unique93++) {
+        abap.builtin.sy.get().index.set(unique93 + 1);
+        index.set(abap.builtin.sy.get().index);
+        abap.statements.readTable(fs_tab1_,{index: index,assigning: fs_row1_});
+        await this.assert_subrc();
+        abap.statements.readTable(fs_tab2_,{index: index,assigning: fs_row2_});
+        await this.assert_subrc();
+        await this.assert_equals({act: fs_row1_, exp: fs_row2_});
+      }
+      abap.builtin.sy.get().index.set(indexBackup1);
+    } else if (INPUT && INPUT.tol) {
+      diff.set(abap.operators.minus(exp,act));
+      if (abap.compare.ge(diff, tol)) {
+        throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_();
+      }
+    } else if (abap.compare.ne(act, exp)) {
+      lv_act.set((await abap.Classes['CLAS-CL_ABAP_UNIT_ASSERT-LCL_DUMP'].to_string({iv_val: act})));
+      lv_exp.set((await abap.Classes['CLAS-CL_ABAP_UNIT_ASSERT-LCL_DUMP'].to_string({iv_val: exp})));
+      if (abap.compare.ne(msg, new abap.types.Character(0).set(''))) {
+        lv_msg.set(msg);
+      } else {
+        lv_msg.set(new abap.types.String().set(`Expected '${abap.templateFormatting(lv_exp)}', got '${abap.templateFormatting(lv_act)}'`));
+      }
+      throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_({msg: lv_msg, actual: lv_act, expected: lv_exp});
+    }
+  }
+  async assert_not_initial(INPUT) {
+    return cl_abap_unit_assert.assert_not_initial(INPUT);
+  }
+  static async assert_not_initial(INPUT) {
+    let act = new abap.types.Character(4);
+    if (INPUT && INPUT.act) {act = INPUT.act;}
+    let msg = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.msg) {msg.set(INPUT.msg);}
+    let quit = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.quit) {quit.set(INPUT.quit);}
+    let level = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.level) {level.set(INPUT.level);}
+    if (abap.compare.initial(act)) {
+      throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_({msg: new abap.types.String().set(`Expected non initial value`)});
+    }
+  }
+  async assert_initial(INPUT) {
+    return cl_abap_unit_assert.assert_initial(INPUT);
+  }
+  static async assert_initial(INPUT) {
+    let act = new abap.types.Character(4);
+    if (INPUT && INPUT.act) {act = INPUT.act;}
+    let msg = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.msg) {msg.set(INPUT.msg);}
+    let quit = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.quit) {quit.set(INPUT.quit);}
+    let level = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.level) {level.set(INPUT.level);}
+    if (abap.compare.initial(act) === false) {
+      throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_({msg: new abap.types.String().set(`Expected initial value`)});
+    }
+  }
+  async assert_subrc(INPUT) {
+    return cl_abap_unit_assert.assert_subrc(INPUT);
+  }
+  static async assert_subrc(INPUT) {
+    let exp = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.exp) {exp.set(INPUT.exp);}
+    if (INPUT === undefined || INPUT.exp === undefined) {exp = new abap.types.Integer().set(0);}
+    let act = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.act) {act.set(INPUT.act);}
+    if (INPUT === undefined || INPUT.act === undefined) {act = abap.builtin.sy.get().subrc;}
+    let msg = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.msg) {msg.set(INPUT.msg);}
+    let quit = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.quit) {quit.set(INPUT.quit);}
+    let level = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.level) {level.set(INPUT.level);}
+    if (abap.compare.ne(act, exp)) {
+      throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_({msg: new abap.types.String().set(`Expected sy-subrc to equal ${abap.templateFormatting(exp)}, got ${abap.templateFormatting(act)}`)});
+    }
+  }
+  async assert_number_between(INPUT) {
+    return cl_abap_unit_assert.assert_number_between(INPUT);
+  }
+  static async assert_number_between(INPUT) {
+    let lower = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.lower) {lower.set(INPUT.lower);}
+    let upper = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.upper) {upper.set(INPUT.upper);}
+    let number = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.number) {number.set(INPUT.number);}
+    let msg = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.msg) {msg.set(INPUT.msg);}
+    let quit = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.quit) {quit.set(INPUT.quit);}
+    let level = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.level) {level.set(INPUT.level);}
+    if (abap.compare.lt(number, lower) || abap.compare.gt(number, upper)) {
+      throw await (new abap.Classes['KERNEL_CX_ASSERT']()).constructor_();
+    }
+  }
+}
+abap.Classes['CL_ABAP_UNIT_ASSERT'] = cl_abap_unit_assert;
+export {cl_abap_unit_assert};
+//# sourceMappingURL=cl_abap_unit_assert.clas.mjs.map

package/output/cl_abap_unit_assert.clas.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [
+    "cl_abap_unit_assert.clas.abap"
+  ],
+  "names": [],
+  "mappings": ";;;AAkIA;;;;;;;;EAEE;;;;;;;;;;;IACE,oCAAS,GAAF,iCAAI,wCAAM;EACnB;EAEA;;;;;;;;;;;;IACE,yBAAG,IAAgB;MACjB;IAGF;EACF;EAEA;;;;;;;;;;;;IACE,yBAAG,cAAY;MACb;IAGF;EACF;EAEA;;;;;;;;;;;;;;IACE,iBAAO,GAAJ,KAAO,IAAG;MACX;IAKF;EACF;EAEA;;;;;;;;;;;;;;IACE,iBAAO,GAAJ,KAAO,IAAG;MACX;IAGF;EACF;EAEA;;;;;;;;;;;;IACE;EAGF;EAEA;;;;;;;;IACE;EACF;EAEA;;;;;;;;;;;;;;IACE;oDAGiB;MACb;;;;;;;IAOJ;EACF;EAEA;;;;;;;;;;;;IACE,iBAAO,GAAJ,KAAO,uBAAS;MACjB;IAGF;EACF;EAEA;;;;;;;;;;;;IACE,iBAAO,GAAJ,KAAO,wBAAU;MAClB;IAGF;EACF;EAEA;;;;;;;;;;;;;;;;QACO,uCAAsB;QACtB,uCAAsB;QACtB,oDAAa;QACb,iDAAa;QACb,yDAAkB;QAClB,yDAAkB;QAClB,yDAAkB;IAEvB,IAAc,QAAuB;IACrC,IAAc,QAAe;IAC7B,IAAc,QAAuB;IACrC,IAAc,QAAe;IAE7B,iDAA6B;IAC7B,iDAA6B;IAG7B,iBAAS,GAAN,OAAS,+CAAY;MACtB,yBAAG,gBAAoB;QACrB,iBAAS,GAAN,OAAS,+CAAY;UACtB;QAGF;MACF;IACF,gCAAO,gBAAqB,yBAAI,gBAAoB;MAElD,iBAAS,GAAN,OAAS,MAAK;QACf;MAGF;IACF;IAEA,iBAAS,GAAN,OAAQ,qCAAG;MACZ,iBAAgB,GAAb,yBAAO,OAAS,yBAAO,MAAK;QAC7B;MAGF;MACA,qDAAoB;MACpB,qDAAoB;;;;;QAElB,UAAQ,eAAE,MAAC,MAAK;QAChB,qEAA8C;iCAC/B;QACf,qEAA8C;iCAC/B;gEAEc;MAC/B;;IACF,6BAAsB;MACpB,SAAW,qBAAJ,IAAM,IAAG;MAGhB,iBAAQ,GAAL,MAAQ,IAAG;QACZ;MACF;IACF,wBAAW,GAAJ,KAAO,IAAG;MACf,YAAS,iFAA0B;MACnC,YAAS,iFAA0B;MACnC,iBAAO,GAAJ,KAAO,oCAAE;QACV,WAAS,GAAG;MACd;QACE,iIAAkD;MACpD;MACA;IAKF;EACF;EAEA;;;;;;;;;;;;IACE,yBAAG,IAAc;MACf;IAGF;EACF;EAEA;;;;;;;;;;;;IACE,yBAAG,cAAkB;MACnB;IAGF;EACF;EAEA;;;;;;;;;;;;;;;;IACE,iBAAO,GAAJ,KAAO,IAAG;MACX;IAGF;EACF;EAEA;;;;;;;;;;;;;;;;IACE,iBAAU,GAAP,QAAS,MAAM,iBAAU,GAAP,QAAS,MAAK;MACjC;IACF;EACF;AAEF",
+  "file": "cl_abap_unit_assert.clas.mjs",
+  "sourceRoot": ""
+}

package/output/cl_abap_zip.clas.locals.mjs

@@ -0,0 +1,115 @@
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cl_abap_zip.clas.locals_imp.abap
+class lcl_stream {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = [];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.mv_xstr = new abap.types.XString({qualifiedName: "XSTRING"});
+    return this;
+  }
+  async append(INPUT) {
+    let iv_xstr = new abap.types.Hex();
+    if (INPUT && INPUT.iv_xstr) {iv_xstr = INPUT.iv_xstr;}
+    abap.statements.concatenate({source: [this.mv_xstr, iv_xstr], target: this.mv_xstr});
+  }
+  async get() {
+    let rv_xstr = new abap.types.XString({qualifiedName: "XSTRING"});
+    rv_xstr.set(this.mv_xstr);
+    return rv_xstr;
+  }
+  async append_date(INPUT) {
+    let iv_date = new abap.types.Date({qualifiedName: "D"});
+    if (INPUT && INPUT.iv_date) {iv_date.set(INPUT.iv_date);}
+  }
+  async append_time(INPUT) {
+    let iv_time = new abap.types.Time({qualifiedName: "T"});
+    if (INPUT && INPUT.iv_time) {iv_time.set(INPUT.iv_time);}
+  }
+  async append_int2(INPUT) {
+    let iv_int = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.iv_int) {iv_int.set(INPUT.iv_int);}
+    let lv_hex = new abap.types.Hex();
+    lv_hex.set(iv_int);
+    await this.append({iv_xstr: lv_hex});
+  }
+  async append_int4(INPUT) {
+    let iv_int = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.iv_int) {iv_int.set(INPUT.iv_int);}
+    let lv_hex = new abap.types.Hex({length: 2});
+    lv_hex.set(iv_int);
+    await this.append({iv_xstr: lv_hex});
+  }
+  async append_crc(INPUT) {
+    let rv_crc = new abap.types.XString({qualifiedName: "XSTRING"});
+    let iv_xstring = new abap.types.XString({qualifiedName: "XSTRING"});
+    if (INPUT && INPUT.iv_xstring) {iv_xstring.set(INPUT.iv_xstring);}
+    let magic_nr = new abap.types.Hex({length: 4});
+    magic_nr.set('EDB88320');
+    let mffffffff = new abap.types.Hex({length: 4});
+    mffffffff.set('FFFFFFFF');
+    let m7fffffff = new abap.types.Hex({length: 4});
+    m7fffffff.set('7FFFFFFF');
+    let m00ffffff = new abap.types.Hex({length: 4});
+    m00ffffff.set('00FFFFFF');
+    let m000000ff = new abap.types.Hex({length: 4});
+    m000000ff.set('000000FF');
+    let m000000 = new abap.types.Hex({length: 3});
+    m000000.set('000000');
+    let cindex = new abap.types.Hex({length: 4});
+    let low_bit = new abap.types.Hex({length: 4});
+    let len = new abap.types.Integer({qualifiedName: "I"});
+    let nindex = new abap.types.Integer({qualifiedName: "I"});
+    let crc = new abap.types.Hex({length: 4});
+    crc.set(mffffffff);
+    let x4 = new abap.types.Hex({length: 4});
+    let idx = new abap.types.Hex({length: 4});
+    if (abap.compare.eq(abap.builtin.xstrlen({val: lcl_stream.crc32_map}), new abap.types.Integer().set(0))) {
+      const indexBackup1 = abap.builtin.sy.get().index.get();
+      const unique3 = new abap.types.Integer().set(256).get();
+      for (let unique4 = 0; unique4 < unique3; unique4++) {
+        abap.builtin.sy.get().index.set(unique4 + 1);
+        cindex.set(abap.operators.minus(abap.builtin.sy.get().index,new abap.types.Integer().set(1)));
+        const indexBackup2 = abap.builtin.sy.get().index.get();
+        const unique5 = new abap.types.Integer().set(8).get();
+        for (let unique6 = 0; unique6 < unique5; unique6++) {
+          abap.builtin.sy.get().index.set(unique6 + 1);
+          low_bit.set(new abap.types.Character(8).set('00000001'));
+          low_bit.set(abap.operators.bitand(cindex,low_bit));
+          cindex.set(abap.operators.div(cindex,new abap.types.Integer().set(2)));
+          cindex.set(abap.operators.bitand(cindex,m7fffffff));
+          if (abap.compare.initial(low_bit) === false) {
+            cindex.set(abap.operators.bitxor(cindex,magic_nr));
+          }
+        }
+        abap.builtin.sy.get().index.set(indexBackup2);
+        abap.statements.concatenate({source: [lcl_stream.crc32_map, cindex], target: lcl_stream.crc32_map});
+      }
+      abap.builtin.sy.get().index.set(indexBackup1);
+    }
+    len.set(abap.builtin.xstrlen({val: iv_xstring}));
+    const indexBackup3 = abap.builtin.sy.get().index.get();
+    const unique7 = len.get();
+    for (let unique8 = 0; unique8 < unique7; unique8++) {
+      abap.builtin.sy.get().index.set(unique8 + 1);
+      nindex.set(abap.operators.minus(abap.builtin.sy.get().index,new abap.types.Integer().set(1)));
+      abap.statements.concatenate({source: [m000000, iv_xstring.getOffset({offset: nindex, length: 1})], target: idx});
+      idx.set(abap.operators.bitand(abap.operators.bitxor(crc,idx),m000000ff));
+      idx.set(abap.operators.multiply(idx,new abap.types.Integer().set(4)));
+      x4.set(lcl_stream.crc32_map.getOffset({offset: idx, length: 4}));
+      crc.set(abap.operators.div(crc,new abap.types.Integer().set(256)));
+      crc.set(abap.operators.bitand(crc,m00ffffff));
+      crc.set(abap.operators.bitxor(x4,crc));
+    }
+    abap.builtin.sy.get().index.set(indexBackup3);
+    crc.set(abap.operators.bitxor(crc,mffffffff));
+    rv_crc.set(crc);
+    await this.append({iv_xstr: rv_crc});
+    return rv_crc;
+  }
+}
+abap.Classes['CLAS-CL_ABAP_ZIP-LCL_STREAM'] = lcl_stream;
+lcl_stream.crc32_map = new abap.types.XString({qualifiedName: "XSTRING"});
+export {lcl_stream};
+//# sourceMappingURL=cl_abap_zip.clas.locals.mjs.map

package/output/cl_abap_zip.clas.locals.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [
+    "cl_abap_zip.clas.locals_imp.abap"
+  ],
+  "names": [],
+  "mappings": ";;AAgBA;;;;;;;;;EACE;;;IACE,sCAAY,cAAQ,kBAAa,YAAoB;EACvD;EAEA;;IACE,YAAU,YAAO;IACnB;;EAEA;;;EAEA;EAEA;;;EAEA;EAEA;;;QACO,6BAAsB;IAC3B,WAAS,MAAM;wCACC;EAClB;EAEA;;;QACO,wCAAsB;IAC3B,WAAS,MAAM;wCACC;EAClB;EAEA;;;;QAGa,0CAA0C,CAAA;;QAC1C,2CAA0C,CAAA;;QAC1C,2CAA0C,CAAA;;QAC1C,2CAA0C,CAAA;;QAC1C,2CAA0C,CAAA;;QAC1C,yCAAwC,CAAA;;QAE7C,wCAAuB;QACvB,yCAAuB;QACvB,kDAAc;QACd,qDAAc;QACd,qCAAuC,CAAA;;QACvC,oCAAuB;QACvB,qCAAuB;IAE7B,iBAAwB,GAArB,2BAAS,wBAAc,gCAAC;;;;;QAEvB,WAAkB,qBAAT,eAAE,MAAC,OAAQ,gCAAC;;;;;UAEnB,YAAU,2CAAU;UACpB,YAAiB,sBAAP,OAAe,QAAO;UAChC,WAAgB,mBAAP,OAAW,gCAAC;UACrB,WAAgB,sBAAP,OAAe,UAAS;UACjC,yBAAG,kBAAsB;YACvB,WAAgB,sBAAP,OAAe,SAAQ;UAClC;QACF;;QACA,sCAAY,sBAAU,iBAAY,oBAAsB;MAC1D;;IACF;IAEA,QAAM,2BAAS,YAAY;;;;;MAEzB,WAAkB,qBAAT,eAAE,MAAC,OAAQ,gCAAC;MACrB,sCAAY,SAAQ,4DAA0B,GAAgB;MAC9D,QAA0B,sBAAd,sBAAJ,IAAY,KAAc,UAAS;MAC3C,QAAU,wBAAJ,IAAM,gCAAC;MACb,OAAM,wDAAgB;MACtB,QAAU,mBAAJ,IAAQ,kCAAG;MACjB,QAAU,sBAAJ,IAAY,UAAS;MAC3B,QAAS,sBAAH,GAAW,IAAG;IACtB;;IACA,QAAU,sBAAJ,IAAY,UAAS;IAE3B,WAAS,GAAG;wCAEI;IAElB;;AAEF",
+  "file": "cl_abap_zip.clas.locals.mjs",
+  "sourceRoot": ""
+}

package/output/cl_abap_zip.clas.mjs

@@ -0,0 +1,95 @@
+await import("./cl_abap_zip.clas.locals.mjs");
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cl_abap_zip.clas.abap
+class cl_abap_zip {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = [];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.files = new abap.types.Table(new abap.types.Structure({"name": new abap.types.String({qualifiedName: "CL_ABAP_ZIP=>T_FILE-NAME"}), "size": new abap.types.Integer({qualifiedName: "CL_ABAP_ZIP=>T_FILE-SIZE"})}, "cl_abap_zip=>t_file"), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "cl_abap_zip=>t_files");
+    this.mt_contents = new abap.types.Table(new abap.types.Structure({"name": new abap.types.String({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-NAME"}), "original_size": new abap.types.Integer({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-ORIGINAL_SIZE"}), "content": new abap.types.XString({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-CONTENT"}), "compressed": new abap.types.XString({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-COMPRESSED"})}, "cl_abap_zip=>ty_contents"), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "");
+    return this;
+  }
+  async crc32(INPUT) {
+    return cl_abap_zip.crc32(INPUT);
+  }
+  static async crc32(INPUT) {
+    let crc = new abap.types.Integer({qualifiedName: "I"});
+    let content = new abap.types.XString({qualifiedName: "XSTRING"});
+    if (INPUT && INPUT.content) {content.set(INPUT.content);}
+    let lo_stream = new abap.types.ABAPObject({qualifiedName: "LCL_STREAM"});
+    lo_stream.set(await (new abap.Classes['CLAS-CL_ABAP_ZIP-LCL_STREAM']()).constructor_());
+    crc.set((await lo_stream.get().append_crc({iv_xstring: content})));
+    return crc;
+  }
+  async delete(INPUT) {
+    let name = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.name) {name.set(INPUT.name);}
+    let index = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.index) {index.set(INPUT.index);}
+    if (INPUT === undefined || INPUT.index === undefined) {index = new abap.types.Integer().set(0);}
+    abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(4).set('todo')));
+  }
+  async get(INPUT) {
+    let name = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.name) {name.set(INPUT.name);}
+    let content = new abap.types.XString({qualifiedName: "XSTRING"});
+    if (INPUT && INPUT.content) {content = INPUT.content;}
+    let ls_length = new abap.types.Integer({qualifiedName: "I"});
+    let ls_contents = new abap.types.Structure({"name": new abap.types.String({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-NAME"}), "original_size": new abap.types.Integer({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-ORIGINAL_SIZE"}), "content": new abap.types.XString({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-CONTENT"}), "compressed": new abap.types.XString({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-COMPRESSED"})}, "cl_abap_zip=>ty_contents");
+    abap.statements.readTable(this.mt_contents,{into: ls_contents,withKey: (i) => {return abap.compare.eq(i.name, name);}});
+    await abap.Classes['CL_ABAP_GZIP'].decompress_binary({gzip_in: ls_contents.get().compressed, raw_out: content, raw_out_len: ls_length});
+  }
+  async add(INPUT) {
+    let name = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.name) {name.set(INPUT.name);}
+    let content = new abap.types.XString({qualifiedName: "XSTRING"});
+    if (INPUT && INPUT.content) {content.set(INPUT.content);}
+    let ls_contents = new abap.types.Structure({"name": new abap.types.String({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-NAME"}), "original_size": new abap.types.Integer({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-ORIGINAL_SIZE"}), "content": new abap.types.XString({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-CONTENT"}), "compressed": new abap.types.XString({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-COMPRESSED"})}, "cl_abap_zip=>ty_contents");
+    ls_contents.get().name.set(name);
+    ls_contents.get().original_size.set(abap.builtin.xstrlen({val: content}));
+    ls_contents.get().content.set(content);
+    await abap.Classes['CL_ABAP_GZIP'].compress_binary({raw_in: content, gzip_out: ls_contents.get().compressed});
+    abap.statements.insertInternal({data: ls_contents, table: this.mt_contents});
+  }
+  async load(INPUT) {
+    let zip = new abap.types.XString({qualifiedName: "XSTRING"});
+    if (INPUT && INPUT.zip) {zip.set(INPUT.zip);}
+    abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(4).set('todo')));
+  }
+  async save() {
+    let val = new abap.types.XString({qualifiedName: "XSTRING"});
+    let lo_stream = new abap.types.ABAPObject({qualifiedName: "LCL_STREAM"});
+    let ls_contents = new abap.types.Structure({"name": new abap.types.String({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-NAME"}), "original_size": new abap.types.Integer({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-ORIGINAL_SIZE"}), "content": new abap.types.XString({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-CONTENT"}), "compressed": new abap.types.XString({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-COMPRESSED"})}, "cl_abap_zip=>ty_contents");
+    let lv_buffer = new abap.types.XString({qualifiedName: "XSTRING"});
+    let lo_conv = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_CONV_OUT_CE"});
+    lo_stream.set(await (new abap.Classes['CLAS-CL_ABAP_ZIP-LCL_STREAM']()).constructor_());
+    lo_conv.set((await abap.Classes['CL_ABAP_CONV_OUT_CE'].create()));
+    for await (const unique9 of abap.statements.loop(this.mt_contents)) {
+      ls_contents.set(unique9);
+      await lo_stream.get().append({iv_xstr: new abap.types.Character(8).set('504B0304')});
+      await lo_stream.get().append({iv_xstr: new abap.types.Character(4).set('1400')});
+      await lo_stream.get().append({iv_xstr: new abap.types.Character(4).set('0000')});
+      await lo_stream.get().append({iv_xstr: new abap.types.Character(4).set('0800')});
+      await lo_stream.get().append({iv_xstr: new abap.types.Character(4).set('0000')});
+      await lo_stream.get().append({iv_xstr: new abap.types.Character(4).set('0000')});
+      await lo_stream.get().append_crc({iv_xstring: ls_contents.get().content});
+      await lo_stream.get().append_int4({iv_int: abap.builtin.xstrlen({val: ls_contents.get().compressed})});
+      await lo_stream.get().append_int4({iv_int: abap.builtin.xstrlen({val: ls_contents.get().content})});
+      await lo_stream.get().append_int2({iv_int: abap.builtin.strlen({val: ls_contents.get().name})});
+      await lo_stream.get().append({iv_xstr: new abap.types.Character(4).set('0000')});
+      await lo_conv.get().convert({data: ls_contents.get().name, buffer: lv_buffer});
+      await lo_stream.get().append({iv_xstr: lv_buffer});
+      await lo_stream.get().append({iv_xstr: ls_contents.get().compressed});
+    }
+    val.set((await lo_stream.get().get()));
+    return val;
+  }
+}
+abap.Classes['CL_ABAP_ZIP'] = cl_abap_zip;
+cl_abap_zip.t_file = new abap.types.Structure({"name": new abap.types.String({qualifiedName: "CL_ABAP_ZIP=>T_FILE-NAME"}), "size": new abap.types.Integer({qualifiedName: "CL_ABAP_ZIP=>T_FILE-SIZE"})}, "cl_abap_zip=>t_file");
+cl_abap_zip.t_files = new abap.types.Table(new abap.types.Structure({"name": new abap.types.String({qualifiedName: "CL_ABAP_ZIP=>T_FILE-NAME"}), "size": new abap.types.Integer({qualifiedName: "CL_ABAP_ZIP=>T_FILE-SIZE"})}, "cl_abap_zip=>t_file"), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "cl_abap_zip=>t_files");
+cl_abap_zip.ty_contents = new abap.types.Structure({"name": new abap.types.String({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-NAME"}), "original_size": new abap.types.Integer({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-ORIGINAL_SIZE"}), "content": new abap.types.XString({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-CONTENT"}), "compressed": new abap.types.XString({qualifiedName: "CL_ABAP_ZIP=>TY_CONTENTS-COMPRESSED"})}, "cl_abap_zip=>ty_contents");
+export {cl_abap_zip};
+//# sourceMappingURL=cl_abap_zip.clas.mjs.map

package/output/cl_abap_zip.clas.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [
+    "cl_abap_zip.clas.abap"
+  ],
+  "names": [],
+  "mappings": ";;;AA8CA;;;;;;;;;;EAEE;;;;;;;QACO,oEAAgC;;IAErC,SAAM,wDAAgC;IACxC;;EAEA;;;;;;IACE,oCAAS,GAAF,iCAAI,wCAAM;EACnB;EAEA;;;;;QAEI,wDAAgB;QAChB,+aAAoC;IACtC,sHAA4D;2IAIrB;EACzC;EAEA;;;;;QACO,+aAAoC;IACzC,WAAW,MAAC,UAAO,IAAI;IACvB,WAAW,MAAC,mBAAgB,2BAAS,SAAS;IAC9C,WAAW,MAAC,aAAU,OAAO;iHAKU;IACvC,0EAAyC;EAC3C;EAEA;;;IACE,oCAAS,GAAF,iCAAI,wCAAM;EACnB;EAEA;;QAGO,oEAAgC;QAChC,+aAAoC;QACpC,8DAAsB;QACtB,2EAAuC;;IAG5C,aAAU,mDAA8B;;;0FAIP;sFAEJ;sFAEA;sFAEA;sFAEA;sFAEA;+EAEiB;4GAEe;yGAEH;qGAEJ;sFAEzB;oFAGqB;wDAClB;2EAIa;IAC7C;IAEA,SAAM,4BAAiB;IACzB;;AAEF",
+  "file": "cl_abap_zip.clas.mjs",
+  "sourceRoot": ""
+}

package/output/cl_apc_tcp_client_manager.clas.locals.mjs

@@ -0,0 +1,86 @@
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cl_apc_tcp_client_manager.clas.locals_imp.abap
+class lcl_message {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = ["IF_APC_WSP_MESSAGE"];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.mv_data = new abap.types.XString({qualifiedName: "XSTRING"});
+    return this;
+  }
+  async if_apc_wsp_message$get_binary() {
+    let rv_binary = new abap.types.XString({qualifiedName: "XSTRING"});
+    rv_binary.set(this.mv_data);
+    return rv_binary;
+  }
+  async if_apc_wsp_message$get_text() {
+    let r_message = new abap.types.String({qualifiedName: "STRING"});
+    abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(4).set('todo')));
+    return r_message;
+  }
+  async if_apc_wsp_message$set_binary(INPUT) {
+    let iv_binary = new abap.types.Hex();
+    if (INPUT && INPUT.iv_binary) {iv_binary = INPUT.iv_binary;}
+    this.mv_data.set(iv_binary);
+  }
+}
+abap.Classes['CLAS-CL_APC_TCP_CLIENT_MANAGER-LCL_MESSAGE'] = lcl_message;
+class lcl_client {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = ["IF_APC_WSP_CLIENT","IF_APC_WSP_MESSAGE_MANAGER"];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.mv_host = new abap.types.String({qualifiedName: "STRING"});
+    this.mv_port = new abap.types.Integer({qualifiedName: "I"});
+    this.mo_handler = new abap.types.ABAPObject({qualifiedName: "IF_APC_WSP_EVENT_HANDLER"});
+    let iv_host = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.iv_host) {iv_host.set(INPUT.iv_host);}
+    let iv_port = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.iv_port) {iv_port.set(INPUT.iv_port);}
+    let io_handler = new abap.types.ABAPObject({qualifiedName: "IF_APC_WSP_EVENT_HANDLER"});
+    if (INPUT && INPUT.io_handler) {io_handler.set(INPUT.io_handler);}
+    abap.statements.assert(abap.compare.initial(iv_host) === false);
+    abap.statements.assert(abap.compare.initial(iv_port) === false);
+    abap.statements.assert(abap.compare.initial(io_handler) === false);
+    this.mv_host.set(iv_host);
+    this.mv_port.set(iv_port);
+    this.mo_handler.set(io_handler);
+    return this;
+  }
+  async if_apc_wsp_client$connect() {
+    const net = await import("net");
+    this.client = net.createConnection({ port: this.mv_port.get(), host: this.mv_host.get()}, () => {this.mo_handler.get().if_apc_wsp_event_handler$on_open();});
+    this.client.on("data", async (data) => {
+        const msg = await (new lcl_message().constructor_());
+        await msg.if_apc_wsp_message$set_binary({iv_binary: data.toString("hex").toUpperCase()});
+        await this.mo_handler.get().if_apc_wsp_event_handler$on_message({i_message: msg});
+    });
+    this.client.on("end",   async () => {this.mo_handler.get().if_apc_wsp_event_handler$on_close();});
+    this.client.on("error", async (e) => {this.mo_handler.get().if_apc_wsp_event_handler$on_error();});
+    await new Promise(resolve => this.client.once("connect", resolve));
+  }
+  async if_apc_wsp_client$close() {
+    this.client.destroy();
+  }
+  async if_apc_wsp_client$get_message_manager() {
+    let ri_manager = new abap.types.ABAPObject({qualifiedName: "IF_APC_WSP_MESSAGE_MANAGER"});
+    ri_manager.set(this.me);
+    return ri_manager;
+  }
+  async if_apc_wsp_message_manager$create_message() {
+    let ri_message = new abap.types.ABAPObject({qualifiedName: "IF_APC_WSP_MESSAGE"});
+    ri_message.set(await (new abap.Classes['CLAS-CL_APC_TCP_CLIENT_MANAGER-LCL_MESSAGE']()).constructor_());
+    return ri_message;
+  }
+  async if_apc_wsp_message_manager$send(INPUT) {
+    let ii_message = new abap.types.ABAPObject({qualifiedName: "IF_APC_WSP_MESSAGE"});
+    if (INPUT && INPUT.ii_message) {ii_message.set(INPUT.ii_message);}
+    const val = await ii_message.get().if_apc_wsp_message$get_binary();
+    this.client.write(Buffer.from(val.get(), "hex"), "binary");
+  }
+}
+abap.Classes['CLAS-CL_APC_TCP_CLIENT_MANAGER-LCL_CLIENT'] = lcl_client;
+export {lcl_message, lcl_client};
+//# sourceMappingURL=cl_apc_tcp_client_manager.clas.locals.mjs.map