@abaplint/transpiler-cli 2.3.111 → 2.3.112

package/output/cl_sxml_string_reader.clas.locals.mjs

@@ -0,0 +1,323 @@
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cl_sxml_string_reader.clas.locals_imp.abap
+class lcl_json_parser {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = [];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.mt_nodes = new abap.types.Table(new abap.types.Structure({"type": new abap.types.Integer({qualifiedName: "IF_SXML_NODE=>NODE_TYPE"}), "name": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-NAME"}), "key": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-KEY"}), "value": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-VALUE"})}, "lcl_json_parser=>ty_node"), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "lcl_json_parser=>ty_nodes");
+    return this;
+  }
+  async parse(INPUT) {
+    let rt_nodes = new abap.types.Table(new abap.types.Structure({"type": new abap.types.Integer({qualifiedName: "IF_SXML_NODE=>NODE_TYPE"}), "name": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-NAME"}), "key": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-KEY"}), "value": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-VALUE"})}, "lcl_json_parser=>ty_node"), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "lcl_json_parser=>ty_nodes");
+    let iv_json = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.iv_json) {iv_json.set(INPUT.iv_json);}
+    abap.statements.clear(this.mt_nodes);
+    await this.traverse({iv_json: iv_json});
+    rt_nodes.set(this.mt_nodes);
+    return rt_nodes;
+  }
+  async append(INPUT) {
+    let iv_type = new abap.types.Integer({qualifiedName: "IF_SXML_NODE=>NODE_TYPE"});
+    if (INPUT && INPUT.iv_type) {iv_type.set(INPUT.iv_type);}
+    let iv_name = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.iv_name) {iv_name.set(INPUT.iv_name);}
+    let iv_key = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.iv_key) {iv_key.set(INPUT.iv_key);}
+    let iv_value = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.iv_value) {iv_value.set(INPUT.iv_value);}
+    let ls_node = new abap.types.Structure({"type": new abap.types.Integer({qualifiedName: "IF_SXML_NODE=>NODE_TYPE"}), "name": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-NAME"}), "key": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-KEY"}), "value": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-VALUE"})}, "lcl_json_parser=>ty_node");
+    ls_node.get().type.set(iv_type);
+    ls_node.get().name.set(iv_name);
+    ls_node.get().key.set(iv_key);
+    ls_node.get().value.set(iv_value);
+    abap.statements.append({source: ls_node, target: this.mt_nodes});
+  }
+  async traverse(INPUT) {
+    let iv_json = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.iv_json) {iv_json.set(INPUT.iv_json);}
+    let iv_key = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.iv_key) {iv_key.set(INPUT.iv_key);}
+    let lv_type = new abap.types.String({qualifiedName: "STRING"});
+    let lv_error = new abap.types.Character(1, {"qualifiedName":"ABAP_BOOL","ddicName":"ABAP_BOOL"});
+    let lv_error_message = new abap.types.String({qualifiedName: "STRING"});
+    let lv_xml_offset = new abap.types.Integer({qualifiedName: "I"});
+    let parsed;
+    try {
+        parsed = JSON.parse(iv_json.get());
+    } catch(e) {
+        lv_error_message.set(e.message);
+        lv_error.set("X")
+    }
+    if (abap.compare.eq(lv_error, abap.builtin.abap_true)) {
+      abap.statements.find(lv_error_message, {regex: new abap.types.Character(15).set(' position (\\d+)'), submatches: [lv_xml_offset]});
+      throw await (new abap.Classes['CX_SXML_PARSE_ERROR']()).constructor_({xml_offset: lv_xml_offset});
+    }
+    lv_type.set(Array.isArray(parsed) ? "array" : typeof parsed);
+    if (parsed === null) lv_type.set("null");
+    let unique79 = lv_type;
+    if (abap.compare.eq(unique79, new abap.types.Character(6).set('object'))) {
+      await this.traverse_object({iv_json: iv_json, iv_key: iv_key});
+    } else if (abap.compare.eq(unique79, new abap.types.Character(5).set('array'))) {
+      await this.traverse_array({iv_json: iv_json, iv_key: iv_key});
+    } else if (abap.compare.eq(unique79, new abap.types.Character(6).set('string')) || abap.compare.eq(unique79, new abap.types.Character(7).set('boolean')) || abap.compare.eq(unique79, new abap.types.Character(6).set('number')) || abap.compare.eq(unique79, new abap.types.Character(4).set('null'))) {
+      await this.traverse_basic({iv_json: iv_json, iv_key: iv_key});
+    } else {
+      abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(2), new abap.types.Character(4).set('todo')));
+    }
+  }
+  async traverse_basic(INPUT) {
+    let iv_json = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.iv_json) {iv_json.set(INPUT.iv_json);}
+    let iv_key = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.iv_key) {iv_key.set(INPUT.iv_key);}
+    let lv_type = new abap.types.String({qualifiedName: "STRING"});
+    let parsed = JSON.parse(iv_json.get());
+    lv_type.set(typeof parsed);
+    if (parsed === null) lv_type.set("null");
+    let unique80 = lv_type;
+    if (abap.compare.eq(unique80, new abap.types.Character(6).set('string'))) {
+      lv_type.set(new abap.types.Character(3).set('str'));
+    } else if (abap.compare.eq(unique80, new abap.types.Character(6).set('number'))) {
+      lv_type.set(new abap.types.Character(3).set('num'));
+    } else if (abap.compare.eq(unique80, new abap.types.Character(7).set('boolean'))) {
+      lv_type.set(new abap.types.Character(4).set('bool'));
+    }
+    await this.append({iv_type: abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_element_open, iv_name: lv_type, iv_key: iv_key});
+    if (abap.compare.ne(lv_type, new abap.types.Character(4).set('null'))) {
+      if (abap.compare.eq(lv_type, new abap.types.Character(3).set('str'))) {
+        await this.append({iv_type: abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_value, iv_value: abap.builtin.substring({val: iv_json, off: new abap.types.Integer().set(1), len: abap.operators.minus(abap.builtin.strlen({val: iv_json}),new abap.types.Integer().set(2))})});
+      } else {
+        await this.append({iv_type: abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_value, iv_value: iv_json});
+      }
+    }
+    await this.append({iv_type: abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_element_close, iv_name: lv_type});
+  }
+  async traverse_array(INPUT) {
+    let iv_json = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.iv_json) {iv_json.set(INPUT.iv_json);}
+    let iv_key = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.iv_key) {iv_key.set(INPUT.iv_key);}
+    let lv_value = new abap.types.String({qualifiedName: "STRING"});
+    let lv_length = new abap.types.Integer({qualifiedName: "I"});
+    let lv_index = new abap.types.Integer({qualifiedName: "I"});
+    let parsed = JSON.parse(iv_json.get());
+    lv_length.set(parsed.length);
+    await this.append({iv_type: abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_element_open, iv_name: new abap.types.Character(5).set('array'), iv_key: iv_key});
+    const indexBackup1 = abap.builtin.sy.get().index.get();
+    const unique81 = lv_length.get();
+    for (let unique82 = 0; unique82 < unique81; unique82++) {
+      abap.builtin.sy.get().index.set(unique82 + 1);
+      lv_index.set(abap.operators.minus(abap.builtin.sy.get().index,new abap.types.Integer().set(1)));
+      lv_value.set(JSON.stringify(parsed[lv_index.get()]));
+      await this.traverse({iv_json: lv_value});
+    }
+    abap.builtin.sy.get().index.set(indexBackup1);
+    await this.append({iv_type: abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_element_close, iv_name: new abap.types.Character(5).set('array')});
+  }
+  async traverse_object(INPUT) {
+    let iv_json = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.iv_json) {iv_json.set(INPUT.iv_json);}
+    let iv_key = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.iv_key) {iv_key.set(INPUT.iv_key);}
+    let lt_keys = new abap.types.Table(new abap.types.String({qualifiedName: "STRING"}), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "");
+    let lv_key = new abap.types.String({qualifiedName: "STRING"});
+    let lv_value = new abap.types.String({qualifiedName: "STRING"});
+    let parsed = JSON.parse(iv_json.get());
+    Object.keys(parsed).forEach(k => lt_keys.append(k));
+    await this.append({iv_type: abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_element_open, iv_name: new abap.types.Character(6).set('object'), iv_key: iv_key});
+    for await (const unique83 of abap.statements.loop(lt_keys)) {
+      lv_key.set(unique83);
+      lv_value.set(JSON.stringify(parsed[lv_key.get()]));
+      await this.traverse({iv_json: lv_value, iv_key: lv_key});
+    }
+    await this.append({iv_type: abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_element_close, iv_name: new abap.types.Character(6).set('object')});
+  }
+}
+abap.Classes['CLAS-CL_SXML_STRING_READER-LCL_JSON_PARSER'] = lcl_json_parser;
+lcl_json_parser.ty_node = new abap.types.Structure({"type": new abap.types.Integer({qualifiedName: "IF_SXML_NODE=>NODE_TYPE"}), "name": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-NAME"}), "key": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-KEY"}), "value": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-VALUE"})}, "lcl_json_parser=>ty_node");
+lcl_json_parser.ty_nodes = new abap.types.Table(new abap.types.Structure({"type": new abap.types.Integer({qualifiedName: "IF_SXML_NODE=>NODE_TYPE"}), "name": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-NAME"}), "key": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-KEY"}), "value": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-VALUE"})}, "lcl_json_parser=>ty_node"), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "lcl_json_parser=>ty_nodes");
+class lcl_attribute {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = ["IF_SXML_ATTRIBUTE"];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.mv_value = new abap.types.String({qualifiedName: "STRING"});
+    this.if_sxml_attribute$qname = new abap.types.Structure({"name": new abap.types.String({qualifiedName: "STRING"})});
+    this.if_sxml_attribute$value_type = new abap.types.Integer({qualifiedName: "IF_SXML_VALUE=>VALUE_TYPE"});
+    let name = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.name) {name.set(INPUT.name);}
+    let value = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.value) {value.set(INPUT.value);}
+    let value_type = new abap.types.Integer({qualifiedName: "IF_SXML_VALUE=>VALUE_TYPE"});
+    if (INPUT && INPUT.value_type) {value_type.set(INPUT.value_type);}
+    this.if_sxml_attribute$qname.get().name.set(name);
+    this.if_sxml_attribute$value_type.set(value_type);
+    this.mv_value.set(value);
+    return this;
+  }
+  async if_sxml_attribute$get_value() {
+    let value = new abap.types.String({qualifiedName: "STRING"});
+    value.set(this.mv_value);
+    return value;
+  }
+}
+abap.Classes['CLAS-CL_SXML_STRING_READER-LCL_ATTRIBUTE'] = lcl_attribute;
+class lcl_open_node {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = ["IF_SXML_OPEN_ELEMENT"];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.mt_attributes = new abap.types.Table(new abap.types.ABAPObject({qualifiedName: "IF_SXML_ATTRIBUTE"}), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "if_sxml_attribute=>attributes");
+    this.if_sxml_open_element$qname = new abap.types.Structure({"name": new abap.types.String({qualifiedName: "STRING"})});
+    this.if_sxml_node$type = new abap.types.Integer({qualifiedName: "IF_SXML_NODE=>NODE_TYPE"});
+    let name = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.name) {name.set(INPUT.name);}
+    let attributes = new abap.types.Table(new abap.types.ABAPObject({qualifiedName: "IF_SXML_ATTRIBUTE"}), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "if_sxml_attribute=>attributes");
+    if (INPUT && INPUT.attributes) {attributes.set(INPUT.attributes);}
+    this.if_sxml_node$type.set(abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_element_open);
+    this.if_sxml_open_element$qname.get().name.set(name);
+    this.mt_attributes.set(attributes);
+    return this;
+  }
+  async if_sxml_open_element$get_attributes() {
+    let attr = new abap.types.Table(new abap.types.ABAPObject({qualifiedName: "IF_SXML_ATTRIBUTE"}), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "if_sxml_attribute=>attributes");
+    attr.set(this.mt_attributes);
+    return attr;
+  }
+}
+abap.Classes['CLAS-CL_SXML_STRING_READER-LCL_OPEN_NODE'] = lcl_open_node;
+class lcl_close_node {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = ["IF_SXML_CLOSE_ELEMENT"];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.if_sxml_close_element$qname = new abap.types.Structure({"name": new abap.types.String({qualifiedName: "STRING"})});
+    this.if_sxml_node$type = new abap.types.Integer({qualifiedName: "IF_SXML_NODE=>NODE_TYPE"});
+    let name = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.name) {name.set(INPUT.name);}
+    this.if_sxml_node$type.set(abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_element_close);
+    this.if_sxml_close_element$qname.get().name.set(name);
+    return this;
+  }
+}
+abap.Classes['CLAS-CL_SXML_STRING_READER-LCL_CLOSE_NODE'] = lcl_close_node;
+class lcl_value_node {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = ["IF_SXML_VALUE_NODE"];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.mv_value = new abap.types.String({qualifiedName: "STRING"});
+    this.if_sxml_node$type = new abap.types.Integer({qualifiedName: "IF_SXML_NODE=>NODE_TYPE"});
+    let value = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.value) {value.set(INPUT.value);}
+    this.if_sxml_node$type.set(abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_value);
+    this.mv_value.set(value);
+    return this;
+  }
+  async if_sxml_value_node$get_value() {
+    let val = new abap.types.String({qualifiedName: "STRING"});
+    val.set(this.mv_value);
+    return val;
+  }
+}
+abap.Classes['CLAS-CL_SXML_STRING_READER-LCL_VALUE_NODE'] = lcl_value_node;
+class lcl_reader {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = ["IF_SXML_READER"];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.mv_json = new abap.types.String({qualifiedName: "STRING"});
+    this.mt_nodes = new abap.types.Table(new abap.types.ABAPObject({qualifiedName: "IF_SXML_NODE"}), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "lcl_reader=>ty_nodes");
+    this.mv_pointer = new abap.types.Integer({qualifiedName: "I"});
+    this.if_sxml_reader$node_type = new abap.types.Integer({qualifiedName: "IF_SXML_NODE=>NODE_TYPE"});
+    this.if_sxml_reader$name = new abap.types.String({qualifiedName: "STRING"});
+    this.if_sxml_reader$value = new abap.types.String({qualifiedName: "STRING"});
+    let iv_json = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.iv_json) {iv_json.set(INPUT.iv_json);}
+    this.mv_json.set(iv_json);
+    return this;
+  }
+  async initialize() {
+    let lo_json = new abap.types.ABAPObject({qualifiedName: "LCL_JSON_PARSER"});
+    let lt_parsed = new abap.types.Table(new abap.types.Structure({"type": new abap.types.Integer({qualifiedName: "IF_SXML_NODE=>NODE_TYPE"}), "name": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-NAME"}), "key": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-KEY"}), "value": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-VALUE"})}, "lcl_json_parser=>ty_node"), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "lcl_json_parser=>ty_nodes");
+    let ls_parsed = new abap.types.Structure({"type": new abap.types.Integer({qualifiedName: "IF_SXML_NODE=>NODE_TYPE"}), "name": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-NAME"}), "key": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-KEY"}), "value": new abap.types.String({qualifiedName: "LCL_JSON_PARSER=>TY_NODE-VALUE"})}, "lcl_json_parser=>ty_node");
+    let li_node = new abap.types.ABAPObject({qualifiedName: "IF_SXML_NODE"});
+    let lt_attributes = new abap.types.Table(new abap.types.ABAPObject({qualifiedName: "IF_SXML_ATTRIBUTE"}), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "if_sxml_attribute=>attributes");
+    let li_attribute = new abap.types.ABAPObject({qualifiedName: "IF_SXML_ATTRIBUTE"});
+    if (abap.compare.initial(this.mv_json)) {
+      return;
+    }
+    lo_json.set(await (new abap.Classes['CLAS-CL_SXML_STRING_READER-LCL_JSON_PARSER']()).constructor_());
+    lt_parsed.set((await lo_json.get().parse({iv_json: this.mv_json})));
+    for await (const unique84 of abap.statements.loop(lt_parsed)) {
+      ls_parsed.set(unique84);
+      let unique85 = ls_parsed.get().type;
+      if (abap.compare.eq(unique85, abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_element_open)) {
+        abap.statements.clear(lt_attributes);
+        if (abap.compare.initial(ls_parsed.get().key) === false) {
+          li_attribute.set(await (new abap.Classes['CLAS-CL_SXML_STRING_READER-LCL_ATTRIBUTE']()).constructor_({name: new abap.types.Character(4).set('name'), value: ls_parsed.get().key, value_type: abap.Classes['IF_SXML_VALUE'].if_sxml_value$co_vt_text}));
+          abap.statements.append({source: li_attribute, target: lt_attributes});
+        }
+        li_node.set(await (new abap.Classes['CLAS-CL_SXML_STRING_READER-LCL_OPEN_NODE']()).constructor_({name: ls_parsed.get().name, attributes: lt_attributes}));
+      } else if (abap.compare.eq(unique85, abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_element_close)) {
+        li_node.set(await (new abap.Classes['CLAS-CL_SXML_STRING_READER-LCL_CLOSE_NODE']()).constructor_({name: ls_parsed.get().name}));
+      } else if (abap.compare.eq(unique85, abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_value)) {
+        li_node.set(await (new abap.Classes['CLAS-CL_SXML_STRING_READER-LCL_VALUE_NODE']()).constructor_({value: ls_parsed.get().value}));
+      } else {
+        abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Integer().set(2)));
+      }
+      abap.statements.append({source: li_node, target: this.mt_nodes});
+    }
+    abap.statements.clear(this.mv_json);
+    this.mv_pointer.set(new abap.types.Integer().set(1));
+  }
+  async if_sxml_reader$next_attribute(INPUT) {
+    let value_type = new abap.types.Integer({qualifiedName: "IF_SXML_VALUE=>VALUE_TYPE"});
+    if (INPUT && INPUT.value_type) {value_type.set(INPUT.value_type);}
+    abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(4).set('todo')));
+  }
+  async if_sxml_reader$next_node(INPUT) {
+    let value_type = new abap.types.Integer({qualifiedName: "IF_SXML_VALUE=>VALUE_TYPE"});
+    if (INPUT && INPUT.value_type) {value_type.set(INPUT.value_type);}
+    if (INPUT === undefined || INPUT.value_type === undefined) {value_type = abap.Classes['IF_SXML_VALUE'].co_vt_text;}
+    let node = new abap.types.ABAPObject({qualifiedName: "IF_SXML_NODE"});
+    let open = new abap.types.ABAPObject({qualifiedName: "IF_SXML_OPEN_ELEMENT"});
+    let close = new abap.types.ABAPObject({qualifiedName: "IF_SXML_CLOSE_ELEMENT"});
+    let value = new abap.types.ABAPObject({qualifiedName: "IF_SXML_VALUE_NODE"});
+    await this.initialize();
+    abap.statements.readTable(this.mt_nodes,{index: this.mv_pointer,into: node});
+    this.mv_pointer.set(abap.operators.add(this.mv_pointer,new abap.types.Integer().set(1)));
+    this.if_sxml_reader$node_type.set(node.get().if_sxml_node$type);
+    abap.statements.clear(this.if_sxml_reader$name);
+    let unique86 = this.if_sxml_reader$node_type;
+    if (abap.compare.eq(unique86, abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_element_open)) {
+      await abap.statements.cast(open, node);
+      this.if_sxml_reader$name.set(open.get().if_sxml_open_element$qname.get().name);
+    } else if (abap.compare.eq(unique86, abap.Classes['IF_SXML_NODE'].if_sxml_node$co_nt_element_close)) {
+      await abap.statements.cast(close, node);
+      this.if_sxml_reader$name.set(close.get().if_sxml_close_element$qname.get().name);
+    }
+  }
+  async if_sxml_reader$skip_node(INPUT) {
+    let writer = new abap.types.ABAPObject({qualifiedName: "IF_SXML_WRITER"});
+    if (INPUT && INPUT.writer) {writer.set(INPUT.writer);}
+  }
+  async if_sxml_reader$read_next_node() {
+    let node = new abap.types.ABAPObject({qualifiedName: "IF_SXML_NODE"});
+    await this.initialize();
+    abap.statements.readTable(this.mt_nodes,{index: this.mv_pointer,into: node});
+    this.mv_pointer.set(abap.operators.add(this.mv_pointer,new abap.types.Integer().set(1)));
+    return node;
+  }
+}
+abap.Classes['CLAS-CL_SXML_STRING_READER-LCL_READER'] = lcl_reader;
+lcl_reader.ty_nodes = new abap.types.Table(new abap.types.ABAPObject({qualifiedName: "IF_SXML_NODE"}), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "lcl_reader=>ty_nodes");
+export {lcl_json_parser, lcl_attribute, lcl_open_node, lcl_close_node, lcl_value_node, lcl_reader};
+//# sourceMappingURL=cl_sxml_string_reader.clas.locals.mjs.map

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

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [
+    "cl_sxml_string_reader.clas.locals_imp.abap"
+  ],
+  "names": [],
+  "mappings": "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",
+  "file": "cl_sxml_string_reader.clas.locals.mjs",
+  "sourceRoot": ""
+}

