@abaplint/transpiler-cli 2.3.110 → 2.3.112

package/output/cl_abap_conv_in_ce.clas.mjs

@@ -0,0 +1,118 @@
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cl_abap_conv_in_ce.clas.abap
+class cl_abap_conv_in_ce {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = [];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.mv_input = new abap.types.XString({qualifiedName: "XSTRING"});
+    this.mv_js_encoding = new abap.types.String({qualifiedName: "STRING"});
+    this.mv_ignore_cerr = new abap.types.Character(1, {"qualifiedName":"ABAP_BOOL","ddicName":"ABAP_BOOL"});
+    return this;
+  }
+  async create(INPUT) {
+    return cl_abap_conv_in_ce.create(INPUT);
+  }
+  static async create(INPUT) {
+    let ret = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_CONV_IN_CE"});
+    let encoding = new abap.types.Character(20, {"qualifiedName":"abap_encoding"});
+    if (INPUT && INPUT.encoding) {encoding.set(INPUT.encoding);}
+    if (INPUT === undefined || INPUT.encoding === undefined) {encoding = new abap.types.Character(5).set('UTF-8');}
+    let input = new abap.types.XString({qualifiedName: "XSTRING"});
+    if (INPUT && INPUT.input) {input.set(INPUT.input);}
+    let replacement = new abap.types.Character(1, {"qualifiedName":"CHAR1"});
+    if (INPUT && INPUT.replacement) {replacement = INPUT.replacement;}
+    if (INPUT === undefined || INPUT.replacement === undefined) {replacement = new abap.types.Character(1).set('#');}
+    let ignore_cerr = new abap.types.Character(1, {"qualifiedName":"ABAP_BOOL","ddicName":"ABAP_BOOL"});
+    if (INPUT && INPUT.ignore_cerr) {ignore_cerr = INPUT.ignore_cerr;}
+    if (INPUT === undefined || INPUT.ignore_cerr === undefined) {ignore_cerr = abap.builtin.abap_false;}
+    let endian = new abap.types.Character(1, {"qualifiedName":"CHAR1"});
+    if (INPUT && INPUT.endian) {endian = INPUT.endian;}
+    abap.statements.assert(abap.compare.eq(replacement, new abap.types.Character(1).set('#')));
+    abap.statements.assert(abap.compare.initial(endian));
+    ret.set(await (new abap.Classes['CL_ABAP_CONV_IN_CE']()).constructor_());
+    let unique16 = encoding;
+    if (abap.compare.eq(unique16, new abap.types.Character(5).set('UTF-8'))) {
+      ret.get().mv_js_encoding.set(new abap.types.Character(4).set('utf8'));
+    } else if (abap.compare.eq(unique16, new abap.types.Character(4).set('4103'))) {
+      ret.get().mv_js_encoding.set(new abap.types.Character(8).set('utf-16le'));
+    } else {
+      abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(13).set('not supported')));
+    }
+    ret.get().mv_input.set(input);
+    ret.get().mv_ignore_cerr.set(ignore_cerr);
+    return ret;
+  }
+  async uccp(INPUT) {
+    return cl_abap_conv_in_ce.uccp(INPUT);
+  }
+  static async uccp(INPUT) {
+    let char_ = new abap.types.Character(2, {"qualifiedName":"cl_abap_conv_in_ce=>ty_char2"});
+    let uccp = new abap.types.Character();
+    if (INPUT && INPUT.uccp) {uccp = INPUT.uccp;}
+    let int = new abap.types.Integer({qualifiedName: "I"});
+    let hex = new abap.types.Hex({length: 2});
+    hex.set(uccp);
+    int.set(hex);
+    try {
+      char_.set((await this.uccpi({value: int})));
+    } catch (e) {
+      if (e instanceof abap.Classes['CX_SY_CONVERSION_CODEPAGE']) {
+      } else {
+        throw e;
+      }
+    }
+    return char_;
+  }
+  async uccpi(INPUT) {
+    return cl_abap_conv_in_ce.uccpi(INPUT);
+  }
+  static async uccpi(INPUT) {
+    let ret = new abap.types.String({qualifiedName: "STRING"});
+    let value = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.value) {value.set(INPUT.value);}
+    let lv_hex = new abap.types.Hex({length: 2});
+    let lo_in = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_CONV_IN_CE"});
+    new abap.OffsetLength(lv_hex, {length: 1}).set(abap.operators.mod(value,new abap.types.Integer().set(255)));
+    new abap.OffsetLength(lv_hex, {offset: 1, length: 1}).set(abap.operators.div(value,new abap.types.Integer().set(255)));
+    lo_in.set((await this.create({encoding: new abap.types.Character(4).set('4103')})));
+    await lo_in.get().convert({input: lv_hex, data: ret});
+    return ret;
+  }
+  async convert(INPUT) {
+    let input = new abap.types.XString({qualifiedName: "XSTRING"});
+    if (INPUT && INPUT.input) {input.set(INPUT.input);}
+    let n = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.n) {n.set(INPUT.n);}
+    let data = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.data) {data = INPUT.data;}
+    let lv_error = new abap.types.Character(1, {"qualifiedName":"ABAP_BOOL","ddicName":"ABAP_BOOL"});
+    if (abap.compare.initial(input)) {
+      return;
+    }
+    abap.statements.assert(abap.compare.initial(this.mv_js_encoding) === false);
+    let buf = Buffer.from(input.get(), "hex");
+    const util= await import("util");
+    const td = new util.TextDecoder(this.mv_js_encoding.get(), {fatal: this.mv_ignore_cerr.get() !== "X"});
+    try {
+        data.set(td.decode(buf));
+    } catch {
+      lv_error.set(abap.builtin.abap_true);
+    }
+    if (abap.compare.eq(lv_error, abap.builtin.abap_true)) {
+      throw await (new abap.Classes['CX_SY_CONVERSION_CODEPAGE']()).constructor_();
+    }
+  }
+  async read(INPUT) {
+    let n = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.n) {n.set(INPUT.n);}
+    let data = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.data) {data = INPUT.data;}
+    await this.convert({input: this.mv_input, n: n, data: data});
+  }
+}
+abap.Classes['CL_ABAP_CONV_IN_CE'] = cl_abap_conv_in_ce;
+cl_abap_conv_in_ce.ty_char2 = new abap.types.Character(2, {"qualifiedName":"cl_abap_conv_in_ce=>ty_char2"});
+export {cl_abap_conv_in_ce};
+//# sourceMappingURL=cl_abap_conv_in_ce.clas.mjs.map

