soap 0.45.0 → 1.0.0

package/lib/wsdl/index.js

@@ -5,29 +5,29 @@
  *
  */
 /*jshint proto:true*/
-exports.__esModule = true;
+Object.defineProperty(exports, "__esModule", { value: true });
 exports.open_wsdl = exports.WSDL = void 0;
-var assert_1 = require("assert");
-var debugBuilder = require("debug");
-var fs = require("fs");
-var _ = require("lodash");
-var path = require("path");
-var sax = require("sax");
-var stripBom = require("strip-bom");
-var url = require("url");
-var http_1 = require("../http");
-var nscontext_1 = require("../nscontext");
-var utils_1 = require("../utils");
-var elements = require("./elements");
-var debug = debugBuilder('node-soap');
-var XSI_URI = 'http://www.w3.org/2001/XMLSchema-instance';
-var trimLeft = /^[\s\xA0]+/;
-var trimRight = /[\s\xA0]+$/;
+const assert_1 = require("assert");
+const debugBuilder = require("debug");
+const fs = require("fs");
+const _ = require("lodash");
+const path = require("path");
+const sax = require("sax");
+const stripBom = require("strip-bom");
+const url = require("url");
+const http_1 = require("../http");
+const nscontext_1 = require("../nscontext");
+const utils_1 = require("../utils");
+const elements = require("./elements");
+const debug = debugBuilder('node-soap');
+const XSI_URI = 'http://www.w3.org/2001/XMLSchema-instance';
+const trimLeft = /^[\s\xA0]+/;
+const trimRight = /[\s\xA0]+$/;
 function trim(text) {
     return text.replace(trimLeft, '').replace(trimRight, '');
 }
 function deepMerge(destination, source) {
-    return _.mergeWith(destination, source, function (a, b) {
+    return _.mergeWith(destination, source, (a, b) => {
         return Array.isArray(a) ? a.concat(b) : undefined;
     });
 }
@@ -37,16 +37,15 @@ function appendColon(ns) {
 function noColonNameSpace(ns) {
     return (ns && ns.charAt(ns.length - 1) === ':') ? ns.substring(0, ns.length - 1) : ns;
 }
-var WSDL = /** @class */ (function () {
-    function WSDL(definition, uri, options) {
-        var _this = this;
+class WSDL {
+    constructor(definition, uri, options) {
         this.ignoredNamespaces = ['tns', 'targetNamespace', 'typedNamespace'];
         this.ignoreBaseNameSpaces = false;
         this.valueKey = '$value';
         this.xmlKey = '$xml';
-        var fromFunc;
+        let fromFunc;
         this.uri = uri;
-        this.callback = function () { };
+        this.callback = () => { };
         this._includesWsdl = [];
         // initialize WSDL cache
         this.WSDL_CACHE = {};
@@ -64,48 +63,48 @@ var WSDL = /** @class */ (function () {
         else {
             throw new Error('WSDL constructor takes either an XML string or service definition');
         }
-        process.nextTick(function () {
+        process.nextTick(() => {
             try {
-                fromFunc.call(_this, definition);
+                fromFunc.call(this, definition);
             }
             catch (e) {
-                return _this.callback(e);
+                return this.callback(e);
             }
-            _this.processIncludes(function (err) {
-                var name;
+            this.processIncludes((err) => {
+                let name;
                 if (err) {
-                    return _this.callback(err);
+                    return this.callback(err);
                 }
                 try {
-                    _this.definitions.deleteFixedAttrs();
-                    var services = _this.services = _this.definitions.services;
+                    this.definitions.deleteFixedAttrs();
+                    const services = this.services = this.definitions.services;
                     if (services) {
                         for (name in services) {
-                            services[name].postProcess(_this.definitions);
+                            services[name].postProcess(this.definitions);
                         }
                     }
-                    var complexTypes = _this.definitions.complexTypes;
+                    const complexTypes = this.definitions.complexTypes;
                     if (complexTypes) {
                         for (name in complexTypes) {
                             complexTypes[name].deleteFixedAttrs();
                         }
                     }
                     // for document style, for every binding, prepare input message element name to (methodName, output message element name) mapping
-                    var bindings = _this.definitions.bindings;
-                    for (var bindingName in bindings) {
-                        var binding = bindings[bindingName];
+                    const bindings = this.definitions.bindings;
+                    for (const bindingName in bindings) {
+                        const binding = bindings[bindingName];
                         if (typeof binding.style === 'undefined') {
                             binding.style = 'document';
                         }
-                        var methods = binding.methods;
-                        var topEls = binding.topElements = {};
-                        for (var methodName in methods) {
+                        const methods = binding.methods;
+                        const topEls = binding.topElements = {};
+                        for (const methodName in methods) {
                             if ((methods[methodName].style || binding.style) !== 'document') {
                                 continue;
                             }
                             if (methods[methodName].input) {
-                                var inputName = methods[methodName].input.$name;
-                                var outputName = '';
+                                const inputName = methods[methodName].input.$name;
+                                let outputName = '';
                                 if (methods[methodName].output) {
                                     outputName = methods[methodName].output.$name;
                                 }
@@ -114,94 +113,93 @@ var WSDL = /** @class */ (function () {
                         }
                     }
                     // prepare soap envelope xmlns definition string
-                    _this.xmlnsInEnvelope = _this._xmlnsMap();
-                    _this.callback(err, _this);
+                    this.xmlnsInEnvelope = this._xmlnsMap();
+                    this.callback(err, this);
                 }
                 catch (e) {
-                    _this.callback(e);
+                    this.callback(e);
                 }
             });
         });
     }
-    WSDL.prototype.onReady = function (callback) {
+    onReady(callback) {
         if (callback) {
             this.callback = callback;
         }
-    };
-    WSDL.prototype.processIncludes = function (callback) {
-        var schemas = this.definitions.schemas;
-        var includes = [];
-        for (var ns in schemas) {
-            var schema = schemas[ns];
+    }
+    processIncludes(callback) {
+        const schemas = this.definitions.schemas;
+        let includes = [];
+        for (const ns in schemas) {
+            const schema = schemas[ns];
             includes = includes.concat(schema.includes || []);
         }
         this._processNextInclude(includes, callback);
-    };
-    WSDL.prototype.describeServices = function () {
-        var services = {};
-        for (var name_1 in this.services) {
-            var service = this.services[name_1];
-            services[name_1] = service.description(this.definitions);
+    }
+    describeServices() {
+        const services = {};
+        for (const name in this.services) {
+            const service = this.services[name];
+            services[name] = service.description(this.definitions);
         }
         return services;
-    };
-    WSDL.prototype.toXML = function () {
+    }
+    toXML() {
         return this.xml || '';
-    };
-    WSDL.prototype.getSaxStream = function (xml) {
-        var saxStream = sax.createStream(true, null);
+    }
+    getSaxStream(xml) {
+        const saxStream = sax.createStream(true, null);
         xml.pipe(saxStream);
         return saxStream;
-    };
-    WSDL.prototype.xmlToObject = function (xml, callback) {
-        var _this = this;
-        var p = typeof callback === 'function' ? {} : sax.parser(true, null);
-        var objectName = null;
-        var root = {};
-        var schema = {
+    }
+    xmlToObject(xml, callback) {
+        const p = typeof callback === 'function' ? {} : sax.parser(true, null);
+        let objectName = null;
+        const root = {};
+        const schema = {
             Envelope: {
                 Header: {
                     Security: {
                         UsernameToken: {
                             Username: 'string',
-                            Password: 'string'
-                        }
-                    }
+                            Password: 'string',
+                        },
+                    },
                 },
                 Body: {
                     Fault: {
                         faultcode: 'string',
                         faultstring: 'string',
-                        detail: 'string'
-                    }
-                }
-            }
+                        detail: 'string',
+                    },
+                },
+            },
         };
-        var stack = [{ name: null, object: root, schema: schema }];
-        var xmlns = {};
-        var refs = {};
-        var id; // {id:{hrefs:[],obj:}, ...}
-        p.onopentag = function (node) {
-            var nsName = node.name;
-            var attrs = node.attributes;
-            var name = utils_1.splitQName(nsName).name;
-            var attributeName;
-            var top = stack[stack.length - 1];
-            var topSchema = top.schema;
-            var elementAttributes = {};
-            var hasNonXmlnsAttribute = false;
-            var hasNilAttribute = false;
-            var obj = {};
-            var originalName = name;
+        const stack = [{ name: null, object: root, schema: schema }];
+        const xmlns = {};
+        const refs = {};
+        let id; // {id:{hrefs:[],obj:}, ...}
+        p.onopentag = (node) => {
+            const nsName = node.name;
+            const attrs = node.attributes;
+            let name = (0, utils_1.splitQName)(nsName).name;
+            let attributeName;
+            const top = stack[stack.length - 1];
+            let topSchema = top.schema;
+            const elementAttributes = {};
+            let hasNonXmlnsAttribute = false;
+            let hasNilAttribute = false;
+            const obj = {};
+            const originalName = name;
             if (!objectName && top.name === 'Body' && name !== 'Fault') {
-                var message = _this.definitions.messages[name];
+                let message = this.definitions.messages[name];
                 // Support RPC/literal messages where response body contains one element named
                 // after the operation + 'Response'. See http://www.w3.org/TR/wsdl#_names
                 if (!message) {
                     try {
                         // Determine if this is request or response
-                        var isInput = false;
-                        var isOutput = false;
+                        let isInput = false;
+                        let isOutput = false;
                         if ((/Response$/).test(name)) {
                             isOutput = true;
                             name = name.replace(/Response$/, '');
@@ -215,27 +213,27 @@ var WSDL = /** @class */ (function () {
                             name = name.replace(/Solicit$/, '');
                         }
                         // Look up the appropriate message as given in the portType's operations
-                        var portTypes = _this.definitions.portTypes;
-                        var portTypeNames = Object.keys(portTypes);
+                        const portTypes = this.definitions.portTypes;
+                        const portTypeNames = Object.keys(portTypes);
                         // Currently this supports only one portType definition.
-                        var portType = portTypes[portTypeNames[0]];
+                        const portType = portTypes[portTypeNames[0]];
                         if (isInput) {
                             name = portType.methods[name].input.$name;
                         }
                         else {
                             name = portType.methods[name].output.$name;
                         }
-                        message = _this.definitions.messages[name];
+                        message = this.definitions.messages[name];
                         // 'cache' this alias to speed future lookups
-                        _this.definitions.messages[originalName] = _this.definitions.messages[name];
+                        this.definitions.messages[originalName] = this.definitions.messages[name];
                     }
                     catch (e) {
-                        if (_this.options.returnFault) {
+                        if (this.options.returnFault) {
                             p.onerror(e);
                         }
                     }
                 }
-                topSchema = message.description(_this.definitions);
+                topSchema = message.description(this.definitions);
                 objectName = originalName;
             }
             if (attrs.href) {
@@ -253,14 +251,14 @@ var WSDL = /** @class */ (function () {
             // Handle element attributes
             for (attributeName in attrs) {
                 if (/^xmlns:|^xmlns$/.test(attributeName)) {
-                    xmlns[utils_1.splitQName(attributeName).name] = attrs[attributeName];
+                    xmlns[(0, utils_1.splitQName)(attributeName).name] = attrs[attributeName];
                     continue;
                 }
                 hasNonXmlnsAttribute = true;
                 elementAttributes[attributeName] = attrs[attributeName];
             }
             for (attributeName in elementAttributes) {
-                var res = utils_1.splitQName(attributeName);
+                const res = (0, utils_1.splitQName)(attributeName);
                 if (res.name === 'nil' && xmlns[res.prefix] === XSI_URI && elementAttributes[attributeName] &&
                     (elementAttributes[attributeName].toLowerCase() === 'true' || elementAttributes[attributeName] === '1')) {
                     hasNilAttribute = true;
@@ -268,20 +266,20 @@ var WSDL = /** @class */ (function () {
                 }
             }
             if (hasNonXmlnsAttribute) {
-                obj[_this.options.attributesKey] = elementAttributes;
+                obj[this.options.attributesKey] = elementAttributes;
             }
             // Pick up the schema for the type specified in element's xsi:type attribute.
-            var xsiTypeSchema;
-            var xsiType;
-            for (var prefix in xmlns) {
-                if (xmlns[prefix] === XSI_URI && (prefix + ":type" in elementAttributes)) {
-                    xsiType = elementAttributes[prefix + ":type"];
+            let xsiTypeSchema;
+            let xsiType;
+            for (const prefix in xmlns) {
+                if (xmlns[prefix] === XSI_URI && (`${prefix}:type` in elementAttributes)) {
+                    xsiType = elementAttributes[`${prefix}:type`];
                     break;
                 }
             }
             if (xsiType) {
-                var type = utils_1.splitQName(xsiType);
-                var typeURI = void 0;
+                const type = (0, utils_1.splitQName)(xsiType);
+                let typeURI;
                 if (type.prefix === utils_1.TNS_PREFIX) {
                     // In case of xsi:type = "MyType"
                     typeURI = xmlns[type.prefix] || xmlns.xmlns;
@@ -289,9 +287,9 @@ var WSDL = /** @class */ (function () {
                 else {
                     typeURI = xmlns[type.prefix];
                 }
-                var typeDef = _this.findSchemaObject(typeURI, type.name);
+                const typeDef = this.findSchemaObject(typeURI, type.name);
                 if (typeDef) {
-                    xsiTypeSchema = typeDef.description(_this.definitions);
+                    xsiTypeSchema = typeDef.description(this.definitions);
                 }
             }
             if (topSchema && topSchema[name + '[]']) {
@@ -299,20 +297,20 @@ var WSDL = /** @class */ (function () {
             }
             stack.push({ name: originalName, object: obj, schema: (xsiTypeSchema || (topSchema && topSchema[name])), id: attrs.id, nil: hasNilAttribute });
         };
-        p.onclosetag = function (nsName) {
-            var cur = stack.pop();
-            var obj = cur.object;
-            var top = stack[stack.length - 1];
-            var topObject = top.object;
-            var topSchema = top.schema;
-            var name = utils_1.splitQName(nsName).name;
+        p.onclosetag = (nsName) => {
+            const cur = stack.pop();
+            let obj = cur.object;
+            const top = stack[stack.length - 1];
+            const topObject = top.object;
+            const topSchema = top.schema;
+            const name = (0, utils_1.splitQName)(nsName).name;
             if (typeof cur.schema === 'string' && (cur.schema === 'string' || cur.schema.split(':')[1] === 'string')) {
                 if (typeof obj === 'object' && Object.keys(obj).length === 0) {
                     obj = cur.object = '';
                 }
             }
             if (cur.nil === true) {
-                if (_this.options.handleNilAsNull) {
+                if (this.options.handleNilAsNull) {
                     obj = null;
                 }
                 else {
@@ -341,48 +339,48 @@ var WSDL = /** @class */ (function () {
                 refs[cur.id].obj = obj;
             }
         };
-        p.oncdata = function (text) {
-            var originalText = text;
+        p.oncdata = (text) => {
+            const originalText = text;
             text = trim(text);
             if (!text.length) {
                 return;
             }
             if (/<\?xml[\s\S]+\?>/.test(text)) {
-                var top_1 = stack[stack.length - 1];
-                var value = _this.xmlToObject(text);
-                if (top_1.object[_this.options.attributesKey]) {
-                    top_1.object[_this.options.valueKey] = value;
+                const top = stack[stack.length - 1];
+                const value = this.xmlToObject(text);
+                if (top.object[this.options.attributesKey]) {
+                    top.object[this.options.valueKey] = value;
                 }
                 else {
-                    top_1.object = value;
+                    top.object = value;
                 }
             }
             else {
                 p.ontext(originalText);
             }
         };
-        p.onerror = function (e) {
+        p.onerror = (e) => {
             p.resume();
             throw {
                 Fault: {
                     faultcode: 500,
                     faultstring: 'Invalid XML',
                     detail: new Error(e).message,
-                    statusCode: 500
-                }
+                    statusCode: 500,
+                },
             };
         };
-        p.ontext = function (text) {
-            var originalText = text;
+        p.ontext = (text) => {
+            const originalText = text;
             text = trim(text);
             if (!text.length) {
                 return;
             }
-            var top = stack[stack.length - 1];
-            var name = utils_1.splitQName(top.schema).name;
-            var value;
-            if (_this.options && _this.options.customDeserializer && _this.options.customDeserializer[name]) {
-                value = _this.options.customDeserializer[name](text, top);
+            const top = stack[stack.length - 1];
+            const name = (0, utils_1.splitQName)(top.schema).name;
+            let value;
+            if (this.options && this.options.customDeserializer && this.options.customDeserializer[name]) {
+                value = this.options.customDeserializer[name](text, top);
             }
             else {
                 if (name === 'int' || name === 'integer' || name === 'short' || name === 'long') {
@@ -398,7 +396,7 @@ var WSDL = /** @class */ (function () {
                     value = new Date(text);
                 }
                 else {
-                    if (_this.options.preserveWhitespace) {
+                    if (this.options.preserveWhitespace) {
                         text = originalText;
                     }
                     // handle string or other types
@@ -410,8 +408,8 @@ var WSDL = /** @class */ (function () {
                     }
                 }
             }
-            if (top.object[_this.options.attributesKey]) {
-                top.object[_this.options.valueKey] = value;
+            if (top.object[this.options.attributesKey]) {
+                top.object[this.options.valueKey] = value;
             }
             else {
                 top.object = value;
@@ -419,17 +417,17 @@ var WSDL = /** @class */ (function () {
         };
         if (typeof callback === 'function') {
             // we be streaming
-            var saxStream = sax.createStream(true, null);
+            const saxStream = sax.createStream(true, null);
             saxStream.on('opentag', p.onopentag);
             saxStream.on('closetag', p.onclosetag);
             saxStream.on('cdata', p.oncdata);
             saxStream.on('text', p.ontext);
             xml.pipe(saxStream)
-                .on('error', function (err) {
+                .on('error', (err) => {
                 callback(err);
             })
-                .on('end', function () {
-                var r;
+                .on('end', () => {
+                let r;
                 try {
                     r = finish();
                 }
@@ -444,23 +442,22 @@ var WSDL = /** @class */ (function () {
         return finish();
         function finish() {
             // MultiRef support: merge objects instead of replacing
-            for (var n in refs) {
-                var ref = refs[n];
-                for (var _i = 0, _a = ref.hrefs; _i < _a.length; _i++) {
-                    var href = _a[_i];
+            for (const n in refs) {
+                const ref = refs[n];
+                for (const href of ref.hrefs) {
                     Object.assign(href.obj, ref.obj);
                 }
             }
             if (root.Envelope) {
-                var body = root.Envelope.Body;
+                const body = root.Envelope.Body;
                 if (body && body.Fault) {
-                    var code = body.Fault.faultcode && body.Fault.faultcode.$value;
-                    var string = body.Fault.faultstring && body.Fault.faultstring.$value;
-                    var detail = body.Fault.detail && body.Fault.detail.$value;
+                    let code = body.Fault.faultcode && body.Fault.faultcode.$value;
+                    let string = body.Fault.faultstring && body.Fault.faultstring.$value;
+                    let detail = body.Fault.detail && body.Fault.detail.$value;
                     code = code || body.Fault.faultcode;
                     string = string || body.Fault.faultstring;
                     detail = detail || body.Fault.detail;
-                    var error = new Error(code + ': ' + string + (detail ? ': ' + JSON.stringify(detail) : ''));
+                    const error = new Error(code + ': ' + string + (detail ? ': ' + JSON.stringify(detail) : ''));
                     error.root = root;
                     throw error;
                 }
@@ -468,20 +465,20 @@ var WSDL = /** @class */ (function () {
             }
             return root;
         }
-    };
+    }
     /**
      * Look up a XSD type or element by namespace URI and name
      * @param {String} nsURI Namespace URI
      * @param {String} qname Local or qualified name
      * @returns {*} The XSD type/element definition
      */
-    WSDL.prototype.findSchemaObject = function (nsURI, qname) {
+    findSchemaObject(nsURI, qname) {
         if (!nsURI || !qname) {
             return null;
         }
-        var def = null;
+        let def = null;
         if (this.definitions.schemas) {
-            var schema = this.definitions.schemas[nsURI];
+            const schema = this.definitions.schemas[nsURI];
             if (schema) {
                 if (qname.indexOf(':') !== -1) {
                     qname = qname.substring(qname.indexOf(':') + 1, qname.length);
@@ -492,7 +489,7 @@ var WSDL = /** @class */ (function () {
             }
         }
         return def;
-    };
+    }
     /**
      * Create document style xml string from the parameters
      * @param {String} name
@@ -501,16 +498,16 @@ var WSDL = /** @class */ (function () {
      * @param {String} nsURI
      * @param {String} type
      */
-    WSDL.prototype.objectToDocumentXML = function (name, params, nsPrefix, nsURI, type) {
+    objectToDocumentXML(name, params, nsPrefix, nsURI, type) {
         // If user supplies XML already, just use that.  XML Declaration should not be present.
         if (params && params._xml) {
             return params._xml;
         }
-        var args = {};
+        const args = {};
         args[name] = params;
-        var parameterTypeObj = type ? this.findSchemaObject(nsURI, type) : null;
+        const parameterTypeObj = type ? this.findSchemaObject(nsURI, type) : null;
         return this.objectToXML(args, null, nsPrefix, nsURI, true, null, parameterTypeObj);
-    };
+    }
     /**
      * Create RPC style xml string from the parameters
      * @param {String} name
@@ -519,43 +516,43 @@ var WSDL = /** @class */ (function () {
      * @param {String} nsURI
      * @returns {string}
      */
-    WSDL.prototype.objectToRpcXML = function (name, params, nsPrefix, nsURI, isParts) {
-        var parts = [];
-        var defs = this.definitions;
-        var nsAttrName = '_xmlns';
-        nsPrefix = nsPrefix || utils_1.findPrefix(defs.xmlns, nsURI);
+    objectToRpcXML(name, params, nsPrefix, nsURI, isParts) {
+        const parts = [];
+        const defs = this.definitions;
+        const nsAttrName = '_xmlns';
+        nsPrefix = nsPrefix || (0, utils_1.findPrefix)(defs.xmlns, nsURI);
         nsURI = nsURI || defs.xmlns[nsPrefix];
         nsPrefix = nsPrefix === utils_1.TNS_PREFIX ? '' : (nsPrefix + ':');
         parts.push(['<', nsPrefix, name, '>'].join(''));
-        for (var key in params) {
+        for (const key in params) {
             if (!params.hasOwnProperty(key)) {
                 continue;
             }
             if (key !== nsAttrName) {
-                var value = params[key];
-                var prefixedKey = (isParts ? '' : nsPrefix) + key;
-                var attributes = [];
+                const value = params[key];
+                const prefixedKey = (isParts ? '' : nsPrefix) + key;
+                const attributes = [];
                 if (typeof value === 'object' && value.hasOwnProperty(this.options.attributesKey)) {
-                    var attrs = value[this.options.attributesKey];
-                    for (var n in attrs) {
+                    const attrs = value[this.options.attributesKey];
+                    for (const n in attrs) {
                         attributes.push(' ' + n + '=' + '"' + attrs[n] + '"');
                     }
                 }
                 parts.push(['<', prefixedKey].concat(attributes).concat('>').join(''));
-                parts.push((typeof value === 'object') ? this.objectToXML(value, key, nsPrefix, nsURI) : utils_1.xmlEscape(value));
+                parts.push((typeof value === 'object') ? this.objectToXML(value, key, nsPrefix, nsURI) : (0, utils_1.xmlEscape)(value));
                 parts.push(['</', prefixedKey, '>'].join(''));
             }
         }
         parts.push(['</', nsPrefix, name, '>'].join(''));
         return parts.join('');
-    };
-    WSDL.prototype.isIgnoredNameSpace = function (ns) {
+    }
+    isIgnoredNameSpace(ns) {
         return this.options.ignoredNamespaces.indexOf(ns) > -1;
-    };
-    WSDL.prototype.filterOutIgnoredNameSpace = function (ns) {
-        var namespace = noColonNameSpace(ns);
+    }
+    filterOutIgnoredNameSpace(ns) {
+        const namespace = noColonNameSpace(ns);
         return this.isIgnoredNameSpace(namespace) ? '' : namespace;
-    };
+    }
     /**
      * Convert an object to XML.  This is a recursive method as it calls itself.
      *
@@ -569,9 +566,9 @@ var WSDL = /** @class */ (function () {
      * @param {?} parameterTypeObject
      * @param {NamespaceContext} nsContext Namespace context
      */
-    WSDL.prototype.objectToXML = function (obj, name, nsPrefix, nsURI, isFirst, xmlnsAttr, schemaObject, nsContext) {
-        var schema = this.definitions.schemas[nsURI];
-        var parentNsPrefix = nsPrefix ? nsPrefix.parent : undefined;
+    objectToXML(obj, name, nsPrefix, nsURI, isFirst, xmlnsAttr, schemaObject, nsContext) {
+        const schema = this.definitions.schemas[nsURI];
+        let parentNsPrefix = nsPrefix ? nsPrefix.parent : undefined;
         if (typeof parentNsPrefix !== 'undefined') {
             // we got the parentNsPrefix for our array. setting the namespace-variable back to the current namespace string
             nsPrefix = nsPrefix.current;
@@ -580,14 +577,14 @@ var WSDL = /** @class */ (function () {
         if (this.isIgnoredNameSpace(parentNsPrefix)) {
             parentNsPrefix = '';
         }
-        var soapHeader = !schema;
-        var qualified = schema && schema.$elementFormDefault === 'qualified';
-        var parts = [];
-        var prefixNamespace = (nsPrefix || qualified) && nsPrefix !== utils_1.TNS_PREFIX;
-        var xmlnsAttrib = '';
+        const soapHeader = !schema;
+        const qualified = schema && schema.$elementFormDefault === 'qualified';
+        const parts = [];
+        const prefixNamespace = (nsPrefix || qualified) && nsPrefix !== utils_1.TNS_PREFIX;
+        let xmlnsAttrib = '';
         if (nsURI && isFirst) {
             if (this.options.overrideRootElement && this.options.overrideRootElement.xmlnsAttributes) {
-                this.options.overrideRootElement.xmlnsAttributes.forEach(function (attribute) {
+                this.options.overrideRootElement.xmlnsAttributes.forEach((attribute) => {
                     xmlnsAttrib += ' ' + attribute.name + '="' + attribute.value + '"';
                 });
             }
@@ -613,20 +610,20 @@ var WSDL = /** @class */ (function () {
         if (xmlnsAttr && !(this.options.overrideRootElement && this.options.overrideRootElement.xmlnsAttributes)) {
             xmlnsAttrib = xmlnsAttr;
         }
-        var ns = '';
+        let ns = '';
         if (this.options.overrideRootElement && isFirst) {
             ns = this.options.overrideRootElement.namespace;
         }
         else if (prefixNamespace && (qualified || isFirst || soapHeader) && !this.isIgnoredNameSpace(nsPrefix)) {
             ns = nsPrefix;
         }
-        var i;
-        var n;
+        let i;
+        let n;
         // start building out XML string.
         if (Array.isArray(obj)) {
-            var nonSubNameSpace = '';
-            var emptyNonSubNameSpaceForArray = false;
-            var nameWithNsRegex = /^([^:]+):([^:]+)$/.exec(name);
+            let nonSubNameSpace = '';
+            let emptyNonSubNameSpaceForArray = false;
+            const nameWithNsRegex = /^([^:]+):([^:]+)$/.exec(name);
             if (nameWithNsRegex) {
                 nonSubNameSpace = nameWithNsRegex[1];
                 name = nameWithNsRegex[2];
@@ -636,11 +633,11 @@ var WSDL = /** @class */ (function () {
                 name = name.substr(1);
             }
             for (i = 0, n = obj.length; i < n; i++) {
-                var item = obj[i];
-                var arrayAttr = this.processAttributes(item, nsContext);
-                var correctOuterNsPrefix = nonSubNameSpace || parentNsPrefix || ns; // using the parent namespace prefix if given
-                var body = this.objectToXML(item, name, nsPrefix, nsURI, false, null, schemaObject, nsContext);
-                var openingTagParts = ['<', name, arrayAttr, xmlnsAttrib];
+                const item = obj[i];
+                const arrayAttr = this.processAttributes(item, nsContext);
+                const correctOuterNsPrefix = nonSubNameSpace || parentNsPrefix || ns; // using the parent namespace prefix if given
+                const body = this.objectToXML(item, name, nsPrefix, nsURI, false, null, schemaObject, nsContext);
+                let openingTagParts = ['<', name, arrayAttr, xmlnsAttrib];
                 if (!emptyNonSubNameSpaceForArray) {
                     openingTagParts = ['<', appendColon(correctOuterNsPrefix), name, arrayAttr, xmlnsAttrib];
                 }
@@ -667,7 +664,7 @@ var WSDL = /** @class */ (function () {
             }
         }
         else if (typeof obj === 'object') {
-            var currentChildXmlnsAttrib = '';
+            let currentChildXmlnsAttrib = '';
             for (name in obj) {
                 // Happens when Object.create(null) is used, it will not inherit the Object prototype
                 if (!obj.hasOwnProperty) {
@@ -688,17 +685,17 @@ var WSDL = /** @class */ (function () {
                 // Its the value of an item. Return it directly.
                 if (name === this.options.valueKey) {
                     nsContext.popContext();
-                    return utils_1.xmlEscape(obj[name]);
+                    return (0, utils_1.xmlEscape)(obj[name]);
                 }
-                var child = obj[name];
+                const child = obj[name];
                 if (typeof child === 'undefined') {
                     continue;
                 }
-                var attr = this.processAttributes(child, nsContext);
-                var value = '';
-                var nonSubNameSpace = '';
-                var emptyNonSubNameSpace = false;
-                var nameWithNsRegex = /^([^:]+):([^:]+)$/.exec(name);
+                const attr = this.processAttributes(child, nsContext);
+                let value = '';
+                let nonSubNameSpace = '';
+                let emptyNonSubNameSpace = false;
+                const nameWithNsRegex = /^([^:]+):([^:]+)$/.exec(name);
                 if (nameWithNsRegex) {
                     nonSubNameSpace = nameWithNsRegex[1] + ':';
                     name = nameWithNsRegex[2];
@@ -713,7 +710,7 @@ var WSDL = /** @class */ (function () {
                 else {
                     if (this.definitions.schemas) {
                         if (schema) {
-                            var childSchemaObject = this.findChildSchemaObject(schemaObject, name);
+                            const childSchemaObject = this.findChildSchemaObject(schemaObject, name);
                             // find sub namespace if not a primitive
                             if (childSchemaObject &&
                                 ((childSchemaObject.$type && (childSchemaObject.$type.indexOf('xsd:') === -1)) ||
@@ -721,13 +718,13 @@ var WSDL = /** @class */ (function () {
                                 /*if the base name space of the children is not in the ingoredSchemaNamspaces we use it.
                                  This is because in some services the child nodes do not need the baseNameSpace.
                                  */
-                                var childNsPrefix = '';
-                                var childName = '';
-                                var childNsURI = void 0;
-                                var childXmlnsAttrib = '';
-                                var elementQName = childSchemaObject.$ref || childSchemaObject.$name;
+                                let childNsPrefix = '';
+                                let childName = '';
+                                let childNsURI;
+                                let childXmlnsAttrib = '';
+                                let elementQName = childSchemaObject.$ref || childSchemaObject.$name;
                                 if (elementQName) {
-                                    elementQName = utils_1.splitQName(elementQName);
+                                    elementQName = (0, utils_1.splitQName)(elementQName);
                                     childName = elementQName.name;
                                     if (elementQName.prefix === utils_1.TNS_PREFIX) {
                                         // Local element
@@ -744,7 +741,7 @@ var WSDL = /** @class */ (function () {
                                         }
                                         childNsURI = schema.xmlns[childNsPrefix] || this.definitions.xmlns[childNsPrefix];
                                     }
-                                    var unqualified = false;
+                                    let unqualified = false;
                                     // Check qualification form for local elements
                                     if (childSchemaObject.$name && childSchemaObject.targetNamespace === undefined) {
                                         if (childSchemaObject.$form === 'unqualified') {
@@ -770,11 +767,11 @@ var WSDL = /** @class */ (function () {
                                         }
                                     }
                                 }
-                                var resolvedChildSchemaObject = void 0;
+                                let resolvedChildSchemaObject;
                                 if (childSchemaObject.$type) {
-                                    var typeQName = utils_1.splitQName(childSchemaObject.$type);
-                                    var typePrefix = typeQName.prefix;
-                                    var typeURI = schema.xmlns[typePrefix] || this.definitions.xmlns[typePrefix];
+                                    const typeQName = (0, utils_1.splitQName)(childSchemaObject.$type);
+                                    const typePrefix = typeQName.prefix;
+                                    const typeURI = schema.xmlns[typePrefix] || this.definitions.xmlns[typePrefix];
                                     childNsURI = typeURI;
                                     if (typeURI !== 'http://www.w3.org/2001/XMLSchema' && typePrefix !== utils_1.TNS_PREFIX) {
                                         // Add the prefix/namespace mapping, but not declare it
@@ -800,7 +797,7 @@ var WSDL = /** @class */ (function () {
                                     // for arrays, we need to remember the current namespace
                                     childNsPrefix = {
                                         current: childNsPrefix,
-                                        parent: ns
+                                        parent: ns,
                                     };
                                     childXmlnsAttrib = childXmlnsAttrib && childXmlnsAttrib.length ? childXmlnsAttrib : currentChildXmlnsAttrib;
                                 }
@@ -812,7 +809,7 @@ var WSDL = /** @class */ (function () {
                             }
                             else if (obj[this.options.attributesKey] && obj[this.options.attributesKey].xsi_type) {
                                 // if parent object has complex type defined and child not found in parent
-                                var completeChildParamTypeObject = this.findChildSchemaObject(obj[this.options.attributesKey].xsi_type.type, obj[this.options.attributesKey].xsi_type.xmlns);
+                                const completeChildParamTypeObject = this.findChildSchemaObject(obj[this.options.attributesKey].xsi_type.type, obj[this.options.attributesKey].xsi_type.xmlns);
                                 nonSubNameSpace = obj[this.options.attributesKey].xsi_type.prefix;
                                 nsContext.addNamespace(obj[this.options.attributesKey].xsi_type.prefix, obj[this.options.attributesKey].xsi_type.xmlns);
                                 value = this.objectToXML(child, name, obj[this.options.attributesKey].xsi_type.prefix, obj[this.options.attributesKey].xsi_type.xmlns, false, null, null, nsContext);
@@ -841,7 +838,7 @@ var WSDL = /** @class */ (function () {
                 else if (this.isIgnoredNameSpace(ns)) {
                     ns = '';
                 }
-                var useEmptyTag = !value && this.options.useEmptyTag;
+                const useEmptyTag = !value && this.options.useEmptyTag;
                 if (!Array.isArray(child)) {
                     // start tag
                     parts.push(['<', emptyNonSubNameSpace ? '' : appendColon(nonSubNameSpace || ns), name, attr, xmlnsAttrib,
@@ -859,20 +856,20 @@ var WSDL = /** @class */ (function () {
             }
         }
         else if (obj !== undefined) {
-            parts.push((this.options.escapeXML) ? utils_1.xmlEscape(obj) : obj);
+            parts.push((this.options.escapeXML) ? (0, utils_1.xmlEscape)(obj) : obj);
         }
         nsContext.popContext();
         return parts.join('');
-    };
-    WSDL.prototype.processAttributes = function (child, nsContext) {
-        var attr = '';
+    }
+    processAttributes(child, nsContext) {
+        let attr = '';
         if (child === null || child === undefined) {
             child = [];
         }
-        var attrObj = child[this.options.attributesKey] || {};
+        const attrObj = child[this.options.attributesKey] || {};
         if (attrObj && attrObj.xsi_type) {
-            var xsiType = attrObj.xsi_type;
-            var prefix = xsiType.prefix || xsiType.namespace;
+            const xsiType = attrObj.xsi_type;
+            let prefix = xsiType.prefix || xsiType.namespace;
             if (xsiType.xmlns) {
                 // Generate a new namespace for complex extension if one not provided
                 if (!prefix) {
@@ -884,41 +881,41 @@ var WSDL = /** @class */ (function () {
                 xsiType.prefix = prefix;
             }
         }
-        Object.keys(attrObj).forEach(function (k) {
-            var v = attrObj[k];
+        Object.keys(attrObj).forEach((k) => {
+            const v = attrObj[k];
             if (k === 'xsi_type') {
-                var name_2 = v.type;
+                let name = v.type;
                 if (v.prefix) {
-                    name_2 = v.prefix + ":" + name_2;
+                    name = `${v.prefix}:${name}`;
                 }
-                attr += " xsi:type=\"" + name_2 + "\"";
+                attr += ` xsi:type="${name}"`;
                 if (v.xmlns) {
-                    attr += " xmlns:" + v.prefix + "=\"" + v.xmlns + "\"";
+                    attr += ` xmlns:${v.prefix}="${v.xmlns}"`;
                 }
             }
             else {
-                attr += " " + k + "=\"" + utils_1.xmlEscape(v) + "\"";
+                attr += ` ${k}="${(0, utils_1.xmlEscape)(v)}"`;
             }
         });
         return attr;
-    };
+    }
     /**
      * Look up a schema type definition
      * @param name
      * @param nsURI
      * @returns {*}
      */
-    WSDL.prototype.findSchemaType = function (name, nsURI) {
+    findSchemaType(name, nsURI) {
         if (!this.definitions.schemas || !name || !nsURI) {
             return null;
         }
-        var schema = this.definitions.schemas[nsURI];
+        const schema = this.definitions.schemas[nsURI];
         if (!schema || !schema.complexTypes) {
             return null;
         }
         return schema.complexTypes[name];
-    };
-    WSDL.prototype.findChildSchemaObject = function (parameterTypeObj, childName, backtrace) {
+    }
+    findChildSchemaObject(parameterTypeObj, childName, backtrace) {
         if (!parameterTypeObj || !childName) {
             return null;
         }
@@ -932,53 +929,53 @@ var WSDL = /** @class */ (function () {
         else {
             backtrace = backtrace.concat([parameterTypeObj]);
         }
-        var found = null;
-        var i = 0;
-        var child;
-        var ref;
+        let found = null;
+        let i = 0;
+        let child;
+        let ref;
         if (Array.isArray(parameterTypeObj.$lookupTypes) && parameterTypeObj.$lookupTypes.length) {
-            var types = parameterTypeObj.$lookupTypes;
+            const types = parameterTypeObj.$lookupTypes;
             for (i = 0; i < types.length; i++) {
-                var typeObj = types[i];
+                const typeObj = types[i];
                 if (typeObj.$name === childName) {
                     found = typeObj;
                     break;
                 }
             }
         }
-        var object = parameterTypeObj;
+        const object = parameterTypeObj;
         if (object.$name === childName && object.name === 'element') {
             return object;
         }
         if (object.$ref) {
-            ref = utils_1.splitQName(object.$ref);
+            ref = (0, utils_1.splitQName)(object.$ref);
             if (ref.name === childName) {
                 return object;
             }
         }
-        var childNsURI;
+        let childNsURI;
         // want to avoid unecessary recursion to improve performance
         if (object.$type && backtrace.length === 1) {
-            var typeInfo = utils_1.splitQName(object.$type);
+            const typeInfo = (0, utils_1.splitQName)(object.$type);
             if (typeInfo.prefix === utils_1.TNS_PREFIX) {
                 childNsURI = parameterTypeObj.$targetNamespace;
             }
             else {
                 childNsURI = this.definitions.xmlns[typeInfo.prefix];
             }
-            var typeDef = this.findSchemaType(typeInfo.name, childNsURI);
+            const typeDef = this.findSchemaType(typeInfo.name, childNsURI);
             if (typeDef) {
                 return this.findChildSchemaObject(typeDef, childName, backtrace);
             }
         }
         // handle $base (e.g. for ExtensionElement) like $type
         if (object.$base && (!Array.isArray(object.children) || !object.children.length)) {
-            var baseInfo = utils_1.splitQName(object.$base);
+            const baseInfo = (0, utils_1.splitQName)(object.$base);
             childNsURI = parameterTypeObj.$targetNamespace;
             if (baseInfo.prefix !== utils_1.TNS_PREFIX) {
                 childNsURI = this.definitions.xmlns[baseInfo.prefix];
             }
-            var baseDef = this.findSchemaType(baseInfo.name, childNsURI);
+            const baseDef = this.findSchemaType(baseInfo.name, childNsURI);
             if (baseDef) {
                 return this.findChildSchemaObject(baseDef, childName, backtrace);
             }
@@ -990,10 +987,10 @@ var WSDL = /** @class */ (function () {
                     break;
                 }
                 if (child.$base) {
-                    var baseQName = utils_1.splitQName(child.$base);
-                    var childNameSpace = baseQName.prefix === utils_1.TNS_PREFIX ? '' : baseQName.prefix;
+                    const baseQName = (0, utils_1.splitQName)(child.$base);
+                    const childNameSpace = baseQName.prefix === utils_1.TNS_PREFIX ? '' : baseQName.prefix;
                     childNsURI = child.xmlns[baseQName.prefix] || child.schemaXmlns[baseQName.prefix];
-                    var foundBase = this.findSchemaType(baseQName.name, childNsURI);
+                    const foundBase = this.findSchemaType(baseQName.name, childNsURI);
                     if (foundBase) {
                         found = this.findChildSchemaObject(foundBase, childName, backtrace);
                         if (found) {
@@ -1009,11 +1006,11 @@ var WSDL = /** @class */ (function () {
             return object;
         }
         return found;
-    };
-    WSDL.prototype._initializeOptions = function (options) {
+    }
+    _initializeOptions(options) {
         this._originalIgnoredNamespaces = (options || {}).ignoredNamespaces;
         this.options = {};
-        var ignoredNamespaces = options ? options.ignoredNamespaces : null;
+        const ignoredNamespaces = options ? options.ignoredNamespaces : null;
         if (ignoredNamespaces &&
             (Array.isArray(ignoredNamespaces.namespaces) || typeof ignoredNamespaces.namespaces === 'string')) {
             if (ignoredNamespaces.override) {
@@ -1057,7 +1054,7 @@ var WSDL = /** @class */ (function () {
         if (options.request) {
             this.options.request = options.request;
         }
-        var ignoreBaseNameSpaces = options ? options.ignoreBaseNameSpaces : null;
+        const ignoreBaseNameSpaces = options ? options.ignoreBaseNameSpaces : null;
         if (ignoreBaseNameSpaces !== null && typeof ignoreBaseNameSpaces !== 'undefined') {
             this.options.ignoreBaseNameSpaces = ignoreBaseNameSpaces;
         }
@@ -1071,16 +1068,15 @@ var WSDL = /** @class */ (function () {
             this.options.overrideRootElement = options.overrideRootElement;
         }
         this.options.useEmptyTag = !!options.useEmptyTag;
-    };
-    WSDL.prototype._processNextInclude = function (includes, callback) {
-        var _this = this;
-        var include = includes.shift();
+    }
+    _processNextInclude(includes, callback) {
+        const include = includes.shift();
         if (!include) {
             return callback();
         }
-        var includePath;
+        let includePath;
         if (!/^https?:/i.test(this.uri) && !/^https?:/i.test(include.location)) {
-            var isFixed = (this.options.wsdl_options !== undefined && this.options.wsdl_options.hasOwnProperty('fixedPath')) ? this.options.wsdl_options.fixedPath : false;
+            const isFixed = (this.options.wsdl_options !== undefined && this.options.wsdl_options.hasOwnProperty('fixedPath')) ? this.options.wsdl_options.fixedPath : false;
             if (isFixed) {
                 includePath = path.resolve(path.dirname(this.uri), path.parse(include.location).base);
             }
@@ -1094,42 +1090,41 @@ var WSDL = /** @class */ (function () {
         if (this.options.wsdl_options !== undefined && typeof this.options.wsdl_options.overrideImportLocation === 'function') {
             includePath = this.options.wsdl_options.overrideImportLocation(includePath);
         }
-        var options = Object.assign({}, this.options);
+        const options = Object.assign({}, this.options);
         // follow supplied ignoredNamespaces option
         options.ignoredNamespaces = this._originalIgnoredNamespaces || this.options.ignoredNamespaces;
         options.WSDL_CACHE = this.WSDL_CACHE;
-        open_wsdl_recursive(includePath, options, function (err, wsdl) {
+        open_wsdl_recursive(includePath, options, (err, wsdl) => {
             if (err) {
                 return callback(err);
             }
-            _this._includesWsdl.push(wsdl);
+            this._includesWsdl.push(wsdl);
             if (wsdl.definitions instanceof elements.DefinitionsElement) {
-                _.mergeWith(_this.definitions, wsdl.definitions, function (a, b) {
+                _.mergeWith(this.definitions, wsdl.definitions, (a, b) => {
                     return (a instanceof elements.SchemaElement) ? a.merge(b) : undefined;
                 });
             }
             else {
                 return callback(new Error('wsdl.defintions is not an instance of elements.DefinitionsElement'));
             }
-            _this._processNextInclude(includes, function (err) {
+            this._processNextInclude(includes, (err) => {
                 callback(err);
             });
         });
-    };
-    WSDL.prototype._parse = function (xml) {
-        var _this = this;
-        var p = sax.parser(true, null);
-        var stack = [];
-        var root = null;
-        var types = null;
-        var schema = null;
-        var schemaAttrs = null;
-        var options = this.options;
-        p.onopentag = function (node) {
-            var nsName = node.name;
-            var attrs = node.attributes;
-            var top = stack[stack.length - 1];
-            var name = utils_1.splitQName(nsName).name;
+    }
+    _parse(xml) {
+        const p = sax.parser(true, null);
+        const stack = [];
+        let root = null;
+        let types = null;
+        let schema = null;
+        let schemaAttrs = null;
+        const options = this.options;
+        p.onopentag = (node) => {
+            const nsName = node.name;
+            const attrs = node.attributes;
+            const top = stack[stack.length - 1];
+            const name = (0, utils_1.splitQName)(nsName).name;
             if (name === 'schema') {
                 schemaAttrs = attrs;
             }
@@ -1138,7 +1133,7 @@ var WSDL = /** @class */ (function () {
                     top.startElement(stack, nsName, attrs, options, schemaAttrs);
                 }
                 catch (e) {
-                    if (_this.options.strict) {
+                    if (this.options.strict) {
                         throw e;
                     }
                     else {
@@ -1165,32 +1160,32 @@ var WSDL = /** @class */ (function () {
                 }
             }
         };
-        p.onclosetag = function (name) {
-            var top = stack[stack.length - 1];
-            assert_1.ok(top, 'Unmatched close tag: ' + name);
+        p.onclosetag = (name) => {
+            const top = stack[stack.length - 1];
+            (0, assert_1.ok)(top, 'Unmatched close tag: ' + name);
             top.endElement(stack, name);
         };
         p.write(xml).close();
         return root;
-    };
-    WSDL.prototype._fromXML = function (xml) {
+    }
+    _fromXML(xml) {
         this.definitions = this._parse(xml);
         this.definitions.descriptions = {
             types: {},
-            elements: {}
+            elements: {},
         };
         this.xml = xml;
-    };
-    WSDL.prototype._fromServices = function (services) {
-    };
-    WSDL.prototype._xmlnsMap = function () {
-        var xmlns = this.definitions.xmlns;
-        var str = '';
-        for (var alias in xmlns) {
+    }
+    _fromServices(services) {
+    }
+    _xmlnsMap() {
+        const xmlns = this.definitions.xmlns;
+        let str = '';
+        for (const alias in xmlns) {
             if (alias === '' || alias === utils_1.TNS_PREFIX) {
                 continue;
             }
-            var ns = xmlns[alias];
+            const ns = xmlns[alias];
             switch (ns) {
                 case 'http://xml.apache.org/xml-soap': // apachesoap
                 case 'http://schemas.xmlsoap.org/wsdl/': // wsdl
@@ -1212,15 +1207,14 @@ var WSDL = /** @class */ (function () {
             str += ' xmlns:' + alias + '="' + ns + '"';
         }
         return str;
-    };
-    return WSDL;
-}());
+    }
+}
 exports.WSDL = WSDL;
 function open_wsdl_recursive(uri, p2, p3) {
-    var fromCache;
-    var WSDL_CACHE;
-    var options;
-    var callback;
+    let fromCache;
+    let WSDL_CACHE;
+    let options;
+    let callback;
     if (typeof p2 === 'function') {
         options = {};
         callback = p2;
@@ -1236,8 +1230,8 @@ function open_wsdl_recursive(uri, p2, p3) {
     return open_wsdl(uri, options, callback);
 }
 function open_wsdl(uri, p2, p3) {
-    var options;
-    var callback;
+    let options;
+    let callback;
     if (typeof p2 === 'function') {
         options = {};
         callback = p2;
@@ -1247,13 +1241,19 @@ function open_wsdl(uri, p2, p3) {
         callback = p3;
     }
     // initialize cache when calling open_wsdl directly
-    var WSDL_CACHE = options.WSDL_CACHE || {};
-    var request_headers = options.wsdl_headers;
-    var request_options = options.wsdl_options;
-    var wsdl;
-    if (!/^https?:/i.test(uri)) {
+    const WSDL_CACHE = options.WSDL_CACHE || {};
+    const request_headers = options.wsdl_headers;
+    const request_options = options.wsdl_options;
+    let wsdl;
+    if (/^\<\?xml[^>]*?>/i.test(uri)) {
+        wsdl = new WSDL(uri, uri, options);
+        WSDL_CACHE[uri] = wsdl;
+        wsdl.WSDL_CACHE = WSDL_CACHE;
+        wsdl.onReady(callback);
+    }
+    else if (!/^https?:/i.test(uri)) {
         debug('Reading file: %s', uri);
-        fs.readFile(uri, 'utf8', function (err, definition) {
+        fs.readFile(uri, 'utf8', (err, definition) => {
             if (err) {
                 callback(err);
             }
@@ -1267,8 +1267,8 @@ function open_wsdl(uri, p2, p3) {
     }
     else {
         debug('Reading url: %s', uri);
-        var httpClient = options.httpClient || new http_1.HttpClient(options);
-        httpClient.request(uri, null /* options */, function (err, response, definition) {
+        const httpClient = options.httpClient || new http_1.HttpClient(options);
+        httpClient.request(uri, null /* options */, (err, response, definition) => {
             if (err) {
                 callback(err);
             }