package/output/cl_sxml_string_reader.clas.mjs

@@ -0,0 +1,25 @@
+await import("./cl_sxml_string_reader.clas.locals.mjs");
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cl_sxml_string_reader.clas.abap
+class cl_sxml_string_reader {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = [];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    return this;
+  }
+  async create(INPUT) {
+    return cl_sxml_string_reader.create(INPUT);
+  }
+  static async create(INPUT) {
+    let reader = new abap.types.ABAPObject({qualifiedName: "IF_SXML_READER"});
+    let data = new abap.types.XString({qualifiedName: "XSTRING"});
+    if (INPUT && INPUT.data) {data.set(INPUT.data);}
+    reader.set(await (new abap.Classes['CLAS-CL_SXML_STRING_READER-LCL_READER']()).constructor_({iv_json: (await abap.Classes['CL_ABAP_CODEPAGE'].convert_from({source: data}))}));
+    return reader;
+  }
+}
+abap.Classes['CL_SXML_STRING_READER'] = cl_sxml_string_reader;
+export {cl_sxml_string_reader};
+//# sourceMappingURL=cl_sxml_string_reader.clas.mjs.map

package/output/cl_sxml_string_reader.clas.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [
+    "cl_sxml_string_reader.clas.abap"
+  ],
+  "names": [],
+  "mappings": ";;;AAOA;;;;;;;;EACE;;;;;;;;IAIA;;AACF",
+  "file": "cl_sxml_string_reader.clas.mjs",
+  "sourceRoot": ""
+}