package/output/cl_abap_conv_in_ce.clas.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [
+    "cl_abap_conv_in_ce.clas.abap"
+  ],
+  "names": [],
+  "mappings": ";;AA8CA;;;;;;;;;;;EACE;;;;;;;;;;;;;;;;;;IACE,oCAAmB,GAAZ,aAAc,qCAAG;IACxB,4CAAO,OAAiB;;IAIxB,IACE,OAEA,IAHG,QAAL;;MAEI,GAAG,OAAE,mBAAiB,uCAAM;;MAE5B,GAAG,OAAE,mBAAiB,2CAAU;;MAEhC,oCAAS,GAAF,iCAAI,kDAAe;;IAG9B,GAAG,OAAE,aAAW,KAAK;IACrB,GAAG,OAAE,mBAAiB,WAAW;IACnC;;EAEA;;;;;;;QACO,kDAAU;QACV,qCAAmB;IACxB,QAAM,IAAI;IACV,QAAM,GAAG;IACT;MACI,WAAQ,+BAAY;;;;;;IAGxB;IACF;;EAEA;;;;;;;QACO,wCAAsB;QACtB,wEAAoC;0BAEzC,yBAAkB,mBAAN,MAAU,kCAAG;0BACzB,oCAAoB,mBAAN,MAAU,kCAAG;IAE3B,WAAQ,uEAA2B;yDAMlB;IACnB;;EAEA;;;;;;;QACO,4FAAuB;IAE5B,yBAAG,MAAgB;MACjB;IACF;IACA,4CAAO,8BAA6B;IACpC;IAEA;IACA;IACA;MACA;IACA;MACA,aAAW,sBAAS;IACpB;IAEA,iBAAY,GAAT,UAAW,uBAAS;MACrB;IACF;EAIF;EAEA;;;;;gEAMoB;EACpB;AAEF",
+  "file": "cl_abap_conv_in_ce.clas.mjs",
+  "sourceRoot": ""
+}

package/output/cl_abap_conv_out_ce.clas.mjs

