xmldsigjs-hotfix
Version:
XMLDSIGjs provides an implementation of XMLDSIG in Typescript/Javascript based on WebCrypto
1,673 lines (1,395 loc) • 729 kB
JavaScript
var XmlDSigJs = (function (exports) {
'use strict';
function _typeof(obj) {
"@babel/helpers - typeof";
if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") {
_typeof = function (obj) {
return typeof obj;
};
} else {
_typeof = function (obj) {
return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
};
}
return _typeof(obj);
}
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
try {
var info = gen[key](arg);
var value = info.value;
} catch (error) {
reject(error);
return;
}
if (info.done) {
resolve(value);
} else {
Promise.resolve(value).then(_next, _throw);
}
}
function _asyncToGenerator(fn) {
return function () {
var self = this,
args = arguments;
return new Promise(function (resolve, reject) {
var gen = fn.apply(self, args);
function _next(value) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
}
function _throw(err) {
asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
}
_next(undefined);
});
};
}
function _classCallCheck(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function _defineProperties(target, props) {
for (var i = 0; i < props.length; i++) {
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _createClass(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
if (staticProps) _defineProperties(Constructor, staticProps);
return Constructor;
}
function _inherits(subClass, superClass) {
if (typeof superClass !== "function" && superClass !== null) {
throw new TypeError("Super expression must either be null or a function");
}
subClass.prototype = Object.create(superClass && superClass.prototype, {
constructor: {
value: subClass,
writable: true,
configurable: true
}
});
if (superClass) _setPrototypeOf(subClass, superClass);
}
function _getPrototypeOf(o) {
_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
return o.__proto__ || Object.getPrototypeOf(o);
};
return _getPrototypeOf(o);
}
function _setPrototypeOf(o, p) {
_setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
o.__proto__ = p;
return o;
};
return _setPrototypeOf(o, p);
}
function _isNativeReflectConstruct() {
if (typeof Reflect === "undefined" || !Reflect.construct) return false;
if (Reflect.construct.sham) return false;
if (typeof Proxy === "function") return true;
try {
Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
return true;
} catch (e) {
return false;
}
}
function _assertThisInitialized(self) {
if (self === void 0) {
throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
}
return self;
}
function _possibleConstructorReturn(self, call) {
if (call && (typeof call === "object" || typeof call === "function")) {
return call;
}
return _assertThisInitialized(self);
}
function _createSuper(Derived) {
var hasNativeReflectConstruct = _isNativeReflectConstruct();
return function _createSuperInternal() {
var Super = _getPrototypeOf(Derived),
result;
if (hasNativeReflectConstruct) {
var NewTarget = _getPrototypeOf(this).constructor;
result = Reflect.construct(Super, arguments, NewTarget);
} else {
result = Super.apply(this, arguments);
}
return _possibleConstructorReturn(this, result);
};
}
function _superPropBase(object, property) {
while (!Object.prototype.hasOwnProperty.call(object, property)) {
object = _getPrototypeOf(object);
if (object === null) break;
}
return object;
}
function _get(target, property, receiver) {
if (typeof Reflect !== "undefined" && Reflect.get) {
_get = Reflect.get;
} else {
_get = function _get(target, property, receiver) {
var base = _superPropBase(target, property);
if (!base) return;
var desc = Object.getOwnPropertyDescriptor(base, property);
if (desc.get) {
return desc.get.call(receiver);
}
return desc.value;
};
}
return _get(target, property, receiver || target);
}
function _slicedToArray(arr, i) {
return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
}
function _toConsumableArray(arr) {
return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
}
function _arrayWithoutHoles(arr) {
if (Array.isArray(arr)) return _arrayLikeToArray(arr);
}
function _arrayWithHoles(arr) {
if (Array.isArray(arr)) return arr;
}
function _iterableToArray(iter) {
if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter);
}
function _iterableToArrayLimit(arr, i) {
if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return;
var _arr = [];
var _n = true;
var _d = false;
var _e = undefined;
try {
for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) {
_arr.push(_s.value);
if (i && _arr.length === i) break;
}
} catch (err) {
_d = true;
_e = err;
} finally {
try {
if (!_n && _i["return"] != null) _i["return"]();
} finally {
if (_d) throw _e;
}
}
return _arr;
}
function _unsupportedIterableToArray(o, minLen) {
if (!o) return;
if (typeof o === "string") return _arrayLikeToArray(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(o);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
}
function _arrayLikeToArray(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
return arr2;
}
function _nonIterableSpread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _nonIterableRest() {
throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _createForOfIteratorHelper(o, allowArrayLike) {
var it;
if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) {
if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
if (it) o = it;
var i = 0;
var F = function () {};
return {
s: F,
n: function () {
if (i >= o.length) return {
done: true
};
return {
done: false,
value: o[i++]
};
},
e: function (e) {
throw e;
},
f: F
};
}
throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
var normalCompletion = true,
didErr = false,
err;
return {
s: function () {
it = o[Symbol.iterator]();
},
n: function () {
var step = it.next();
normalCompletion = step.done;
return step;
},
e: function (e) {
didErr = true;
err = e;
},
f: function () {
try {
if (!normalCompletion && it.return != null) it.return();
} finally {
if (didErr) throw err;
}
}
};
}
var ELEMENT = "element";
var ATTRIBUTE = "attribute";
var CONTENT = "content";
var MAX = 1e9;
function assign(target) {
for (var _len = arguments.length, sources = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
sources[_key - 1] = arguments[_key];
}
var res = arguments[0];
for (var i = 1; i < arguments.length; i++) {
var obj = arguments[i];
for (var prop in obj) {
if (!obj.hasOwnProperty(prop)) {
continue;
}
res[prop] = obj[prop];
}
}
return res;
}
function XmlElement(params) {
return function (target) {
var t = target;
t.localName = params.localName || t.name;
t.namespaceURI = params.namespaceURI || t.namespaceURI || null;
t.prefix = params.prefix || t.prefix || null;
t.parser = params.parser || t.parser;
if (t.target !== t) {
t.items = assign({}, t.items);
}
t.target = target;
};
}
function XmlChildElement() {
var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
return function (target, propertyKey) {
var t = target.constructor;
var key = propertyKey;
if (!t.items) {
t.items = {};
}
if (t.target !== t) {
t.items = assign({}, t.items);
}
t.target = target;
if (params.parser) {
t.items[key] = {
parser: params.parser,
required: params.required || false,
maxOccurs: params.maxOccurs || MAX,
minOccurs: params.minOccurs === void 0 ? 0 : params.minOccurs,
noRoot: params.noRoot || false
};
} else {
t.items[key] = {
namespaceURI: params.namespaceURI || null,
required: params.required || false,
prefix: params.prefix || null,
defaultValue: params.defaultValue,
converter: params.converter,
noRoot: params.noRoot || false
};
}
params.localName = params.localName || params.parser && params.parser.localName || key;
t.items[key].namespaceURI = params.namespaceURI || params.parser && params.parser.namespaceURI || null;
t.items[key].prefix = params.prefix || params.parser && params.parser.prefix || null;
t.items[key].localName = params.localName;
t.items[key].type = ELEMENT;
defineProperty(target, key, params);
};
}
function XmlAttribute() {
var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {
required: false,
namespaceURI: null
};
return function (target, propertyKey) {
var t = target.constructor;
var key = propertyKey;
if (!params.localName) {
params.localName = propertyKey;
}
if (!t.items) {
t.items = {};
}
if (t.target !== t) {
t.items = assign({}, t.items);
}
t.target = target;
t.items[propertyKey] = params;
t.items[propertyKey].type = ATTRIBUTE;
defineProperty(target, key, params);
};
}
function defineProperty(target, key, params) {
var key2 = "_".concat(key);
var opt = {
set: function set(v) {
if (this[key2] !== v) {
this.element = null;
this[key2] = v;
}
},
get: function get() {
if (this[key2] === void 0) {
var defaultValue = params.defaultValue;
if (params.parser) {
defaultValue = new params.parser();
defaultValue.localName = params.localName;
}
this[key2] = defaultValue;
}
return this[key2];
}
};
Object.defineProperty(target, key2, {
writable: true,
enumerable: false
});
Object.defineProperty(target, key, opt);
}
var Collection = function () {
function Collection(items) {
_classCallCheck(this, Collection);
this.items = new Array();
if (items) {
this.items = items;
}
}
_createClass(Collection, [{
key: "Item",
value: function Item(index) {
return this.items[index] || null;
}
}, {
key: "Add",
value: function Add(item) {
this.items.push(item);
}
}, {
key: "Pop",
value: function Pop() {
return this.items.pop();
}
}, {
key: "RemoveAt",
value: function RemoveAt(index) {
this.items = this.items.filter(function (item, index2) {
return index2 !== index;
});
}
}, {
key: "Clear",
value: function Clear() {
this.items = new Array();
}
}, {
key: "GetIterator",
value: function GetIterator() {
return this.items;
}
}, {
key: "ForEach",
value: function ForEach(cb) {
this.GetIterator().forEach(cb);
}
}, {
key: "Map",
value: function Map(cb) {
return new Collection(this.GetIterator().map(cb));
}
}, {
key: "Filter",
value: function Filter(cb) {
return new Collection(this.GetIterator().filter(cb));
}
}, {
key: "Sort",
value: function Sort(cb) {
return new Collection(this.GetIterator().sort(cb));
}
}, {
key: "Every",
value: function Every(cb) {
return this.GetIterator().every(cb);
}
}, {
key: "Some",
value: function Some(cb) {
return this.GetIterator().some(cb);
}
}, {
key: "IsEmpty",
value: function IsEmpty() {
return this.Count === 0;
}
}, {
key: "Count",
get: function get() {
return this.items.length;
}
}]);
return Collection;
}();
function printf(text) {
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
args[_key2 - 1] = arguments[_key2];
}
var msg = text;
var regFind = /[^%](%\d+)/g;
var match = null;
var matches = [];
while (match = regFind.exec(msg)) {
matches.push({
arg: match[1],
index: match.index
});
}
for (var i = matches.length - 1; i >= 0; i--) {
var item = matches[i];
var arg = item.arg.substring(1);
var index = item.index + 1;
msg = msg.substring(0, index) + arguments[+arg] + msg.substring(index + 1 + arg.length);
}
msg = msg.replace("%%", "%");
return msg;
}
function padNum(num, size) {
var s = num + "";
while (s.length < size) {
s = "0" + s;
}
return s;
}
var XmlError = function XmlError(code) {
for (var _len3 = arguments.length, args = new Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
args[_key3 - 1] = arguments[_key3];
}
_classCallCheck(this, XmlError);
this.prefix = "XMLJS";
this.code = code;
this.name = this.constructor.name;
arguments[0] = xes[code];
var message = printf.apply(this, arguments);
this.message = "".concat(this.prefix).concat(padNum(code, 4), ": ").concat(message);
this.stack = new Error(this.message).stack;
};
var XE;
(function (XE) {
XE[XE["NONE"] = 0] = "NONE";
XE[XE["NULL_REFERENCE"] = 1] = "NULL_REFERENCE";
XE[XE["NULL_PARAM"] = 2] = "NULL_PARAM";
XE[XE["DECORATOR_NULL_PARAM"] = 3] = "DECORATOR_NULL_PARAM";
XE[XE["COLLECTION_LIMIT"] = 4] = "COLLECTION_LIMIT";
XE[XE["METHOD_NOT_IMPLEMENTED"] = 5] = "METHOD_NOT_IMPLEMENTED";
XE[XE["METHOD_NOT_SUPPORTED"] = 6] = "METHOD_NOT_SUPPORTED";
XE[XE["PARAM_REQUIRED"] = 7] = "PARAM_REQUIRED";
XE[XE["CONVERTER_UNSUPPORTED"] = 8] = "CONVERTER_UNSUPPORTED";
XE[XE["ELEMENT_MALFORMED"] = 9] = "ELEMENT_MALFORMED";
XE[XE["ELEMENT_MISSING"] = 10] = "ELEMENT_MISSING";
XE[XE["ATTRIBUTE_MISSING"] = 11] = "ATTRIBUTE_MISSING";
XE[XE["CONTENT_MISSING"] = 12] = "CONTENT_MISSING";
XE[XE["CRYPTOGRAPHIC"] = 13] = "CRYPTOGRAPHIC";
XE[XE["CRYPTOGRAPHIC_NO_MODULE"] = 14] = "CRYPTOGRAPHIC_NO_MODULE";
XE[XE["CRYPTOGRAPHIC_UNKNOWN_TRANSFORM"] = 15] = "CRYPTOGRAPHIC_UNKNOWN_TRANSFORM";
XE[XE["ALGORITHM_NOT_SUPPORTED"] = 16] = "ALGORITHM_NOT_SUPPORTED";
XE[XE["ALGORITHM_WRONG_NAME"] = 17] = "ALGORITHM_WRONG_NAME";
XE[XE["XML_EXCEPTION"] = 18] = "XML_EXCEPTION";
})(XE || (XE = {}));
var xes = {};
xes[XE.NONE] = "No description";
xes[XE.NULL_REFERENCE] = "Null reference";
xes[XE.NULL_PARAM] = "'%1' has empty '%2' object";
xes[XE.DECORATOR_NULL_PARAM] = "Decorator '%1' has empty '%2' parameter";
xes[XE.COLLECTION_LIMIT] = "Collection of '%1' in element '%2' has wrong amount of items";
xes[XE.METHOD_NOT_IMPLEMENTED] = "Method is not implemented";
xes[XE.METHOD_NOT_SUPPORTED] = "Method is not supported";
xes[XE.PARAM_REQUIRED] = "Required parameter is missing '%1'";
xes[XE.CONVERTER_UNSUPPORTED] = "Converter is not supported";
xes[XE.ELEMENT_MALFORMED] = "Malformed element '%1'";
xes[XE.ELEMENT_MISSING] = "Element '%1' is missing in '%2'";
xes[XE.ATTRIBUTE_MISSING] = "Attribute '%1' is missing in '%2'";
xes[XE.CONTENT_MISSING] = "Content is missing in '%1'";
xes[XE.CRYPTOGRAPHIC] = "Cryptographic error: %1";
xes[XE.CRYPTOGRAPHIC_NO_MODULE] = "WebCrypto module is not found";
xes[XE.CRYPTOGRAPHIC_UNKNOWN_TRANSFORM] = "Unknown transform %1";
xes[XE.ALGORITHM_NOT_SUPPORTED] = "Algorithm is not supported '%1'";
xes[XE.ALGORITHM_WRONG_NAME] = "Algorithm wrong name in use '%1'";
xes[XE.XML_EXCEPTION] = "XML exception: %1";
var Convert = function () {
function Convert() {
_classCallCheck(this, Convert);
}
_createClass(Convert, null, [{
key: "ToString",
value: function ToString(buffer) {
var enc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "utf8";
var buf = new Uint8Array(buffer);
switch (enc.toLowerCase()) {
case "utf8":
return this.ToUtf8String(buf);
case "binary":
return this.ToBinary(buf);
case "hex":
return this.ToHex(buf);
case "base64":
return this.ToBase64(buf);
case "base64url":
return this.ToBase64Url(buf);
default:
throw new XmlError(XE.CONVERTER_UNSUPPORTED);
}
}
}, {
key: "FromString",
value: function FromString(str) {
var enc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "utf8";
switch (enc.toLowerCase()) {
case "utf8":
return this.FromUtf8String(str);
case "binary":
return this.FromBinary(str);
case "hex":
return this.FromHex(str);
case "base64":
return this.FromBase64(str);
case "base64url":
return this.FromBase64Url(str);
default:
throw new XmlError(XE.CONVERTER_UNSUPPORTED);
}
}
}, {
key: "ToBase64",
value: function ToBase64(buf) {
if (typeof btoa !== "undefined") {
var binary = this.ToString(buf, "binary");
return btoa(binary);
} else if (typeof Buffer !== "undefined") {
return Buffer.from(buf).toString("base64");
} else {
throw new XmlError(XE.CONVERTER_UNSUPPORTED);
}
}
}, {
key: "FromBase64",
value: function FromBase64(base64Text) {
base64Text = base64Text.replace(/\n/g, "").replace(/\r/g, "").replace(/\t/g, "").replace(/\s/g, "");
if (typeof atob !== "undefined") {
return this.FromBinary(atob(base64Text));
} else if (typeof Buffer !== "undefined") {
return new Uint8Array(Buffer.from(base64Text, "base64"));
} else {
throw new XmlError(XE.CONVERTER_UNSUPPORTED);
}
}
}, {
key: "FromBase64Url",
value: function FromBase64Url(base64url) {
return this.FromBase64(this.Base64Padding(base64url.replace(/\-/g, "+").replace(/\_/g, "/")));
}
}, {
key: "ToBase64Url",
value: function ToBase64Url(data) {
return this.ToBase64(data).replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, "");
}
}, {
key: "FromUtf8String",
value: function FromUtf8String(text) {
var s = unescape(encodeURIComponent(text));
var uintArray = new Uint8Array(s.length);
for (var i = 0; i < s.length; i++) {
uintArray[i] = s.charCodeAt(i);
}
return uintArray;
}
}, {
key: "ToUtf8String",
value: function ToUtf8String(buffer) {
var encodedString = String.fromCharCode.apply(null, buffer);
var decodedString = decodeURIComponent(escape(encodedString));
return decodedString;
}
}, {
key: "FromBinary",
value: function FromBinary(text) {
var stringLength = text.length;
var resultView = new Uint8Array(stringLength);
for (var i = 0; i < stringLength; i++) {
resultView[i] = text.charCodeAt(i);
}
return resultView;
}
}, {
key: "ToBinary",
value: function ToBinary(buffer) {
var resultString = "";
for (var i = 0; i < buffer.length; i++) {
resultString = resultString + String.fromCharCode(buffer[i]);
}
return resultString;
}
}, {
key: "ToHex",
value: function ToHex(buffer) {
var splitter = "";
var res = [];
for (var i = 0; i < buffer.length; i++) {
var char = buffer[i].toString(16);
res.push(char.length === 1 ? "0" + char : char);
}
return res.join(splitter);
}
}, {
key: "FromHex",
value: function FromHex(hexString) {
var res = new Uint8Array(hexString.length / 2);
for (var i = 0; i < hexString.length; i = i + 2) {
var c = hexString.slice(i, i + 2);
res[i / 2] = parseInt(c, 16);
}
return res;
}
}, {
key: "ToDateTime",
value: function ToDateTime(dateTime) {
return new Date(dateTime);
}
}, {
key: "FromDateTime",
value: function FromDateTime(dateTime) {
var str = dateTime.toISOString();
return str;
}
}, {
key: "Base64Padding",
value: function Base64Padding(base64) {
var padCount = 4 - base64.length % 4;
if (padCount < 4) {
for (var i = 0; i < padCount; i++) {
base64 += "=";
}
}
return base64;
}
}]);
return Convert;
}();
var APPLICATION_XML = "application/xml";
var XmlNodeType;
(function (XmlNodeType) {
XmlNodeType[XmlNodeType["None"] = 0] = "None";
XmlNodeType[XmlNodeType["Element"] = 1] = "Element";
XmlNodeType[XmlNodeType["Attribute"] = 2] = "Attribute";
XmlNodeType[XmlNodeType["Text"] = 3] = "Text";
XmlNodeType[XmlNodeType["CDATA"] = 4] = "CDATA";
XmlNodeType[XmlNodeType["EntityReference"] = 5] = "EntityReference";
XmlNodeType[XmlNodeType["Entity"] = 6] = "Entity";
XmlNodeType[XmlNodeType["ProcessingInstruction"] = 7] = "ProcessingInstruction";
XmlNodeType[XmlNodeType["Comment"] = 8] = "Comment";
XmlNodeType[XmlNodeType["Document"] = 9] = "Document";
XmlNodeType[XmlNodeType["DocumentType"] = 10] = "DocumentType";
XmlNodeType[XmlNodeType["DocumentFragment"] = 11] = "DocumentFragment";
XmlNodeType[XmlNodeType["Notation"] = 12] = "Notation";
XmlNodeType[XmlNodeType["Whitespace"] = 13] = "Whitespace";
XmlNodeType[XmlNodeType["SignificantWhitespace"] = 14] = "SignificantWhitespace";
XmlNodeType[XmlNodeType["EndElement"] = 15] = "EndElement";
XmlNodeType[XmlNodeType["EndEntity"] = 16] = "EndEntity";
XmlNodeType[XmlNodeType["XmlDeclaration"] = 17] = "XmlDeclaration";
})(XmlNodeType || (XmlNodeType = {}));
var xpath = function xpath(node, xPath) {
throw new Error("Not implemented");
};
var sWindow;
if (typeof self === "undefined") {
sWindow = global;
var xmldom = require("xmldom");
xpath = require("xpath.js");
sWindow.XMLSerializer = xmldom.XMLSerializer;
sWindow.DOMParser = xmldom.DOMParser;
sWindow.DOMImplementation = xmldom.DOMImplementation;
sWindow.document = new DOMImplementation().createDocument("http://www.w3.org/1999/xhtml", "html", null);
} else {
sWindow = self;
}
function SelectNodesEx(node, xPath) {
var doc = node.ownerDocument == null ? node : node.ownerDocument;
var nsResolver = document.createNSResolver(node.ownerDocument == null ? node.documentElement : node.ownerDocument.documentElement);
var personIterator = doc.evaluate(xPath, node, nsResolver, XPathResult.ANY_TYPE, null);
var ns = [];
var n;
while (n = personIterator.iterateNext()) {
ns.push(n);
}
return ns;
}
var Select = typeof self !== "undefined" ? SelectNodesEx : xpath;
function Parse(xmlString) {
xmlString = xmlString.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
return new DOMParser().parseFromString(xmlString, APPLICATION_XML);
}
function Stringify(target) {
return new XMLSerializer().serializeToString(target);
}
function SelectSingleNode(node, path) {
var ns = Select(node, path);
if (ns && ns.length > 0) {
return ns[0];
}
return null;
}
function _SelectNamespaces(node) {
var selectedNodes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
if (node && node.nodeType === XmlNodeType.Element) {
var el = node;
if (el.namespaceURI && el.namespaceURI !== "http://www.w3.org/XML/1998/namespace" && !selectedNodes[el.prefix || ""]) {
selectedNodes[el.prefix ? el.prefix : ""] = node.namespaceURI;
}
for (var i = 0; i < node.childNodes.length; i++) {
var childNode = node.childNodes.item(i);
if (childNode && childNode.nodeType === XmlNodeType.Element) {
_SelectNamespaces(childNode, selectedNodes);
}
}
}
}
function SelectNamespaces(node) {
var attrs = {};
_SelectNamespaces(node, attrs);
return attrs;
}
function assign$1(target) {
for (var _len4 = arguments.length, sources = new Array(_len4 > 1 ? _len4 - 1 : 0), _key4 = 1; _key4 < _len4; _key4++) {
sources[_key4 - 1] = arguments[_key4];
}
var res = arguments[0];
for (var i = 1; i < arguments.length; i++) {
var obj = arguments[i];
for (var prop in obj) {
if (!obj.hasOwnProperty(prop)) {
continue;
}
res[prop] = obj[prop];
}
}
return res;
}
function isNodeType(obj, type) {
return obj && obj.nodeType === type;
}
function isElement(obj) {
return isNodeType(obj, XmlNodeType.Element);
}
function isDocument(obj) {
return isNodeType(obj, XmlNodeType.Document);
}
var XmlBase64Converter = {
get: function get(value) {
if (value) {
return Convert.ToBase64(value);
}
return void 0;
},
set: function set(value) {
return Convert.FromBase64(value);
}
};
var XmlNumberConverter = {
get: function get(value) {
if (value) {
return value.toString();
}
return "0";
},
set: function set(value) {
return Number(value);
}
};
var DEFAULT_ROOT_NAME = "xml_root";
var XmlObject = function () {
function XmlObject() {
var properties = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
_classCallCheck(this, XmlObject);
this.prefix = this.GetStatic().prefix || null;
this.localName = this.GetStatic().localName;
this.namespaceURI = this.GetStatic().namespaceURI;
if (properties) {
for (var _i = 0, _Object$entries = Object.entries(properties); _i < _Object$entries.length; _i++) {
var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
key = _Object$entries$_i[0],
value = _Object$entries$_i[1];
if (value !== undefined) {
this[key] = value;
}
}
}
}
_createClass(XmlObject, [{
key: "HasChanged",
value: function HasChanged() {
var self = this.GetStatic();
if (self.items) {
for (var key in self.items) {
if (!self.items.hasOwnProperty(key)) {
continue;
}
var item = self.items[key];
var value = this[key];
if (item.parser && value && value.HasChanged()) {
return true;
}
}
}
return this.element === null;
}
}, {
key: "GetXml",
value: function GetXml(hard) {
if (!(hard || this.HasChanged())) {
return this.element || null;
}
var thisAny = this;
var doc = this.CreateDocument();
var el = this.CreateElement();
var self = this.GetStatic();
var localName = this.localName;
if (self.items) {
for (var key in self.items) {
if (!self.items.hasOwnProperty(key)) {
continue;
}
var parser = thisAny[key];
var selfItem = self.items[key];
switch (selfItem.type) {
case CONTENT:
{
var schema = selfItem;
var value = schema.converter ? schema.converter.get(parser) : parser;
if (schema.required && (value === null || value === void 0)) {
throw new XmlError(XE.CONTENT_MISSING, localName);
}
if (schema.defaultValue !== parser || schema.required) {
el.textContent = value;
}
break;
}
case ATTRIBUTE:
{
var _schema = selfItem;
var _value2 = _schema.converter ? _schema.converter.get(parser) : parser;
if (_schema.required && (_value2 === null || _value2 === void 0)) {
throw new XmlError(XE.ATTRIBUTE_MISSING, _schema.localName, localName);
}
if (_schema.defaultValue !== parser || _schema.required) {
if (!_schema.namespaceURI) {
el.setAttribute(_schema.localName, _value2);
} else {
el.setAttributeNS(_schema.namespaceURI, _schema.localName, _value2);
}
}
break;
}
case ELEMENT:
{
var _schema2 = selfItem;
var node = null;
if (_schema2.parser) {
if (_schema2.required && !parser || _schema2.minOccurs && !parser.Count) {
throw new XmlError(XE.ELEMENT_MISSING, parser.localName, localName);
}
if (parser) {
node = parser.GetXml(parser.element === void 0 && (_schema2.required || parser.Count));
}
} else {
var _value3 = _schema2.converter ? _schema2.converter.get(parser) : parser;
if (_schema2.required && _value3 === void 0) {
throw new XmlError(XE.ELEMENT_MISSING, _schema2.localName, localName);
}
if (parser !== _schema2.defaultValue || _schema2.required) {
if (!_schema2.namespaceURI) {
node = doc.createElement("".concat(_schema2.prefix ? _schema2.prefix + ":" : "").concat(_schema2.localName));
} else {
node = doc.createElementNS(_schema2.namespaceURI, "".concat(_schema2.prefix ? _schema2.prefix + ":" : "").concat(_schema2.localName));
}
if (Array.isArray(_value3)) {
var _iterator = _createForOfIteratorHelper(_value3),
_step;
try {
for (_iterator.s(); !(_step = _iterator.n()).done;) {
var child = _step.value;
var val = child instanceof XmlObject ? child.GetXml(true) : child;
if (val !== null) {
node.appendChild(val);
}
}
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
} else if (_value3 instanceof XmlObject) {
node.appendChild(_value3.GetXml(true));
} else {
node.textContent = _value3;
}
}
}
if (node) {
if (_schema2.noRoot) {
var els = [];
for (var i = 0; i < node.childNodes.length; i++) {
var colNode = node.childNodes.item(i);
if (isElement(colNode)) {
els.push(colNode);
}
}
if (els.length < _schema2.minOccurs || els.length > _schema2.maxOccurs) {
throw new XmlError(XE.COLLECTION_LIMIT, parser.localName, self.localName);
}
els.forEach(function (e) {
return el.appendChild(e.cloneNode(true));
});
} else if (node.childNodes.length < _schema2.minOccurs || node.childNodes.length > _schema2.maxOccurs) {
throw new XmlError(XE.COLLECTION_LIMIT, parser.localName, self.localName);
} else {
el.appendChild(node);
}
}
break;
}
}
}
}
this.OnGetXml(el);
this.element = el;
return el;
}
}, {
key: "LoadXml",
value: function LoadXml(param) {
var element;
var thisAny = this;
if (typeof param === "string") {
var doc = Parse(param);
element = doc.documentElement;
} else {
element = param;
}
if (!element) {
throw new XmlError(XE.PARAM_REQUIRED, "element");
}
var self = this.GetStatic();
var localName = this.localName;
if (!(element.localName === localName && element.namespaceURI == this.NamespaceURI)) {
throw new XmlError(XE.ELEMENT_MALFORMED, localName);
}
if (self.items) {
for (var key in self.items) {
if (!self.items.hasOwnProperty(key)) {
continue;
}
var selfItem = self.items[key];
switch (selfItem.type) {
case CONTENT:
{
var schema = selfItem;
if (schema.required && !element.textContent) {
throw new XmlError(XE.CONTENT_MISSING, localName);
}
if (!element.textContent) {
thisAny[key] = schema.defaultValue;
} else {
var value = schema.converter ? schema.converter.set(element.textContent) : element.textContent;
thisAny[key] = value;
}
break;
}
case ATTRIBUTE:
{
var _schema3 = selfItem;
var hasAttribute = void 0;
var getAttribute = void 0;
if (!_schema3.localName) {
throw new XmlError(XE.PARAM_REQUIRED, "localName");
}
if (_schema3.namespaceURI) {
hasAttribute = element.hasAttributeNS.bind(element, _schema3.namespaceURI, _schema3.localName);
getAttribute = element.getAttributeNS.bind(element, _schema3.namespaceURI, _schema3.localName);
} else {
hasAttribute = element.hasAttribute.bind(element, _schema3.localName);
getAttribute = element.getAttribute.bind(element, _schema3.localName);
}
if (_schema3.required && !hasAttribute()) {
throw new XmlError(XE.ATTRIBUTE_MISSING, _schema3.localName, localName);
}
if (!hasAttribute()) {
thisAny[key] = _schema3.defaultValue;
} else {
var _value4 = _schema3.converter ? _schema3.converter.set(getAttribute()) : getAttribute();
thisAny[key] = _value4;
}
break;
}
case ELEMENT:
{
var _schema4 = selfItem;
if (_schema4.noRoot) {
if (!_schema4.parser) {
throw new XmlError(XE.XML_EXCEPTION, "Schema for '".concat(_schema4.localName, "' with flag noRoot must have 'parser'"));
}
var col = new _schema4.parser();
if (!(col instanceof XmlCollection)) {
throw new XmlError(XE.XML_EXCEPTION, "Schema for '".concat(_schema4.localName, "' with flag noRoot must have 'parser' like instance of XmlCollection"));
}
col.OnLoadXml(element);
delete col.element;
if (col.Count < _schema4.minOccurs || col.Count > _schema4.maxOccurs) {
throw new XmlError(XE.COLLECTION_LIMIT, _schema4.parser.localName, localName);
}
thisAny[key] = col;
continue;
}
var foundElement = null;
for (var i = 0; i < element.childNodes.length; i++) {
var node = element.childNodes.item(i);
if (!isElement(node)) {
continue;
}
var el = node;
if (el.localName === _schema4.localName && el.namespaceURI == _schema4.namespaceURI) {
foundElement = el;
break;
}
}
if (_schema4.required && !foundElement) {
throw new XmlError(XE.ELEMENT_MISSING, _schema4.parser ? _schema4.parser.localName : _schema4.localName, localName);
}
if (!_schema4.parser) {
if (!foundElement) {
thisAny[key] = _schema4.defaultValue;
} else {
var _value5 = _schema4.converter ? _schema4.converter.set(foundElement.textContent) : foundElement.textContent;
thisAny[key] = _value5;
}
} else {
if (foundElement) {
var _value6 = new _schema4.parser();
_value6.localName = _schema4.localName;
_value6.namespaceURI = _schema4.namespaceURI;
thisAny[key] = _value6;
_value6.LoadXml(foundElement);
}
}
break;
}
}
}
}
this.OnLoadXml(element);
this.prefix = element.prefix || "";
this.element = element;
}
}, {
key: "toString",
value: function toString() {
var xml = this.GetXml();
return xml ? new XMLSerializer().serializeToString(xml) : "";
}
}, {
key: "GetElement",
value: function GetElement(name) {
var required = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
if (!this.element) {
throw new XmlError(XE.NULL_PARAM, this.localName);
}
return XmlObject.GetElement(this.element, name, required);
}
}, {
key: "GetChildren",
value: function GetChildren(localName, nameSpace) {
if (!this.element) {
throw new XmlError(XE.NULL_PARAM, this.localName);
}
return XmlObject.GetChildren(this.element, localName, nameSpace || this.NamespaceURI || undefined);
}
}, {
key: "GetChild",
value: function GetChild(localName) {
var required = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
if (!this.element) {
throw new XmlError(XE.NULL_PARAM, this.localName);
}
return XmlObject.GetChild(this.element, localName, this.NamespaceURI || undefined, required);
}
}, {
key: "GetFirstChild",
value: function GetFirstChild(localName, namespace) {
if (!this.element) {
throw new XmlError(XE.NULL_PARAM, this.localName);
}
return XmlObject.GetFirstChild(this.element, localName, namespace);
}
}, {
key: "GetAttribute",
value: function GetAttribute(name, defaultValue) {
var required = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
if (!this.element) {
throw new XmlError(XE.NULL_PARAM, this.localName);
}
return XmlObject.GetAttribute(this.element, name, defaultValue, required);
}
}, {
key: "IsEmpty",
value: function IsEmpty() {
return this.Element === void 0;
}
}, {
key: "OnLoadXml",
value: function OnLoadXml(element) {}
}, {
key: "GetStatic",
value: function GetStatic() {
return this.constructor;
}
}, {
key: "GetPrefix",
value: function GetPrefix() {
return this.Prefix ? this.prefix + ":" : "";
}
}, {
key: "OnGetXml",
value: function OnGetXml(element) {}
}, {
key: "CreateElement",
value: function CreateElement(document, localName) {
var namespaceUri = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
var prefix = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
if (!document) {
document = this.CreateDocument();
}
localName = localName || this.localName;
namespaceUri = namespaceUri || this.NamespaceURI;
prefix = prefix || this.prefix;
var tagName = (prefix ? "".concat(prefix, ":") : "") + localName;
var xn = namespaceUri ? document.createElementNS(namespaceUri, tagName) : document.createElement(tagName);
document.importNode(xn, true);
return xn;
}
}, {
key: "CreateDocument",
value: function CreateDocument() {
return XmlObject.CreateDocument(this.localName, this.NamespaceURI, this.Prefix);
}
}, {
key: "Element",
get: function get() {
return this.element;
}
}, {
key: "Prefix",
get: function get() {
return this.prefix;
},
set: function set(value) {
this.prefix = value;
}
}, {
key: "LocalName",
get: function get() {
return this.localName;
}
}, {
key: "NamespaceURI",
get: function get() {
return this.namespaceURI || null;
}
}], [{
key: "LoadXml",
value: function LoadXml(param) {
var xml = new this();
xml.LoadXml(param);
return xml;
}
}, {
key: "GetElement",
value: function GetElement(element, name) {
var required = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
var xmlNodeList = element.getElementsByTagName(name);
if (required && xmlNodeList.length === 0) {
throw new XmlError(XE.ELEMENT_MISSING, name, element.localName);
}
return xmlNodeList[0] || null;
}
}, {
key: "GetAttribute",
value: function GetAttribute(element, attrName, defaultValue) {
var required = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
if (element.hasAttribute(attrName)) {
return element.getAttribute(attrName);
} else {
if (required) {
throw new XmlError(XE.ATTRIBUTE_MISSING, attrName, element.localName);
}
return defaultValue;
}
}
}, {
key: "GetElementById",
value: function GetElementById(node, idValue) {
if (node == null || idValue == null) {
return null;
}
var xel = null;
if (isDocument(node)) {
xel = node.getElementById(idValue);
}
if (xel == null) {
xel = SelectSingleNode(node, "//*[@Id='".concat(idValue, "']"));
if (xel == null) {
xel = SelectSingleNode(node, "//*[@ID='".concat(idValue, "']"));
if (xel == null) {
xel = SelectSingleNode(node, "//*[@id='".concat(idValue, "']"));
}
}
}
return xel;
}
}, {
key: "CreateDocument",
value: function CreateDocument() {
var root = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : DEFAULT_ROOT_NAME;
var namespaceUri = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
var prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
var namePrefix = "";
var nsPrefix = "";
var namespaceUri2 = "";
if (prefix) {
namePrefix = prefix + ":";
nsPrefix = ":" + prefix;
}
if (namespaceUri) {
namespaceUri2 = " xmlns".concat(nsPrefix, "=\"").concat(namespaceUri, "\"");
}
var name = "".concat(namePrefix).concat(root);
var doc = new DOMParser().parseFromString("<".concat(name).concat(namespaceUri2, "></").concat(name, ">"), APPLICATION_XML);
return doc;
}
}, {
key: "GetChildren",
value: function GetChildren(node, localName, nameSpace) {
node = isDocument(node) ? node.documentElement : node;
var res = [];
for (var i = 0; i < node.childNodes.length; i++) {
var child = node.childNodes[i];
if (isElement(child) && child.localName === localName && (child.namespaceURI === nameSpace || !nameSpace)) {
res.push(child);
}
}
return res;
}
}, {
key: "GetFirstChild",
value: function GetFirstChild(node, localName, nameSpace) {
node = isDocument(node) ? node.documentElement : node;
for (var i = 0; i < node.childNodes.length; i++) {
var child = node.childNodes[i];
if (isElement(child) && child.localName === localName && (child.namespaceURI === nameSpace || !nameSpace)) {
return child;
}
}
return null;
}
}, {
key: "GetChild",
value: function GetChild(node, localName, nameSpace) {
var required = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
for (var i = 0; i < node.childNodes.length; i++) {
var child = node.childNodes[i];
if (isElement(child) && child.localName === localName && (child.namespaceURI === nameSpace || !nameSpace)) {
return child;
}
}
if (required) {
throw new XmlError(XE.ELEMENT_MISSING, localName, node.localName);
}
return null;
}
}]);
return XmlObject;
}();
var XmlCollection = function (_XmlObject) {
_inherits(XmlCollection, _XmlObject);
var _super = _createSuper(XmlCollection);
function XmlCollection() {
var _this2;
_classCallCheck(this, XmlCollection);
_this2 = _super.apply(this, arguments);
_this2.MaxOccurs = Number.MAX_VALUE;
_this2.MinOccurs = 0;
_this2.items = [];
return _this2;
}
_createClass(XmlCollection, [{
key: "HasChanged",
value: function HasChanged() {
var res = _get(_getPrototypeOf(XmlCollection.prototype), "HasChanged", this).call(this);
var changed = this.Some(function (item) {
return item.HasChanged();
});
return res || changed;
}
}, {
key: "Item",
value: function Item(index) {
return this.items[index] || null;
}
}, {
key: "Add",
value: function Add(item) {
this.items.push(item);
this.element = null;
}
}, {
key: "Pop",
value: function Pop() {
this.element = null;
return this.items.pop();
}
}, {
key: "RemoveAt",
value: function RemoveAt(index) {
this.items = this.items.filter(function (item, index2) {
return index2 !== index;
});
this.element = null;
}
}