package/output/cl_sxml_string_writer.clas.mjs

@@ -0,0 +1,146 @@
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cl_sxml_string_writer.clas.abap
+class cl_sxml_string_writer {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = ["IF_SXML_WRITER"];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    this.mv_output = new abap.types.XString({qualifiedName: "XSTRING"});
+    this.mv_type = new abap.types.Integer({qualifiedName: "IF_SXML=>XML_STREAM_TYPE"});
+    this.mt_stack = new abap.types.Table(new abap.types.String({qualifiedName: "STRING"}), {"withHeader":false,"primaryKey":{"name":"primary_key","type":"STANDARD","isUnique":false,"keyFields":[]},"secondary":[]}, "");
+    let type = new abap.types.Integer({qualifiedName: "IF_SXML=>XML_STREAM_TYPE"});
+    if (INPUT && INPUT.type) {type.set(INPUT.type);}
+    this.mv_type.set(type);
+    return this;
+  }
+  async create(INPUT) {
+    return cl_sxml_string_writer.create(INPUT);
+  }
+  static async create(INPUT) {
+    let writer = new abap.types.ABAPObject({qualifiedName: "CL_SXML_STRING_WRITER"});
+    let type = new abap.types.Integer({qualifiedName: "IF_SXML=>XML_STREAM_TYPE"});
+    if (INPUT && INPUT.type) {type.set(INPUT.type);}
+    if (INPUT === undefined || INPUT.type === undefined) {type = abap.Classes['IF_SXML'].if_sxml$co_xt_xml10;}
+    let ignore_conversion_errors = new abap.types.Character(1, {"qualifiedName":"ABAP_BOOL","ddicName":"ABAP_BOOL"});
+    if (INPUT && INPUT.ignore_conversion_errors) {ignore_conversion_errors = INPUT.ignore_conversion_errors;}
+    if (INPUT === undefined || INPUT.ignore_conversion_errors === undefined) {ignore_conversion_errors = abap.builtin.abap_false;}
+    let normalizing = new abap.types.Character(1, {"qualifiedName":"ABAP_BOOL","ddicName":"ABAP_BOOL"});
+    if (INPUT && INPUT.normalizing) {normalizing = INPUT.normalizing;}
+    if (INPUT === undefined || INPUT.normalizing === undefined) {normalizing = abap.builtin.abap_false;}
+    let no_empty_elements = new abap.types.Character(1, {"qualifiedName":"ABAP_BOOL","ddicName":"ABAP_BOOL"});
+    if (INPUT && INPUT.no_empty_elements) {no_empty_elements = INPUT.no_empty_elements;}
+    if (INPUT === undefined || INPUT.no_empty_elements === undefined) {no_empty_elements = abap.builtin.abap_false;}
+    let encoding = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.encoding) {encoding.set(INPUT.encoding);}
+    if (INPUT === undefined || INPUT.encoding === undefined) {encoding = new abap.types.Character(5).set('UTF-8');}
+    writer.set(await (new abap.Classes['CL_SXML_STRING_WRITER']()).constructor_({type: type}));
+    return writer;
+  }
+  async if_sxml_writer$set_option(INPUT) {
+    let option = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.option) {option.set(INPUT.option);}
+    let value = new abap.types.Character(1, {"qualifiedName":"ABAP_BOOL","ddicName":"ABAP_BOOL"});
+    if (INPUT && INPUT.value) {value = INPUT.value;}
+    if (INPUT === undefined || INPUT.value === undefined) {value = abap.builtin.abap_true;}
+    abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(4).set('todo')));
+  }
+  async get_output() {
+    let output = new abap.types.XString({qualifiedName: "XSTRING"});
+    output.set(this.mv_output);
+    return output;
+  }
+  async append_text(INPUT) {
+    let text = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.text) {text.set(INPUT.text);}
+    let append = new abap.types.XString({qualifiedName: "XSTRING"});
+    append.set((await (await abap.Classes['CL_ABAP_CONV_CODEPAGE'].create_out()).get().if_abap_conv_out$convert({source: text})));
+    abap.statements.concatenate({source: [this.mv_output, append], target: this.mv_output});
+  }
+  async get_text() {
+    let text = new abap.types.String({qualifiedName: "STRING"});
+    text.set((await (await abap.Classes['CL_ABAP_CONV_CODEPAGE'].create_in()).get().if_abap_conv_in$convert({source: this.mv_output})));
+    return text;
+  }
+  async if_sxml_writer$open_element(INPUT) {
+    let name = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.name) {name.set(INPUT.name);}
+    let nsuri = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.nsuri) {nsuri.set(INPUT.nsuri);}
+    let prefix = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.prefix) {prefix.set(INPUT.prefix);}
+    let parent = new abap.types.String({qualifiedName: "STRING"});
+    parent.set((await this.peek()));
+    if (abap.compare.eq(parent, new abap.types.Character(5).set('array')) && abap.compare.np((await this.get_text()), new abap.types.Character(2).set('*['))) {
+      await this.append_text({text: new abap.types.Character(1).set(',')});
+    }
+    if (abap.compare.eq(parent, new abap.types.Character(6).set('object')) && abap.compare.np((await this.get_text()), new abap.types.Character(2).set('*{'))) {
+      await this.append_text({text: new abap.types.Character(1).set(',')});
+    }
+    abap.statements.append({source: name, target: this.mt_stack});
+    let unique87 = name;
+    if (abap.compare.eq(unique87, new abap.types.Character(6).set('object'))) {
+      await this.append_text({text: new abap.types.Character(1).set('{')});
+    } else if (abap.compare.eq(unique87, new abap.types.Character(5).set('array'))) {
+      await this.append_text({text: new abap.types.Character(1).set('[')});
+    }
+  }
+  async remove() {
+    let rv_name = new abap.types.String({qualifiedName: "STRING"});
+    let index = new abap.types.Integer({qualifiedName: "I"});
+    index.set(abap.builtin.lines({val: this.mt_stack}));
+    abap.statements.readTable(this.mt_stack,{index: index,into: rv_name});
+    await abap.statements.deleteInternal(this.mt_stack,{index: index});
+    return rv_name;
+  }
+  async if_sxml_writer$close_element() {
+    let name = new abap.types.String({qualifiedName: "STRING"});
+    name.set((await this.remove()));
+    let unique88 = name;
+    if (abap.compare.eq(unique88, new abap.types.Character(6).set('object'))) {
+      await this.append_text({text: new abap.types.Character(1).set('}')});
+    } else if (abap.compare.eq(unique88, new abap.types.Character(5).set('array'))) {
+      await this.append_text({text: new abap.types.Character(1).set(']')});
+    }
+  }
+  async if_sxml_writer$write_attribute(INPUT) {
+    let name = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.name) {name.set(INPUT.name);}
+    let nsuri = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.nsuri) {nsuri.set(INPUT.nsuri);}
+    let prefix = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.prefix) {prefix.set(INPUT.prefix);}
+    let value = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.value) {value.set(INPUT.value);}
+    await this.append_text({text: new abap.types.Character(1).set('"')});
+    await this.append_text({text: value});
+    await this.append_text({text: new abap.types.Character(2).set('":')});
+  }
+  async peek() {
+    let rv_name = new abap.types.String({qualifiedName: "STRING"});
+    let index = new abap.types.Integer({qualifiedName: "I"});
+    index.set(abap.builtin.lines({val: this.mt_stack}));
+    abap.statements.readTable(this.mt_stack,{index: index,into: rv_name});
+    return rv_name;
+  }
+  async if_sxml_writer$write_value(INPUT) {
+    let value = new abap.types.String({qualifiedName: "STRING"});
+    if (INPUT && INPUT.value) {value.set(INPUT.value);}
+    let name = new abap.types.String({qualifiedName: "STRING"});
+    name.set((await this.peek()));
+    let unique89 = name;
+    if (abap.compare.eq(unique89, new abap.types.Character(3).set('str'))) {
+      await this.append_text({text: new abap.types.Character(1).set('"')});
+      await this.append_text({text: abap.builtin.condense({val: value})});
+      await this.append_text({text: new abap.types.Character(1).set('"')});
+    } else if (abap.compare.eq(unique89, new abap.types.Character(3).set('num'))) {
+      await this.append_text({text: abap.builtin.condense({val: value})});
+    } else {
+      console.dir(name);
+      abap.statements.assert(abap.compare.eq(new abap.types.Integer().set(1), new abap.types.Character(31).set('todo_if_sxml_writer_write_value')));
+    }
+  }
+}
+abap.Classes['CL_SXML_STRING_WRITER'] = cl_sxml_string_writer;
+export {cl_sxml_string_writer};
+//# sourceMappingURL=cl_sxml_string_writer.clas.mjs.map