@@ -0,0 +1,82 @@
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cl_abap_conv_out_ce.clas.abap
+class cl_abap_conv_out_ce {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = [];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.mv_js_encoding = new abap.types.String({qualifiedName: "STRING"});
+    this.mv_buffer = new abap.types.XString({qualifiedName: "XSTRING"});
+    return this;
+  }
+  async create(INPUT) {
+    return cl_abap_conv_out_ce.create(INPUT);
+  }
+  static async create(INPUT) {
+    let ret = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_CONV_OUT_CE"});
+    let encoding = new abap.types.Character(20, {"qualifiedName":"abap_encoding"});
+    if (INPUT && INPUT.encoding) {encoding.set(INPUT.encoding);}
+    let ignore_cerr = new abap.types.Character(1, {"qualifiedName":"ABAP_BOOL","ddicName":"ABAP_BOOL"});
+    if (INPUT && INPUT.ignore_cerr) {ignore_cerr = INPUT.ignore_cerr;}
+    if (INPUT === undefined || INPUT.ignore_cerr === undefined) {ignore_cerr = abap.builtin.abap_false;}
+    let endian = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.endian) {endian.set(INPUT.endian);}
+    let replacement = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.replacement) {replacement.set(INPUT.replacement);}
+    ret.set(await (new abap.Classes['CL_ABAP_CONV_OUT_CE']()).constructor_());
+    let unique17 = encoding;
+    if (abap.compare.eq(unique17, new abap.types.Character(5).set('UTF-8')) || abap.compare.eq(unique17, new abap.types.Character(0).set(''))) {
+      ret.get().mv_js_encoding.set(new abap.types.Character(4).set('utf8'));
+    } else if (abap.compare.eq(unique17, new abap.types.Character(4).set('4103'))) {
+      ret.get().mv_js_encoding.set(new abap.types.Character(7).set('utf16le'));
+    } else {
+      abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(13).set('not supported')));
+    }
+    return ret;
+  }
+  async uccpi(INPUT) {
+    return cl_abap_conv_out_ce.uccpi(INPUT);
+  }
+  static async uccpi(INPUT) {
+    let ret = new abap.types.Integer({qualifiedName: "I"});
+    let value = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.value) {value.set(INPUT.value);}
+    let lo_out = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_CONV_OUT_CE"});
+    let lv_hex = new abap.types.XString({qualifiedName: "XSTRING"});
+    lo_out.set((await this.create({encoding: new abap.types.Character(4).set('4103')})));
+    await lo_out.get().convert({data: value, buffer: lv_hex});
+    abap.statements.assert(abap.compare.eq(abap.builtin.xstrlen({val: lv_hex}), new abap.types.Integer().set(2)));
+    ret.set(lv_hex.getOffset({length: 1}));
+    ret.set(abap.operators.add(ret,abap.operators.multiply(lv_hex.getOffset({offset: 1, length: 1}),new abap.types.Integer().set(255))));
+    return ret;
+  }
+  async write(INPUT) {
+    let data = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.data) {data.set(INPUT.data);}
+    let res = new abap.types.XString({qualifiedName: "XSTRING"});
+    await this.convert({data: data, buffer: res});
+    abap.statements.concatenate({source: [this.mv_buffer, res], target: this.mv_buffer});
+  }
+  async get_buffer() {
+    let buffer = new abap.types.XString({qualifiedName: "XSTRING"});
+    buffer.set(this.mv_buffer);
+    return buffer;
+  }
+  async reset() {
+    abap.statements.clear(this.mv_buffer);
+  }
+  async convert(INPUT) {
+    let data = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.data) {data.set(INPUT.data);}
+    let n = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.n) {n.set(INPUT.n);}
+    let buffer = new abap.types.XString({qualifiedName: "XSTRING"});
+    if (INPUT && INPUT.buffer) {buffer = INPUT.buffer;}
+    let result = Buffer.from(data.get(), this.mv_js_encoding.get()).toString("hex");
+    buffer.set(result.toUpperCase());
+  }
+}
+abap.Classes['CL_ABAP_CONV_OUT_CE'] = cl_abap_conv_out_ce;
+export {cl_abap_conv_out_ce};
+//# sourceMappingURL=cl_abap_conv_out_ce.clas.mjs.map

package/output/cl_abap_conv_out_ce.clas.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [
+    "cl_abap_conv_out_ce.clas.abap"
+  ],
+  "names": [],
+  "mappings": ";;AAoCA;;;;;;;;;;EACE;;;;;;;;;;;;;;;IAEE,IACE,OAEA,IAHG,QAAL;;MAEI,GAAG,OAAE,mBAAiB,uCAAM;;MAE5B,GAAG,OAAE,mBAAiB,0CAAS;;MAE/B,oCAAS,GAAF,iCAAI,kDAAe;;IAEhC;;EAEA;;;;;;;QACO,0EAAsC;QACtC,2DAAmB;IACxB,YAAS,uEAA2B;6DAKf;IACrB,oCAAyB,GAAlB,2BAAS,UAAW,gCAAC;IAC5B,QAAM,6BAAS;IACf,QAAU,mBAAJ,IAAkB,wBAAZ,yCAAc,mCAAG;IAC/B;;EAEA;;;QACO,wDAAgB;iDAEY;IACjC,sCAAY,gBAAU,cAAS,cAAsB;EACvD;EAEA;;IACE,WAAS,cAAS;IACpB;;EAEA;IACE,sBAAM,cAAS;EACjB;EAEA;;;;;;;IAGE;IACA;EACF;AACF",
+  "file": "cl_abap_conv_out_ce.clas.mjs",
+  "sourceRoot": ""
+}

package/output/cl_abap_datadescr.clas.mjs

