@sap/cds-dk 9.9.3 → 10.0.4

package/node_modules/xml-js/lib/options-helper.js

@@ -0,0 +1,43 @@
+var isArray = require('./array-helper').isArray;
+
+module.exports = {
+
+  copyOptions: function (options) {
+    var key, copy = {};
+    for (key in options) {
+      if (options.hasOwnProperty(key)) {
+        copy[key] = options[key];
+      }
+    }
+    return copy;
+  },
+
+  ensureFlagExists: function (item, options) {
+    if (!(item in options) || typeof options[item] !== 'boolean') {
+      options[item] = false;
+    }
+  },
+
+  ensureSpacesExists: function (options) {
+    if (!('spaces' in options) || (typeof options.spaces !== 'number' && typeof options.spaces !== 'string')) {
+      options.spaces = 0;
+    }
+  },
+
+  ensureAlwaysArrayExists: function (options) {
+    if (!('alwaysArray' in options) || (typeof options.alwaysArray !== 'boolean' && !isArray(options.alwaysArray))) {
+      options.alwaysArray = false;
+    }
+  },
+
+  ensureKeyExists: function (key, options) {
+    if (!(key + 'Key' in options) || typeof options[key + 'Key'] !== 'string') {
+      options[key + 'Key'] = options.compact ? '_' + key : key;
+    }
+  },
+
+  checkFnExists: function (key, options) {
+    return key + 'Fn' in options;
+  }
+
+};

package/node_modules/xml-js/lib/xml2js.js