package/output/cl_sxml_string_writer.clas.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [
+    "cl_sxml_string_writer.clas.abap"
+  ],
+  "names": [],
+  "mappings": ";;AAuCA;;;EAEE;;;;;;;;IACE,iBAAU,IAAI;IAChB;;EAEA;;;;;;;;;;;;;;;;;;;;;IAIA;;EAEA;;;;;;IACE,oCAAS,GAAF,iCAAI,wCAAM;EACnB;EAEA;;IACE,WAAS,cAAS;IACpB;;EAEA;;;QACO,2DAAmB;IACxB,YAAS,gHAAqD;IAC9D,sCAAY,gBAAU,iBAAY,cAAsB;EAC1D;EAEA;;IACE,UAAO,wHAAyD;IAClE;;EAEA;;;;;;;QACO,yDAAkB;IACvB,YAAS,kBAAO;IAEhB,iBAAU,GAAP,QAAS,yCAAQ,iBAAgB,IAAZ,wBAAe,sCAAI;0EACvB;IACpB;IACA,iBAAU,GAAP,QAAS,0CAAS,iBAAgB,IAAZ,wBAAe,sCAAI;0EACxB;IACpB;IAEA,gCAAO,cAAQ,aAAQ;IACvB,IACE,OAEA,IAHG,IAAL;;0EAEsB;;0EAEA;;EAExB;EAEA;;QACO,oDAAY;IACjB,UAAQ,yBAAO,eAAU;IACzB,oEAA4C;;IAE9C;;EAEA;QACO,uDAAgB;IACrB,UAAO,oBAAS;IAChB,IACE,OAEA,IAHG,IAAL;;0EAEsB;;0EAEA;;EAExB;EAEA;;;;;;;;;wEACoB;yCACE;yEACD;EACrB;EAEA;;QACO,oDAAY;IACjB,UAAQ,yBAAO,eAAU;IACzB,oEAA4C;IAC9C;;EAEA;;;QACO,uDAAgB;IACrB,UAAO,kBAAO;IACd,IACE,OAIA,IALG,IAAL;;0EAEsB;yEACc;0EACd;;yEAEc;;MAEhC;MACA,oCAAS,GAAF,iCAAI,oEAAiC;;EAElD;AAEF",
+  "file": "cl_sxml_string_writer.clas.mjs",
+  "sourceRoot": ""
+}