@@ -0,0 +1,35 @@
+const {cl_abap_typedescr} = await import("./cl_abap_typedescr.clas.mjs");
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cl_abap_datadescr.clas.abap
+class cl_abap_datadescr extends cl_abap_typedescr {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = [];
+  async constructor_(INPUT) {
+    await super.constructor_(INPUT);
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    return this;
+  }
+  async get_data_type_kind(INPUT) {
+    return cl_abap_datadescr.get_data_type_kind(INPUT);
+  }
+  static async get_data_type_kind(INPUT) {
+    let p_type_kind = new abap.types.Character(1, {"qualifiedName":"abap_typekind"});
+    let p_data = new abap.types.Character(4);
+    if (INPUT && INPUT.p_data) {p_data = INPUT.p_data;}
+    let descr = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_TYPEDESCR"});
+    descr.set((await abap.Classes['CL_ABAP_TYPEDESCR'].describe_by_data({p_data: p_data})));
+    p_type_kind.set(descr.get().type_kind);
+    return p_type_kind;
+  }
+  async applies_to_data(INPUT) {
+    let p_flag = new abap.types.Character(1, {"qualifiedName":"ABAP_BOOL","ddicName":"ABAP_BOOL"});
+    let p_data = new abap.types.Character(4);
+    if (INPUT && INPUT.p_data) {p_data = INPUT.p_data;}
+    abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(4).set('todo')));
+    return p_flag;
+  }
+}
+abap.Classes['CL_ABAP_DATADESCR'] = cl_abap_datadescr;
+export {cl_abap_datadescr};
+//# sourceMappingURL=cl_abap_datadescr.clas.mjs.map

package/output/cl_abap_datadescr.clas.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [
+    "cl_abap_datadescr.clas.abap"
+  ],
+  "names": [],
+  "mappings": ";;;AAeA;;;;;;;;;EAEE;;;;;;;QACO,uEAAmC;IACxC,WAAQ,2EAA6C;IACrD,gBAAc,KAAK,OAAE,SAAS;IAChC;;EAEA;;;;IACE,oCAAS,GAAF,iCAAI,wCAAM;IACnB;;AAEF",
+  "file": "cl_abap_datadescr.clas.mjs",
+  "sourceRoot": ""
+}

package/output/cl_abap_elemdescr.clas.mjs