@@ -0,0 +1,362 @@
+var sax = require('sax');
+var expat /*= require('node-expat');*/ = { on: function () { }, parse: function () { } };
+var helper = require('./options-helper');
+var isArray = require('./array-helper').isArray;
+
+var options;
+var pureJsParser = true;
+var currentElement;
+
+function validateOptions(userOptions) {
+  options = helper.copyOptions(userOptions);
+  helper.ensureFlagExists('ignoreDeclaration', options);
+  helper.ensureFlagExists('ignoreInstruction', options);
+  helper.ensureFlagExists('ignoreAttributes', options);
+  helper.ensureFlagExists('ignoreText', options);
+  helper.ensureFlagExists('ignoreComment', options);
+  helper.ensureFlagExists('ignoreCdata', options);
+  helper.ensureFlagExists('ignoreDoctype', options);
+  helper.ensureFlagExists('compact', options);
+  helper.ensureFlagExists('alwaysChildren', options);
+  helper.ensureFlagExists('addParent', options);
+  helper.ensureFlagExists('trim', options);
+  helper.ensureFlagExists('nativeType', options);
+  helper.ensureFlagExists('nativeTypeAttributes', options);
+  helper.ensureFlagExists('sanitize', options);
+  helper.ensureFlagExists('instructionHasAttributes', options);
+  helper.ensureFlagExists('captureSpacesBetweenElements', options);
+  helper.ensureAlwaysArrayExists(options);
+  helper.ensureKeyExists('declaration', options);
+  helper.ensureKeyExists('instruction', options);
+  helper.ensureKeyExists('attributes', options);
+  helper.ensureKeyExists('text', options);
+  helper.ensureKeyExists('comment', options);
+  helper.ensureKeyExists('cdata', options);
+  helper.ensureKeyExists('doctype', options);
+  helper.ensureKeyExists('type', options);
+  helper.ensureKeyExists('name', options);
+  helper.ensureKeyExists('elements', options);
+  helper.ensureKeyExists('parent', options);
+  helper.checkFnExists('doctype', options);
+  helper.checkFnExists('instruction', options);
+  helper.checkFnExists('cdata', options);
+  helper.checkFnExists('comment', options);
+  helper.checkFnExists('text', options);
+  helper.checkFnExists('instructionName', options);
+  helper.checkFnExists('elementName', options);
+  helper.checkFnExists('attributeName', options);
+  helper.checkFnExists('attributeValue', options);
+  helper.checkFnExists('attributes', options);
+  return options;
+}
+
+function nativeType(value) {
+  var nValue = Number(value);
+  if (!isNaN(nValue)) {
+    return nValue;
+  }
+  var bValue = value.toLowerCase();
+  if (bValue === 'true') {
+    return true;
+  } else if (bValue === 'false') {
+    return false;
+  }
+  return value;
+}
+
+function addField(type, value) {
+  var key;
+  if (options.compact) {
+    if (
+      !currentElement[options[type + 'Key']] &&
+      (isArray(options.alwaysArray) ? options.alwaysArray.indexOf(options[type + 'Key']) !== -1 : options.alwaysArray)
+    ) {
+      currentElement[options[type + 'Key']] = [];
+    }
+    if (currentElement[options[type + 'Key']] && !isArray(currentElement[options[type + 'Key']])) {
+      currentElement[options[type + 'Key']] = [currentElement[options[type + 'Key']]];
+    }
+    if (type + 'Fn' in options && typeof value === 'string') {
+      value = options[type + 'Fn'](value, currentElement);
+    }
+    if (type === 'instruction' && ('instructionFn' in options || 'instructionNameFn' in options)) {
+      for (key in value) {
+        if (value.hasOwnProperty(key)) {
+          if ('instructionFn' in options) {
+            value[key] = options.instructionFn(value[key], key, currentElement);
+          } else {
+            var temp = value[key];
+            delete value[key];
+            value[options.instructionNameFn(key, temp, currentElement)] = temp;
+          }
+        }
+      }
+    }
+    if (isArray(currentElement[options[type + 'Key']])) {
+      currentElement[options[type + 'Key']].push(value);
+    } else {
+      currentElement[options[type + 'Key']] = value;
+    }
+  } else {
+    if (!currentElement[options.elementsKey]) {
+      currentElement[options.elementsKey] = [];
+    }
+    var element = {};
+    element[options.typeKey] = type;
+    if (type === 'instruction') {
+      for (key in value) {
+        if (value.hasOwnProperty(key)) {
+          break;
+        }
+      }
+      element[options.nameKey] = 'instructionNameFn' in options ? options.instructionNameFn(key, value, currentElement) : key;
+      if (options.instructionHasAttributes) {
+        element[options.attributesKey] = value[key][options.attributesKey];
+        if ('instructionFn' in options) {
+          element[options.attributesKey] = options.instructionFn(element[options.attributesKey], key, currentElement);
+        }
+      } else {
+        if ('instructionFn' in options) {
+          value[key] = options.instructionFn(value[key], key, currentElement);
+        }
+        element[options.instructionKey] = value[key];
+      }
+    } else {
+      if (type + 'Fn' in options) {
+        value = options[type + 'Fn'](value, currentElement);
+      }
+      element[options[type + 'Key']] = value;
+    }
+    if (options.addParent) {
+      element[options.parentKey] = currentElement;
+    }
+    currentElement[options.elementsKey].push(element);
+  }
+}
+
+function manipulateAttributes(attributes) {
+  if ('attributesFn' in options && attributes) {
+    attributes = options.attributesFn(attributes, currentElement);
+  }
+  if ((options.trim || 'attributeValueFn' in options || 'attributeNameFn' in options || options.nativeTypeAttributes) && attributes) {
+    var key;
+    for (key in attributes) {
+      if (attributes.hasOwnProperty(key)) {
+        if (options.trim) attributes[key] = attributes[key].trim();
+        if (options.nativeTypeAttributes) {
+          attributes[key] = nativeType(attributes[key]);
+        }
+        if ('attributeValueFn' in options) attributes[key] = options.attributeValueFn(attributes[key], key, currentElement);
+        if ('attributeNameFn' in options) {
+          var temp = attributes[key];
+          delete attributes[key];
+          attributes[options.attributeNameFn(key, attributes[key], currentElement)] = temp;
+        }
+      }
+    }
+  }
+  return attributes;
+}
+
+function onInstruction(instruction) {
+  var attributes = {};
+  if (instruction.body && (instruction.name.toLowerCase() === 'xml' || options.instructionHasAttributes)) {
+    var attrsRegExp = /([\w:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\w+))\s*/g;
+    var match;
+    while ((match = attrsRegExp.exec(instruction.body)) !== null) {
+      attributes[match[1]] = match[2] || match[3] || match[4];
+    }
+    attributes = manipulateAttributes(attributes);
+  }
+  if (instruction.name.toLowerCase() === 'xml') {
+    if (options.ignoreDeclaration) {
+      return;
+    }
+    currentElement[options.declarationKey] = {};
+    if (Object.keys(attributes).length) {
+      currentElement[options.declarationKey][options.attributesKey] = attributes;
+    }
+    if (options.addParent) {
+      currentElement[options.declarationKey][options.parentKey] = currentElement;
+    }
+  } else {
+    if (options.ignoreInstruction) {
+      return;
+    }
+    if (options.trim) {
+      instruction.body = instruction.body.trim();
+    }
+    var value = {};
+    if (options.instructionHasAttributes && Object.keys(attributes).length) {
+      value[instruction.name] = {};
+      value[instruction.name][options.attributesKey] = attributes;
+    } else {
+      value[instruction.name] = instruction.body;
+    }
+    addField('instruction', value);
+  }
+}
+
+function onStartElement(name, attributes) {
+  var element;
+  if (typeof name === 'object') {
+    attributes = name.attributes;
+    name = name.name;
+  }
+  attributes = manipulateAttributes(attributes);
+  if ('elementNameFn' in options) {
+    name = options.elementNameFn(name, currentElement);
+  }
+  if (options.compact) {
+    element = {};
+    if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) {
+      element[options.attributesKey] = {};
+      var key;
+      for (key in attributes) {
+        if (attributes.hasOwnProperty(key)) {
+          element[options.attributesKey][key] = attributes[key];
+        }
+      }
+    }
+    if (
+      !(name in currentElement) &&
+      (isArray(options.alwaysArray) ? options.alwaysArray.indexOf(name) !== -1 : options.alwaysArray)
+    ) {
+      currentElement[name] = [];
+    }
+    if (currentElement[name] && !isArray(currentElement[name])) {
+      currentElement[name] = [currentElement[name]];
+    }
+    if (isArray(currentElement[name])) {
+      currentElement[name].push(element);
+    } else {
+      currentElement[name] = element;
+    }
+  } else {
+    if (!currentElement[options.elementsKey]) {
+      currentElement[options.elementsKey] = [];
+    }
+    element = {};
+    element[options.typeKey] = 'element';
+    element[options.nameKey] = name;
+    if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) {
+      element[options.attributesKey] = attributes;
+    }
+    if (options.alwaysChildren) {
+      element[options.elementsKey] = [];
+    }
+    currentElement[options.elementsKey].push(element);
+  }
+  element[options.parentKey] = currentElement; // will be deleted in onEndElement() if !options.addParent
+  currentElement = element;
+}
+
+function onText(text) {
+  if (options.ignoreText) {
+    return;
+  }
+  if (!text.trim() && !options.captureSpacesBetweenElements) {
+    return;
+  }
+  if (options.trim) {
+    text = text.trim();
+  }
+  if (options.nativeType) {
+    text = nativeType(text);
+  }
+  if (options.sanitize) {
+    text = text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+  }
+  addField('text', text);
+}
+
+function onComment(comment) {
+  if (options.ignoreComment) {
+    return;
+  }
+  if (options.trim) {
+    comment = comment.trim();
+  }
+  addField('comment', comment);
+}
+
+function onEndElement(name) {
+  var parentElement = currentElement[options.parentKey];
+  if (!options.addParent) {
+    delete currentElement[options.parentKey];
+  }
+  currentElement = parentElement;
+}
+
+function onCdata(cdata) {
+  if (options.ignoreCdata) {
+    return;
+  }
+  if (options.trim) {
+    cdata = cdata.trim();
+  }
+  addField('cdata', cdata);
+}
+
+function onDoctype(doctype) {
+  if (options.ignoreDoctype) {
+    return;
+  }
+  doctype = doctype.replace(/^ /, '');
+  if (options.trim) {
+    doctype = doctype.trim();
+  }
+  addField('doctype', doctype);
+}
+
+function onError(error) {
+  error.note = error; //console.error(error);
+}
+
+module.exports = function (xml, userOptions) {
+
+  var parser = pureJsParser ? sax.parser(true, {}) : parser = new expat.Parser('UTF-8');
+  var result = {};
+  currentElement = result;
+
+  options = validateOptions(userOptions);
+
+  if (pureJsParser) {
+    parser.opt = {strictEntities: true};
+    parser.onopentag = onStartElement;
+    parser.ontext = onText;
+    parser.oncomment = onComment;
+    parser.onclosetag = onEndElement;
+    parser.onerror = onError;
+    parser.oncdata = onCdata;
+    parser.ondoctype = onDoctype;
+    parser.onprocessinginstruction = onInstruction;
+  } else {
+    parser.on('startElement', onStartElement);
+    parser.on('text', onText);
+    parser.on('comment', onComment);
+    parser.on('endElement', onEndElement);
+    parser.on('error', onError);
+    //parser.on('startCdata', onStartCdata);
+    //parser.on('endCdata', onEndCdata);
+    //parser.on('entityDecl', onEntityDecl);
+  }
+
+  if (pureJsParser) {
+    parser.write(xml).close();
+  } else {
+    if (!parser.parse(xml)) {
+      throw new Error('XML parsing error: ' + parser.getError());
+    }
+  }
+
+  if (result[options.elementsKey]) {
+    var temp = result[options.elementsKey];
+    delete result[options.elementsKey];
+    result[options.elementsKey] = temp;
+    delete result.text;
+  }
+
+  return result;
+
+};