package/output/cl_system_uuid.clas.mjs

@@ -0,0 +1,35 @@
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cl_system_uuid.clas.abap
+class cl_system_uuid {
+  static INTERNAL_TYPE = 'CLAS';
+  static IMPLEMENTED_INTERFACES = ["IF_SYSTEM_UUID_RFC4122_STATIC","IF_SYSTEM_UUID_STATIC"];
+  async constructor_(INPUT) {
+    this.me = new abap.types.ABAPObject();
+    this.me.set(this);
+    return this;
+  }
+  async if_system_uuid_static$create_uuid_x16() {
+    return cl_system_uuid.if_system_uuid_static$create_uuid_x16();
+  }
+  static async if_system_uuid_static$create_uuid_x16() {
+    let uuid = new abap.types.Hex({length: 16});
+    const crypto = await import("crypto");
+    uuid.set(crypto.randomBytes(16).toString("hex").toUpperCase());
+    return uuid;
+  }
+  async if_system_uuid_rfc4122_static$create_uuid_c36_by_version(INPUT) {
+    return cl_system_uuid.if_system_uuid_rfc4122_static$create_uuid_c36_by_version(INPUT);
+  }
+  static async if_system_uuid_rfc4122_static$create_uuid_c36_by_version(INPUT) {
+    let uuid = new abap.types.Character(36, {"qualifiedName":"SYSUUID_C36"});
+    let version = new abap.types.Integer({qualifiedName: "I"});
+    if (INPUT && INPUT.version) {version.set(INPUT.version);}
+    abap.statements.assert(abap.compare.eq(version, new abap.types.Integer().set(4)));
+    const crypto = await import("crypto");
+    uuid.set(crypto.randomUUID());
+    return uuid;
+  }
+}
+abap.Classes['CL_SYSTEM_UUID'] = cl_system_uuid;
+export {cl_system_uuid};
+//# sourceMappingURL=cl_system_uuid.clas.mjs.map