@@ -0,0 +1,148 @@
+const {cl_abap_datadescr} = await import("./cl_abap_datadescr.clas.mjs");
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cl_abap_elemdescr.clas.abap
+class cl_abap_elemdescr extends cl_abap_datadescr {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = [];
+  async constructor_(INPUT) {
+    await super.constructor_(INPUT);
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.output_length = new abap.types.Integer({qualifiedName: "I"});
+    this.edit_mask = new abap.types.Character(7, {"qualifiedName":"abap_editmask"});
+    this.help_id = new abap.types.Character(62, {"qualifiedName":"abap_helpid"});
+    return this;
+  }
+  async get_p(INPUT) {
+    return cl_abap_elemdescr.get_p(INPUT);
+  }
+  static async get_p(INPUT) {
+    let p_result = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_ELEMDESCR"});
+    let p_length = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.p_length) {p_length.set(INPUT.p_length);}
+    let p_decimals = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.p_decimals) {p_decimals.set(INPUT.p_decimals);}
+    abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(4).set('todo')));
+    return p_result;
+  }
+  async get_n(INPUT) {
+    return cl_abap_elemdescr.get_n(INPUT);
+  }
+  static async get_n(INPUT) {
+    let p_result = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_ELEMDESCR"});
+    let p_length = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.p_length) {p_length.set(INPUT.p_length);}
+    abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(4).set('todo')));
+    return p_result;
+  }
+  async get_x(INPUT) {
+    return cl_abap_elemdescr.get_x(INPUT);
+  }
+  static async get_x(INPUT) {
+    let p_result = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_ELEMDESCR"});
+    let p_length = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.p_length) {p_length.set(INPUT.p_length);}
+    abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(4).set('todo')));
+    return p_result;
+  }
+  async get_xstring() {
+    return cl_abap_elemdescr.get_xstring();
+  }
+  static async get_xstring() {
+    let p_result = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_ELEMDESCR"});
+    abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(4).set('todo')));
+    return p_result;
+  }
+  async get_ddic_field(INPUT) {
+    let p_flddescr = new abap.types.Structure({"tabname": new abap.types.Character(30, {}), "fieldname": new abap.types.Character(30, {}), "langu": new abap.types.Character(1, {}), "position": new abap.types.Numc({length: 4}), "offset": new abap.types.Numc({length: 6}), "domname": new abap.types.Character(30, {}), "rollname": new abap.types.Character(30, {}), "checktable": new abap.types.Character(1, {}), "leng": new abap.types.Numc({length: 6}), "intlen": new abap.types.Numc({length: 6}), "outputlen": new abap.types.Numc({length: 6}), "decimals": new abap.types.Numc({length: 6}), "datatype": new abap.types.Character(1, {}), "inttype": new abap.types.Character(1, {}), "reftable": new abap.types.Character(1, {}), "reffield": new abap.types.Character(1, {}), "precfield": new abap.types.Character(1, {}), "authorid": new abap.types.Character(1, {}), "memoryid": new abap.types.Character(1, {}), "logflag": new abap.types.Character(1, {}), "mask": new abap.types.Character(1, {}), "masklen": new abap.types.Character(1, {}), "convexit": new abap.types.Character(1, {}), "headlen": new abap.types.Character(1, {}), "scrlen1": new abap.types.Character(1, {}), "scrlen2": new abap.types.Character(1, {}), "scrlen3": new abap.types.Character(1, {}), "fieldtext": new abap.types.Character(1, {}), "reptext": new abap.types.Character(1, {}), "scrtext_s": new abap.types.Character(1, {}), "scrtext_m": new abap.types.Character(1, {}), "scrtext_l": new abap.types.Character(1, {}), "keyflag": new abap.types.Character(1, {}), "lowercase": new abap.types.Character(1, {}), "mac": new abap.types.Character(1, {}), "genkey": new abap.types.Character(1, {}), "noforkey": new abap.types.Character(1, {}), "valexi": new abap.types.Character(1, {}), "noauthch": new abap.types.Character(1, {}), "sign": new abap.types.Character(1, {}), "dynpfld": new abap.types.Character(1, {}), "f4availabl": new abap.types.Character(1, {}), "comptype": new abap.types.Character(1, {}), "outputstyle": new abap.types.Character(1, {}), "lfieldname": new abap.types.Character(132, {})}, "DFIES");
+    let p_langu = new abap.types.Character(1, {"qualifiedName":"sy-langu","conversionExit":"ISOLA"});
+    if (INPUT && INPUT.p_langu) {p_langu = INPUT.p_langu;}
+    if (INPUT === undefined || INPUT.p_langu === undefined) {p_langu = abap.builtin.sy.get().langu;}
+    p_flddescr.get().tabname.set(this.absolute_name);
+    p_flddescr.get().inttype.set(this.type_kind);
+    p_flddescr.get().langu.set(abap.builtin.sy.get().langu);
+    p_flddescr.get().position.set(new abap.types.Integer().set(1));
+    p_flddescr.get().leng.set(this.length);
+    p_flddescr.get().decimals.set(this.decimals);
+    return p_flddescr;
+  }
+  async get_i() {
+    return cl_abap_elemdescr.get_i();
+  }
+  static async get_i() {
+    let r_result = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_ELEMDESCR"});
+    let foo = new abap.types.Integer({qualifiedName: "I"});
+    await abap.statements.cast(r_result, (await abap.Classes['CL_ABAP_TYPEDESCR'].describe_by_data({p_data: foo})));
+    return r_result;
+  }
+  async get_string() {
+    return cl_abap_elemdescr.get_string();
+  }
+  static async get_string() {
+    let p_result = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_ELEMDESCR"});
+    let foo = new abap.types.String({qualifiedName: "STRING"});
+    await abap.statements.cast(p_result, (await abap.Classes['CL_ABAP_TYPEDESCR'].describe_by_data({p_data: foo})));
+    return p_result;
+  }
+  async get_f() {
+    return cl_abap_elemdescr.get_f();
+  }
+  static async get_f() {
+    let r_result = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_ELEMDESCR"});
+    let foo = new abap.types.Float({qualifiedName: "F"});
+    await abap.statements.cast(r_result, (await abap.Classes['CL_ABAP_TYPEDESCR'].describe_by_data({p_data: foo})));
+    return r_result;
+  }
+  async get_d() {
+    return cl_abap_elemdescr.get_d();
+  }
+  static async get_d() {
+    let r_result = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_ELEMDESCR"});
+    let foo = new abap.types.Date({qualifiedName: "D"});
+    await abap.statements.cast(r_result, (await abap.Classes['CL_ABAP_TYPEDESCR'].describe_by_data({p_data: foo})));
+    return r_result;
+  }
+  async get_t() {
+    return cl_abap_elemdescr.get_t();
+  }
+  static async get_t() {
+    let r_result = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_ELEMDESCR"});
+    let foo = new abap.types.Time({qualifiedName: "T"});
+    await abap.statements.cast(r_result, (await abap.Classes['CL_ABAP_TYPEDESCR'].describe_by_data({p_data: foo})));
+    return r_result;
+  }
+  async get_c(INPUT) {
+    return cl_abap_elemdescr.get_c(INPUT);
+  }
+  static async get_c(INPUT) {
+    let p_result = new abap.types.ABAPObject({qualifiedName: "CL_ABAP_ELEMDESCR"});
+    let p_length = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.p_length) {p_length.set(INPUT.p_length);}
+    let foo = new abap.types.DataReference(new abap.types.Character(4));
+    abap.statements.createData(foo,{"typeName": "C","length": p_length});
+    await abap.statements.cast(p_result, (await abap.Classes['CL_ABAP_TYPEDESCR'].describe_by_data_ref({p_data_ref: foo})));
+    return p_result;
+  }
+  async get_ddic_fixed_values() {
+    let p_fixed_values = new abap.types.Table(new abap.types.Structure({"low": new abap.types.Character(10, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-low"}), "high": new abap.types.Character(10, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-high"}), "option": new abap.types.Character(2, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-option"}), "ddlanguage": new abap.types.Character(1, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-ddlanguage"}), "ddtext": new abap.types.Character(60, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-ddtext"})}, "cl_abap_elemdescr=>fixvalue"), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "cl_abap_elemdescr=>fixvalues");
+    let lv_dummy = new abap.types.String({qualifiedName: "STRING"});
+    let lv_name = new abap.types.String({qualifiedName: "STRING"});
+    let ls_row = new abap.types.Structure({"low": new abap.types.Character(10, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-low"}), "high": new abap.types.Character(10, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-high"}), "option": new abap.types.Character(2, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-option"}), "ddlanguage": new abap.types.Character(1, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-ddlanguage"}), "ddtext": new abap.types.Character(60, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-ddtext"})}, "cl_abap_elemdescr=>fixvalue");
+    abap.statements.split({source: this.absolute_name, at: new abap.types.Character(1).set('='), targets: [lv_dummy,lv_name]});
+    for (const f of abap.DDIC[lv_name.get()]?.fixedValues || []) {
+      abap.statements.clear(ls_row);
+        ls_row.get().low.set(f.low || "");
+        ls_row.get().high.set(f.high || "");
+        ls_row.get().option.set(f.option || "");
+        ls_row.get().ddlanguage.set(f.ddlanguage || "");
+        ls_row.get().ddtext.set(f.ddtext || "");
+      abap.statements.append({source: ls_row, target: p_fixed_values});
+    }
+    return p_fixed_values;
+  }
+}
+abap.Classes['CL_ABAP_ELEMDESCR'] = cl_abap_elemdescr;
+cl_abap_elemdescr.fixvalue = new abap.types.Structure({"low": new abap.types.Character(10, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-low"}), "high": new abap.types.Character(10, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-high"}), "option": new abap.types.Character(2, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-option"}), "ddlanguage": new abap.types.Character(1, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-ddlanguage"}), "ddtext": new abap.types.Character(60, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-ddtext"})}, "cl_abap_elemdescr=>fixvalue");
+cl_abap_elemdescr.fixvalues = new abap.types.Table(new abap.types.Structure({"low": new abap.types.Character(10, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-low"}), "high": new abap.types.Character(10, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-high"}), "option": new abap.types.Character(2, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-option"}), "ddlanguage": new abap.types.Character(1, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-ddlanguage"}), "ddtext": new abap.types.Character(60, {"qualifiedName":"cl_abap_elemdescr=>fixvalue-ddtext"})}, "cl_abap_elemdescr=>fixvalue"), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "cl_abap_elemdescr=>fixvalues");
+export {cl_abap_elemdescr};
+//# sourceMappingURL=cl_abap_elemdescr.clas.mjs.map

package/output/cl_abap_elemdescr.clas.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [
+    "cl_abap_elemdescr.clas.abap"
+  ],
+  "names": [],
+  "mappings": ";;;AA6DA;;;;;;;;;;;;EAEE;;;;;;;;;IACE,oCAAS,GAAF,iCAAI,wCAAM;IACnB;;EAEA;;;;;;;IACE,oCAAS,GAAF,iCAAI,wCAAM;IACnB;;EAEA;;;;;;;IACE,oCAAS,GAAF,iCAAI,wCAAM;IACnB;;EAEA;;;;;IACE,oCAAS,GAAF,iCAAI,wCAAM;IACnB;;EAEA;;;;;IACE,UAAU,MAAC,aAAW,kBAAa;IACnC,UAAU,MAAC,aAAW,cAAS;IAC/B,UAAU,MAAC,WAAW,eAAE,MAAC,MAAK;IAC9B,UAAU,MAAC,cAAW,+BAAC;IACvB,UAAU,MAAC,UAAW,WAAM;IAC5B,UAAU,MAAC,cAAW,aAAQ;IAEhC;;EAEA;;;;;QACO,kDAAU;+BACf,WAAY,wEAA0C;IACxD;;EAEA;;;;;QACO,sDAAe;+BACpB,WAAY,wEAA0C;IACxD;;EAEA;;;;;QACO,gDAAU;+BACf,WAAY,wEAA0C;IACxD;;EAEA;;;;;QACO,+CAAU;+BACf,WAAY,wEAA0C;IACxD;;EAEA;;;;;QACO,+CAAU;+BACf,WAAY,wEAA0C;IACxD;;EAEA;;;;;;;QACO,+DAAoB;;+BAEzB,WAAY,gFAA8C;IAC5D;;EAEA;;QAEO,2DAAoB;QACpB,0DAAoB;QACpB,8hBAAoC;IAEzC;IAEA;MACA,sBAAM,MAAM;MACZ;MACA;MACA;MACA;MACA;MACA,gCAAO,gBAAU,cAAc;IAC/B;IAEF;;AAEF",
+  "file": "cl_abap_elemdescr.clas.mjs",
+  "sourceRoot": ""
+}