package/node_modules/xml-js/lib/xml2json.js

@@ -0,0 +1,22 @@
+var helper = require('./options-helper');
+var xml2js = require('./xml2js');
+
+function validateOptions (userOptions) {
+  var options = helper.copyOptions(userOptions);
+  helper.ensureSpacesExists(options);
+  return options;
+}
+
+module.exports = function(xml, userOptions) {
+  var options, js, json, parentKey;
+  options = validateOptions(userOptions);
+  js = xml2js(xml, options);
+  parentKey = 'compact' in options && options.compact ? '_parent' : 'parent';
+  // parentKey = ptions.compact ? '_parent' : 'parent'; // consider this
+  if ('addParent' in options && options.addParent) {
+    json = JSON.stringify(js, function (k, v) { return k === parentKey? '_' : v; }, options.spaces);
+  } else {
+    json = JSON.stringify(js, null, options.spaces);
+  }
+  return json.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
+};

package/node_modules/xml-js/package.json

@@ -0,0 +1,111 @@
+{
+  "name": "xml-js",
+  "version": "1.6.11",
+  "description": "A convertor between XML text and Javascript object / JSON text.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/nashwaan/xml-js.git"
+  },
+  "author": "Yousuf Almarzooqi <ysf953@gmail.com>",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/nashwaan/xml-js/issues"
+  },
+  "homepage": "https://github.com/nashwaan/xml-js#readme",
+  "keywords": [
+    "XML",
+    "xml",
+    "js",
+    "JSON",
+    "json",
+    "cdata",
+    "CDATA",
+    "doctype",
+    "processing instruction",
+    "Javascript",
+    "js2xml",
+    "json2xml",
+    "xml2js",
+    "xml2json",
+    "transform",
+    "transformer",
+    "transforming",
+    "transformation",
+    "convert",
+    "convertor",
+    "converting",
+    "conversion",
+    "parse",
+    "parser",
+    "parsing"
+  ],
+  "main": "lib/index.js",
+  "bin": "./bin/cli.js",
+  "types": "./types/index.d.ts",
+  "scripts": {
+    "build": "webpack",
+    "doc": "node doc/compile-doc.js",
+    "watch:doc": "watch \"npm run doc\" doc/templates/",
+    "live:doc": "browser-sync start --port 9997 --server doc/ --files doc/templates/ --no-open --no-ui --no-online",
+    "open:doc": "biased-opener --browser chrome http://localhost:9997",
+    "start:doc": "npm-run-all --parallel watch:doc live:doc open:doc",
+    "debug": "nodemon --inspect --watch lib/ --watch test/ --debug-brk test/index.js",
+    "debug:cli": "nodemon --inspect --watch lib/ --debug-brk index.js -- --help",
+    "jest": "jest --config=test/jest.conf.js",
+    "jasmine": "jasmine JASMINE_CONFIG_PATH=./test/jasmine.json",
+    "watch:jasmine": "watch \"npm run jasmine\" lib/ test/ --ignoreDirectoryPattern=/browse-.+/",
+    "bundle:jasmine": "globify test/*.spec.js --watch --verbose --list --outfile test/browse-jasmine/bundle.js",
+    "live:jasmine": "browser-sync start --port 9999 --server test/browse-jasmine/ --files test/browse-jasmine/ --no-open --no-ui --no-online",
+    "open-help": "biased-opener --help",
+    "open:jasmine": "biased-opener --browser chrome http://localhost:9999",
+    "istanbul-original": "istanbul cover --dir test/coverage-jasmine -x test/browse-** test/index.js",
+    "istanbul": "istanbul cover --dir test/coverage-jasmine test/index.js",
+    "watch:istanbul": "watch \"npm run istanbul\" lib/ test/ --ignoreDirectoryPattern=/coverage-.+/",
+    "live:istanbul": "browser-sync start --port 9998 --server test/coverage-jasmine/lcov-report/ --files test/coverage-jasmine/lcov-report/ --no-open --no-ui --no-online",
+    "open:istanbul": "biased-opener --browser chrome http://localhost:9998",
+    "live": "npm-run-all --parallel live:* open:*",
+    "start": "npm-run-all --parallel bundle:jasmine live:jasmine open:jasmine watch:istanbul live:istanbul open:istanbul",
+    "git:commit": "git add . && git commit -a -m \"Committed by npm script.\" && git push origin master",
+    "git:push": "git push origin master",
+    "deploy": "npm-run-all --serial coverage:* git:*",
+    "coverage": "npm-run-all coverage:*",
+    "coverage:a-step": "npm run istanbul",
+    "coverage:coveralls": "cross-env COVERALLS_REPO_TOKEN=CaEwzjHxsKRqomJSYmGagrJdlR7uLHhHC && cat ./test/coverage-jasmine/lcov.info | coveralls",
+    "coverage:codecov": "codecov --token=0e52af41-702b-4d7f-8aa3-61145ac36624 --file=test/coverage-jasmine/lcov.info ",
+    "coverage:codacy": "cross-env CODACY_PROJECT_TOKEN=0207815122ea49a68241d1aa435f21f1 && cat ./test/coverage-jasmine/lcov.info | codacy-coverage",
+    "coverage:codeclimate": "cross-env CODECLIMATE_REPO_TOKEN=60848a077f9070acf358b0c7145f0a2698a460ddeca7d8250815e75aa4333f7d codeclimate-test-reporter < test\\coverage-jasmine\\lcov.info",
+    "prepublish": "npm run test",
+    "test": "npm run jasmine && npm run jest && npm run test:types",
+    "test:types": "tsc -p ./types"
+  },
+  "dependencies": {
+    "sax": "^1.2.4"
+  },
+  "devDependencies": {
+    "babel-core": "^6.26.3",
+    "babel-loader": "^7.1.4",
+    "babel-preset-env": "^1.7.0",
+    "biased-opener": "^0.2.8",
+    "browser-sync": "^2.26.3",
+    "cash-cat": "^0.2.0",
+    "codacy-coverage": "^3.4.0",
+    "codeclimate-test-reporter": "^0.5.1",
+    "codecov": "^3.1.0",
+    "coveralls": "^3.0.2",
+    "cross-env": "^5.2.0",
+    "eslint": "^5.12.0",
+    "globify": "^2.3.4",
+    "istanbul": "^0.4.5",
+    "jasmine": "^3.3.1",
+    "jest": "^20.0.4",
+    "jest-cli": "^20.0.4",
+    "jsonpath": "^1.0.0",
+    "nodemon": "^1.18.9",
+    "npm-run-all": "^4.1.5",
+    "prismjs": "^1.15.0",
+    "typescript": "^3.2.2",
+    "unminified-webpack-plugin": "^1.4.2",
+    "watch": "^1.0.1",
+    "webpack": "^3.10.0"
+  }
+}