package/output/cl_system_uuid.clas.mjs.map

@@ -0,0 +1,10 @@
+{
+  "version": 3,
+  "sources": [
+    "cl_system_uuid.clas.abap"
+  ],
+  "names": [],
+  "mappings": ";;AAMA;;;;;;;;EAEE;;;;;IACE;IACA;IACF;;EAEA;;;;;;;IACE,oCAAe,GAAR,SAAU,gCAAC;IAClB;IACA;IACF;;AAEF",
+  "file": "cl_system_uuid.clas.mjs",
+  "sourceRoot": ""
+}

package/output/cx_abap_message_digest.clas.mjs

@@ -0,0 +1,16 @@
+const {cx_static_check} = await import("./cx_static_check.clas.mjs");
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cx_abap_message_digest.clas.abap
+class cx_abap_message_digest extends cx_static_check {
+  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;
+  }
+}
+abap.Classes['CX_ABAP_MESSAGE_DIGEST'] = cx_abap_message_digest;
+export {cx_abap_message_digest};
+//# sourceMappingURL=cx_abap_message_digest.clas.mjs.map

package/output/cx_abap_message_digest.clas.mjs.map

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

package/output/cx_abap_random.clas.mjs

@@ -0,0 +1,16 @@
+const {cx_dynamic_check} = await import("./cx_dynamic_check.clas.mjs");
+const {cx_root} = await import("./cx_root.clas.mjs");
+// cx_abap_random.clas.abap
+class cx_abap_random extends cx_dynamic_check {
+  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;
+  }
+}
+abap.Classes['CX_ABAP_RANDOM'] = cx_abap_random;
+export {cx_abap_random};
+//# sourceMappingURL=cx_abap_random.clas.mjs.map

package/output/cx_abap_random.clas.mjs.map

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