package/output/cl_abap_enumdescr.clas.mjs

@@ -0,0 +1,19 @@
+const {cl_abap_elemdescr} = await import("./cl_abap_elemdescr.clas.mjs");
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cl_abap_enumdescr.clas.abap
+class cl_abap_enumdescr extends cl_abap_elemdescr {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = [];
+  async constructor_(INPUT) {
+    await super.constructor_(INPUT);
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.members = new abap.types.Table(new abap.types.Structure({"name": new abap.types.Character(30, {"qualifiedName":"cl_abap_enumdescr=>member-name"}), "value": new abap.types.String({qualifiedName: "CL_ABAP_ENUMDESCR=>MEMBER-VALUE"})}, "cl_abap_enumdescr=>member"), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":["NAME"]},"secondary":[]}, "cl_abap_enumdescr=>member_table");
+    return this;
+  }
+}
+abap.Classes['CL_ABAP_ENUMDESCR'] = cl_abap_enumdescr;
+cl_abap_enumdescr.member = new abap.types.Structure({"name": new abap.types.Character(30, {"qualifiedName":"cl_abap_enumdescr=>member-name"}), "value": new abap.types.String({qualifiedName: "CL_ABAP_ENUMDESCR=>MEMBER-VALUE"})}, "cl_abap_enumdescr=>member");
+cl_abap_enumdescr.member_table = new abap.types.Table(new abap.types.Structure({"name": new abap.types.Character(30, {"qualifiedName":"cl_abap_enumdescr=>member-name"}), "value": new abap.types.String({qualifiedName: "CL_ABAP_ENUMDESCR=>MEMBER-VALUE"})}, "cl_abap_enumdescr=>member"), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":["NAME"]},"secondary":[]}, "cl_abap_enumdescr=>member_table");
+export {cl_abap_enumdescr};
+//# sourceMappingURL=cl_abap_enumdescr.clas.mjs.map

package/output/cl_abap_enumdescr.clas.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [
+    "cl_abap_enumdescr.clas.abap"
+  ],
+  "names": [],
+  "mappings": ";;;AAUA;;;;;;;;;;AAEA",
+  "file": "cl_abap_enumdescr.clas.mjs",
+  "sourceRoot": ""
+}

package/output/cl_abap_exceptional_values.clas.mjs

@@ -0,0 +1,65 @@
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cl_abap_exceptional_values.clas.abap
+class cl_abap_exceptional_values {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = [];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    return this;
+  }
+  async get_max_value(INPUT) {
+    return cl_abap_exceptional_values.get_max_value(INPUT);
+  }
+  static async get_max_value(INPUT) {
+    let out = new abap.types.DataReference(new abap.types.Character(4));
+    let in_ = new abap.types.Character(4);
+    if (INPUT && INPUT.in_) {in_ = INPUT.in_;}
+    let lv_type = new abap.types.Character(1, {});
+    let lv_length = new abap.types.Integer({qualifiedName: "I"});
+    let lv_decimals = new abap.types.Integer({qualifiedName: "I"});
+    let fs_out_ = new abap.types.FieldSymbol(new abap.types.Character(4));
+    abap.statements.describe({field: in_, type: lv_type});
+    let unique1 = lv_type;
+    if (abap.compare.eq(unique1, abap.Classes['CL_ABAP_TYPEDESCR'].typekind_int)) {
+      out.assign(abap.Classes['CL_ABAP_MATH'].max_int4);
+    } else if (abap.compare.eq(unique1, abap.Classes['CL_ABAP_TYPEDESCR'].typekind_packed)) {
+      abap.statements.describe({field: in_, length: lv_length, decimals: lv_decimals, mode: 'BYTE'});
+      abap.statements.createData(out,{"typeName": "P","length": lv_length,"decimals": lv_decimals});
+      abap.statements.assign({target: fs_out_, source: (out).dereference()});
+      if (abap.compare.eq(lv_length, new abap.types.Integer().set(3)) && abap.compare.eq(lv_decimals, new abap.types.Integer().set(1))) {
+        fs_out_.set(new abap.types.Character(6).set('9999.9'));
+      } else {
+        abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(4).set('todo')));
+      }
+    } else {
+      abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(4).set('todo')));
+    }
+    return out;
+  }
+  async get_min_value(INPUT) {
+    return cl_abap_exceptional_values.get_min_value(INPUT);
+  }
+  static async get_min_value(INPUT) {
+    let out = new abap.types.DataReference(new abap.types.Character(4));
+    let in_ = new abap.types.Character(4);
+    if (INPUT && INPUT.in_) {in_ = INPUT.in_;}
+    let lv_type = new abap.types.Character(1, {});
+    let fs_out_ = new abap.types.FieldSymbol(new abap.types.Character(4));
+    abap.statements.describe({field: in_, type: lv_type});
+    let unique2 = lv_type;
+    if (abap.compare.eq(unique2, abap.Classes['CL_ABAP_TYPEDESCR'].typekind_int)) {
+      out.assign(abap.Classes['CL_ABAP_MATH'].min_int4);
+    } else if (abap.compare.eq(unique2, abap.Classes['CL_ABAP_TYPEDESCR'].typekind_packed)) {
+      out.set((await this.get_max_value({in_: in_})));
+      abap.statements.assign({target: fs_out_, source: (out).dereference()});
+      fs_out_.set(abap.operators.multiply(fs_out_,new abap.types.Integer().set(-1)));
+    } else {
+      abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(4).set('todo')));
+    }
+    return out;
+  }
+}
+abap.Classes['CL_ABAP_EXCEPTIONAL_VALUES'] = cl_abap_exceptional_values;
+export {cl_abap_exceptional_values};
+//# sourceMappingURL=cl_abap_exceptional_values.clas.mjs.map