package/node_modules/xml-js/types/index.d.ts

@@ -0,0 +1,154 @@
+export interface Attributes {
+  [key: string]: string | number | undefined
+}
+
+export interface DeclarationAttributes {
+  version?: string | number
+  encoding?: 'utf-8' | string
+  standalone?: 'yes' | 'no'
+}
+
+export interface ElementCompact {
+  [key: string]: any
+  _declaration?: {
+    _attributes?: DeclarationAttributes
+  }
+  _instruction?: {
+    [key: string]: string
+  }
+  _attributes?: Attributes
+  _cdata?: string
+  _doctype?: string
+  _comment?: string
+  _text?: string | number
+}
+
+export interface Element {
+  declaration?: {
+    attributes?: DeclarationAttributes
+  }
+  instruction?: string
+  attributes?: Attributes
+  cdata?: string
+  doctype?: string
+  comment?: string
+  text?: string | number | boolean
+  type?: string
+  name?: string
+  elements?: Array<Element>
+}
+
+declare namespace Options {
+  interface XML2JSON extends XML2JS {
+    spaces?: number | string
+  }
+
+  interface XML2JS extends ChangingKeyNames, IgnoreOptions {
+    compact?: boolean
+    trim?: boolean
+    sanitize?: boolean
+    nativeType?: boolean
+    addParent?: boolean
+    alwaysArray?: boolean | Array<string>
+    alwaysChildren?: boolean
+    instructionHasAttributes?: boolean
+    captureSpacesBetweenElements?: boolean
+    doctypeFn?: (value: string, parentElement: object) => void;
+    instructionFn?: (
+      instructionValue: string,
+      instructionName: string,
+      parentElement: string
+    ) => void;
+    cdataFn?: (value: string, parentElement: object) => void;
+    commentFn?: (value: string, parentElement: object) => void;
+    textFn?: (value: string, parentElement: object) => void;
+    instructionNameFn?: (
+      instructionName: string,
+      instructionValue: string,
+      parentElement: string
+    ) => void;
+    elementNameFn?: (value: string, parentElement: object) => void;
+    attributeNameFn?: (
+      attributeName: string,
+      attributeValue: string,
+      parentElement: string
+    ) => void;
+    attributeValueFn?: (
+      attributeValue: string,
+      attributeName: string,
+      parentElement: string
+    ) => void;
+    attributesFn?: (value: string, parentElement: string) => void;
+  }
+
+  interface JS2XML extends ChangingKeyNames, IgnoreOptions {
+    spaces?: number | string
+    compact?: boolean
+    indentText?: boolean
+    indentCdata?: boolean
+    indentAttributes?: boolean
+    indentInstruction?: boolean
+    fullTagEmptyElement?: boolean
+    noQuotesForNativeAttributes?: boolean
+    doctypeFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
+    instructionFn?: (
+      instructionValue: string,
+      instructionName: string,
+      currentElementName: string,
+      currentElementObj: object
+    ) => void;
+    cdataFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
+    commentFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
+    textFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
+    instructionNameFn?: (
+      instructionName: string,
+      instructionValue: string,
+      currentElementName: string,
+      currentElementObj: object
+    ) => void;
+    elementNameFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
+    attributeNameFn?: (
+      attributeName: string,
+      attributeValue: string,
+      currentElementName: string,
+      currentElementObj: object
+    ) => void;
+    attributeValueFn?: (
+      attributeValue: string,
+      attributeName: string,
+      currentElementName: string,
+      currentElementObj: object
+    ) => void;
+    attributesFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
+    fullTagEmptyElementFn?: (currentElementName: string, currentElementObj: object) => void;
+  }
+
+  interface IgnoreOptions {
+    ignoreDeclaration?: boolean
+    ignoreInstruction?: boolean
+    ignoreAttributes?: boolean
+    ignoreComment?: boolean
+    ignoreCdata?: boolean
+    ignoreDoctype?: boolean
+    ignoreText?: boolean
+  }
+
+  interface ChangingKeyNames {
+    declarationKey?: string
+    instructionKey?: string
+    attributesKey?: string
+    textKey?: string
+    cdataKey?: string
+    doctypeKey?: string
+    commentKey?: string
+    parentKey?: string
+    typeKey?: string
+    nameKey?: string
+    elementsKey?: string
+  }
+}
+
+export function js2xml(obj: Element | ElementCompact, options?: Options.JS2XML): string;
+export function json2xml(json: string, options?: Options.JS2XML): string;
+export function xml2json(xml: string, options?: Options.XML2JSON): string;
+export function xml2js(xml: string, options?: Options.XML2JS): Element | ElementCompact;