package/output/cl_abap_exceptional_values.clas.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [
+    "cl_abap_exceptional_values.clas.abap"
+  ],
+  "names": [],
+  "mappings": ";;AAeA;;;;;;;;EAEE;;;;;;;QACO,yCAA2B;QAC3B,wDAAkB;QAClB,0DAAkB;IACvB,IAAc,OAAc;IAE5B,mDAA+B;IAE/B,IACE,OAEA,GAHG,OAAL;;MAEiD,WAA5B,6BAAc,QAAiB;;MAEhD,4FAAqE;;MAGrE,oEAAsB;MAEtB,iBAAa,GAAV,WAAY,gCAAE,iBAAgB,GAAZ,aAAc,gCAAC;QAClC,YAAQ,yCAAQ;MAClB;QACE,oCAAS,GAAF,iCAAI,wCAAM;MACnB;;MAEA,oCAAS,GAAF,iCAAI,wCAAM;;IAEvB;;EAEA;;;;;;;QACO,yCAAuB;IAC5B,IAAc,OAAc;IAE5B,mDAA+B;IAE/B,IACE,OAEA,GAHG,OAAL;;MAEiD,WAA5B,6BAAc,QAAiB;;MAEhD,SAAM,qCAAoB;MAC1B,oEAAsB;MACtB,YAAc,wBAAN,QAAQ,iCAAE;;MAElB,oCAAS,GAAF,iCAAI,wCAAM;;IAEvB;;AAEF",
+  "file": "cl_abap_exceptional_values.clas.mjs",
+  "sourceRoot": ""
+}

package/output/cl_abap_format.clas.mjs

@@ -0,0 +1,26 @@
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cl_abap_format.clas.abap
+class cl_abap_format {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = [];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.e_html_attr = cl_abap_format.e_html_attr;
+    this.e_html_text = cl_abap_format.e_html_text;
+    this.e_json_string = cl_abap_format.e_json_string;
+    this.e_url = cl_abap_format.e_url;
+    return this;
+  }
+}
+abap.Classes['CL_ABAP_FORMAT'] = cl_abap_format;
+cl_abap_format.e_html_attr = new abap.types.Integer({qualifiedName: "I"});
+cl_abap_format.e_html_attr.set(5);
+cl_abap_format.e_html_text = new abap.types.Integer({qualifiedName: "I"});
+cl_abap_format.e_html_text.set(4);
+cl_abap_format.e_json_string = new abap.types.Integer({qualifiedName: "I"});
+cl_abap_format.e_json_string.set(24);
+cl_abap_format.e_url = new abap.types.Integer({qualifiedName: "I"});
+cl_abap_format.e_url.set(12);
+export {cl_abap_format};
+//# sourceMappingURL=cl_abap_format.clas.mjs.map

package/output/cl_abap_format.clas.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [
+    "cl_abap_format.clas.abap"
+  ],
+  "names": [],
+  "mappings": ";;AAQA;;;;;;;;;;;;AAEA",
+  "file": "cl_abap_format.clas.mjs",
+  "sourceRoot": ""
+}