webcrypto-liner
Version:
A WebCrypto polyfill that "smooths out" the rough-edges in existing User Agent implementations.
952 lines (951 loc) • 548 kB
JavaScript
var _excluded = ["name", "optional", "primitiveSchema"],
_excluded2 = ["value"],
_excluded3 = ["isHexOnly"],
_excluded4 = ["value", "isIndefiniteForm"],
_excluded5 = ["value"],
_excluded6 = ["isConstructed"],
_excluded7 = ["idBlock", "lenBlock"],
_excluded8 = ["unusedBits", "isConstructed"],
_excluded9 = ["idBlock", "lenBlock"],
_excluded10 = ["value"],
_excluded11 = ["valueDec", "isFirstSid"],
_excluded12 = ["value"],
_excluded13 = ["valueDec"],
_excluded14 = ["value"],
_excluded15 = ["value", "valueDate"],
_excluded16 = ["value"],
_excluded17 = ["value", "local"];
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
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 _iterableToArray(iter) { if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); }
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
function _regeneratorRuntime() { "use strict"; _regeneratorRuntime = function _regeneratorRuntime() { return e; }; var t, e = {}, r = Object.prototype, n = r.hasOwnProperty, o = Object.defineProperty || function (t, e, r) { t[e] = r.value; }, i = "function" == typeof Symbol ? Symbol : {}, a = i.iterator || "@@iterator", c = i.asyncIterator || "@@asyncIterator", u = i.toStringTag || "@@toStringTag"; function define(t, e, r) { return Object.defineProperty(t, e, { value: r, enumerable: !0, configurable: !0, writable: !0 }), t[e]; } try { define({}, ""); } catch (t) { define = function define(t, e, r) { return t[e] = r; }; } function wrap(t, e, r, n) { var i = e && e.prototype instanceof Generator ? e : Generator, a = Object.create(i.prototype), c = new Context(n || []); return o(a, "_invoke", { value: makeInvokeMethod(t, r, c) }), a; } function tryCatch(t, e, r) { try { return { type: "normal", arg: t.call(e, r) }; } catch (t) { return { type: "throw", arg: t }; } } e.wrap = wrap; var h = "suspendedStart", l = "suspendedYield", f = "executing", s = "completed", y = {}; function Generator() {} function GeneratorFunction() {} function GeneratorFunctionPrototype() {} var p = {}; define(p, a, function () { return this; }); var d = Object.getPrototypeOf, v = d && d(d(values([]))); v && v !== r && n.call(v, a) && (p = v); var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p); function defineIteratorMethods(t) { ["next", "throw", "return"].forEach(function (e) { define(t, e, function (t) { return this._invoke(e, t); }); }); } function AsyncIterator(t, e) { function invoke(r, o, i, a) { var c = tryCatch(t[r], t, o); if ("throw" !== c.type) { var u = c.arg, h = u.value; return h && "object" == _typeof(h) && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) { invoke("next", t, i, a); }, function (t) { invoke("throw", t, i, a); }) : e.resolve(h).then(function (t) { u.value = t, i(u); }, function (t) { return invoke("throw", t, i, a); }); } a(c.arg); } var r; o(this, "_invoke", { value: function value(t, n) { function callInvokeWithMethodAndArg() { return new e(function (e, r) { invoke(t, n, e, r); }); } return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); } }); } function makeInvokeMethod(e, r, n) { var o = h; return function (i, a) { if (o === f) throw new Error("Generator is already running"); if (o === s) { if ("throw" === i) throw a; return { value: t, done: !0 }; } for (n.method = i, n.arg = a;;) { var c = n.delegate; if (c) { var u = maybeInvokeDelegate(c, n); if (u) { if (u === y) continue; return u; } } if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) { if (o === h) throw o = s, n.arg; n.dispatchException(n.arg); } else "return" === n.method && n.abrupt("return", n.arg); o = f; var p = tryCatch(e, r, n); if ("normal" === p.type) { if (o = n.done ? s : l, p.arg === y) continue; return { value: p.arg, done: n.done }; } "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg); } }; } function maybeInvokeDelegate(e, r) { var n = r.method, o = e.iterator[n]; if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y; var i = tryCatch(o, e.iterator, r.arg); if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y; var a = i.arg; return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y); } function pushTryEntry(t) { var e = { tryLoc: t[0] }; 1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e); } function resetTryEntry(t) { var e = t.completion || {}; e.type = "normal", delete e.arg, t.completion = e; } function Context(t) { this.tryEntries = [{ tryLoc: "root" }], t.forEach(pushTryEntry, this), this.reset(!0); } function values(e) { if (e || "" === e) { var r = e[a]; if (r) return r.call(e); if ("function" == typeof e.next) return e; if (!isNaN(e.length)) { var o = -1, i = function next() { for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next; return next.value = t, next.done = !0, next; }; return i.next = i; } } throw new TypeError(_typeof(e) + " is not iterable"); } return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", { value: GeneratorFunctionPrototype, configurable: !0 }), o(GeneratorFunctionPrototype, "constructor", { value: GeneratorFunction, configurable: !0 }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) { var e = "function" == typeof t && t.constructor; return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name)); }, e.mark = function (t) { return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t; }, e.awrap = function (t) { return { __await: t }; }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () { return this; }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) { void 0 === i && (i = Promise); var a = new AsyncIterator(wrap(t, r, n, o), i); return e.isGeneratorFunction(r) ? a : a.next().then(function (t) { return t.done ? t.value : a.next(); }); }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () { return this; }), define(g, "toString", function () { return "[object Generator]"; }), e.keys = function (t) { var e = Object(t), r = []; for (var n in e) r.push(n); return r.reverse(), function next() { for (; r.length;) { var t = r.pop(); if (t in e) return next.value = t, next.done = !1, next; } return next.done = !0, next; }; }, e.values = values, Context.prototype = { constructor: Context, reset: function reset(e) { if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t); }, stop: function stop() { this.done = !0; var t = this.tryEntries[0].completion; if ("throw" === t.type) throw t.arg; return this.rval; }, dispatchException: function dispatchException(e) { if (this.done) throw e; var r = this; function handle(n, o) { return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o; } for (var o = this.tryEntries.length - 1; o >= 0; --o) { var i = this.tryEntries[o], a = i.completion; if ("root" === i.tryLoc) return handle("end"); if (i.tryLoc <= this.prev) { var c = n.call(i, "catchLoc"), u = n.call(i, "finallyLoc"); if (c && u) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } else if (c) { if (this.prev < i.catchLoc) return handle(i.catchLoc, !0); } else { if (!u) throw new Error("try statement without catch or finally"); if (this.prev < i.finallyLoc) return handle(i.finallyLoc); } } } }, abrupt: function abrupt(t, e) { for (var r = this.tryEntries.length - 1; r >= 0; --r) { var o = this.tryEntries[r]; if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) { var i = o; break; } } i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null); var a = i ? i.completion : {}; return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a); }, complete: function complete(t, e) { if ("throw" === t.type) throw t.arg; return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y; }, finish: function finish(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y; } }, catch: function _catch(t) { for (var e = this.tryEntries.length - 1; e >= 0; --e) { var r = this.tryEntries[e]; if (r.tryLoc === t) { var n = r.completion; if ("throw" === n.type) { var o = n.arg; resetTryEntry(r); } return o; } } throw new Error("illegal catch attempt"); }, delegateYield: function delegateYield(e, r, n) { return this.delegate = { iterator: values(e), resultName: r, nextLoc: n }, "next" === this.method && (this.arg = t), y; } }, e; }
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 _wrapNativeSuper(Class) { var _cache = typeof Map === "function" ? new Map() : undefined; _wrapNativeSuper = function _wrapNativeSuper(Class) { if (Class === null || !_isNativeFunction(Class)) return Class; if (typeof Class !== "function") { throw new TypeError("Super expression must either be null or a function"); } if (typeof _cache !== "undefined") { if (_cache.has(Class)) return _cache.get(Class); _cache.set(Class, Wrapper); } function Wrapper() { return _construct(Class, arguments, _getPrototypeOf(this).constructor); } Wrapper.prototype = Object.create(Class.prototype, { constructor: { value: Wrapper, enumerable: false, writable: true, configurable: true } }); return _setPrototypeOf(Wrapper, Class); }; return _wrapNativeSuper(Class); }
function _construct(t, e, r) { if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments); var o = [null]; o.push.apply(o, e); var p = new (t.bind.apply(t, o))(); return r && _setPrototypeOf(p, r.prototype), p; }
function _isNativeFunction(fn) { try { return Function.toString.call(fn).indexOf("[native code]") !== -1; } catch (e) { return typeof fn === "function"; } }
function _objectDestructuringEmpty(obj) { if (obj == null) throw new TypeError("Cannot destructure " + obj); }
function _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }
function _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
function _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
function _get() { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get.bind(); } 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(arguments.length < 3 ? target : receiver); } return desc.value; }; } return _get.apply(this, arguments); }
function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
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 } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, 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 s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
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 _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, _toPropertyKey(descriptor.key), descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
var liner = function (exports, asmCrypto, elliptic) {
'use strict';
function _interopNamespaceDefault(e) {
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function get() {
return e[k];
}
});
}
});
}
n.default = e;
return Object.freeze(n);
}
function _mergeNamespaces(n, m) {
m.forEach(function (e) {
e && typeof e !== 'string' && !Array.isArray(e) && Object.keys(e).forEach(function (k) {
if (k !== 'default' && !(k in n)) {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function get() {
return e[k];
}
});
}
});
});
return Object.freeze(n);
}
var asmCrypto__namespace = _interopNamespaceDefault(asmCrypto);
var elliptic__namespace = _interopNamespaceDefault(elliptic);
var window$2 = {};
if (typeof self !== "undefined") {
window$2 = self;
}
exports.nativeCrypto = window$2["msCrypto"] || window$2.crypto || {};
exports.nativeSubtle = null;
try {
exports.nativeSubtle = (exports.nativeCrypto === null || exports.nativeCrypto === void 0 ? void 0 : exports.nativeCrypto.subtle) || (exports.nativeCrypto === null || exports.nativeCrypto === void 0 ? void 0 : exports.nativeCrypto["webkitSubtle"]) || null;
} catch (err) {
console.warn("Cannot get subtle from crypto", err);
}
function setCrypto(crypto) {
exports.nativeCrypto = crypto;
exports.nativeSubtle = crypto.subtle;
}
var ARRAY_BUFFER_NAME = "[object ArrayBuffer]";
var BufferSourceConverter = function () {
function BufferSourceConverter() {
_classCallCheck(this, BufferSourceConverter);
}
_createClass(BufferSourceConverter, null, [{
key: "isArrayBuffer",
value: function isArrayBuffer(data) {
return Object.prototype.toString.call(data) === ARRAY_BUFFER_NAME;
}
}, {
key: "toArrayBuffer",
value: function toArrayBuffer(data) {
if (this.isArrayBuffer(data)) {
return data;
}
if (data.byteLength === data.buffer.byteLength) {
return data.buffer;
}
if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
return data.buffer;
}
return this.toUint8Array(data.buffer).slice(data.byteOffset, data.byteOffset + data.byteLength).buffer;
}
}, {
key: "toUint8Array",
value: function toUint8Array(data) {
return this.toView(data, Uint8Array);
}
}, {
key: "toView",
value: function toView(data, type) {
if (data.constructor === type) {
return data;
}
if (this.isArrayBuffer(data)) {
return new type(data);
}
if (this.isArrayBufferView(data)) {
return new type(data.buffer, data.byteOffset, data.byteLength);
}
throw new TypeError("The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
}
}, {
key: "isBufferSource",
value: function isBufferSource(data) {
return this.isArrayBufferView(data) || this.isArrayBuffer(data);
}
}, {
key: "isArrayBufferView",
value: function isArrayBufferView(data) {
return ArrayBuffer.isView(data) || data && this.isArrayBuffer(data.buffer);
}
}, {
key: "isEqual",
value: function isEqual(a, b) {
var aView = BufferSourceConverter.toUint8Array(a);
var bView = BufferSourceConverter.toUint8Array(b);
if (aView.length !== bView.byteLength) {
return false;
}
for (var i = 0; i < aView.length; i++) {
if (aView[i] !== bView[i]) {
return false;
}
}
return true;
}
}, {
key: "concat",
value: function concat() {
var buffers;
for (var _len = arguments.length, args = new Array(_len), _key2 = 0; _key2 < _len; _key2++) {
args[_key2] = arguments[_key2];
}
if (Array.isArray(args[0]) && !(args[1] instanceof Function)) {
buffers = args[0];
} else if (Array.isArray(args[0]) && args[1] instanceof Function) {
buffers = args[0];
} else {
if (args[args.length - 1] instanceof Function) {
buffers = args.slice(0, args.length - 1);
} else {
buffers = args;
}
}
var size = 0;
var _iterator = _createForOfIteratorHelper(buffers),
_step;
try {
for (_iterator.s(); !(_step = _iterator.n()).done;) {
var buffer = _step.value;
size += buffer.byteLength;
}
} catch (err) {
_iterator.e(err);
} finally {
_iterator.f();
}
var res = new Uint8Array(size);
var offset = 0;
var _iterator2 = _createForOfIteratorHelper(buffers),
_step2;
try {
for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
var _buffer2 = _step2.value;
var view = this.toUint8Array(_buffer2);
res.set(view, offset);
offset += view.length;
}
} catch (err) {
_iterator2.e(err);
} finally {
_iterator2.f();
}
if (args[args.length - 1] instanceof Function) {
return this.toView(res, args[args.length - 1]);
}
return res.buffer;
}
}]);
return BufferSourceConverter;
}();
var STRING_TYPE = "string";
var HEX_REGEX = /^[0-9a-f]+$/i;
var BASE64_REGEX = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/;
var BASE64URL_REGEX = /^[a-zA-Z0-9-_]+$/;
var Utf8Converter = function () {
function Utf8Converter() {
_classCallCheck(this, Utf8Converter);
}
_createClass(Utf8Converter, null, [{
key: "fromString",
value: function fromString(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.buffer;
}
}, {
key: "toString",
value: function toString(buffer) {
var buf = BufferSourceConverter.toUint8Array(buffer);
var encodedString = "";
for (var i = 0; i < buf.length; i++) {
encodedString += String.fromCharCode(buf[i]);
}
var decodedString = decodeURIComponent(escape(encodedString));
return decodedString;
}
}]);
return Utf8Converter;
}();
var Utf16Converter = function () {
function Utf16Converter() {
_classCallCheck(this, Utf16Converter);
}
_createClass(Utf16Converter, null, [{
key: "toString",
value: function toString(buffer) {
var littleEndian = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var arrayBuffer = BufferSourceConverter.toArrayBuffer(buffer);
var dataView = new DataView(arrayBuffer);
var res = "";
for (var i = 0; i < arrayBuffer.byteLength; i += 2) {
var code = dataView.getUint16(i, littleEndian);
res += String.fromCharCode(code);
}
return res;
}
}, {
key: "fromString",
value: function fromString(text) {
var littleEndian = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
var res = new ArrayBuffer(text.length * 2);
var dataView = new DataView(res);
for (var i = 0; i < text.length; i++) {
dataView.setUint16(i * 2, text.charCodeAt(i), littleEndian);
}
return res;
}
}]);
return Utf16Converter;
}();
var Convert = function () {
function Convert() {
_classCallCheck(this, Convert);
}
_createClass(Convert, null, [{
key: "isHex",
value: function isHex(data) {
return _typeof(data) === STRING_TYPE && HEX_REGEX.test(data);
}
}, {
key: "isBase64",
value: function isBase64(data) {
return _typeof(data) === STRING_TYPE && BASE64_REGEX.test(data);
}
}, {
key: "isBase64Url",
value: function isBase64Url(data) {
return _typeof(data) === STRING_TYPE && BASE64URL_REGEX.test(data);
}
}, {
key: "ToString",
value: function ToString(buffer) {
var enc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "utf8";
var buf = BufferSourceConverter.toUint8Array(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);
case "utf16le":
return Utf16Converter.toString(buf, true);
case "utf16":
case "utf16be":
return Utf16Converter.toString(buf);
default:
throw new Error("Unknown type of encoding '".concat(enc, "'"));
}
}
}, {
key: "FromString",
value: function FromString(str) {
var enc = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "utf8";
if (!str) {
return new ArrayBuffer(0);
}
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);
case "utf16le":
return Utf16Converter.fromString(str, true);
case "utf16":
case "utf16be":
return Utf16Converter.fromString(str);
default:
throw new Error("Unknown type of encoding '".concat(enc, "'"));
}
}
}, {
key: "ToBase64",
value: function ToBase64(buffer) {
var buf = BufferSourceConverter.toUint8Array(buffer);
if (typeof btoa !== "undefined") {
var _binary = this.ToString(buf, "binary");
return btoa(_binary);
} else {
return Buffer.from(buf).toString("base64");
}
}
}, {
key: "FromBase64",
value: function FromBase64(base64) {
var formatted = this.formatString(base64);
if (!formatted) {
return new ArrayBuffer(0);
}
if (!Convert.isBase64(formatted)) {
throw new TypeError("Argument 'base64Text' is not Base64 encoded");
}
if (typeof atob !== "undefined") {
return this.FromBinary(atob(formatted));
} else {
return new Uint8Array(Buffer.from(formatted, "base64")).buffer;
}
}
}, {
key: "FromBase64Url",
value: function FromBase64Url(base64url) {
var formatted = this.formatString(base64url);
if (!formatted) {
return new ArrayBuffer(0);
}
if (!Convert.isBase64Url(formatted)) {
throw new TypeError("Argument 'base64url' is not Base64Url encoded");
}
return this.FromBase64(this.Base64Padding(formatted.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 encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Convert.DEFAULT_UTF8_ENCODING;
switch (encoding) {
case "ascii":
return this.FromBinary(text);
case "utf8":
return Utf8Converter.fromString(text);
case "utf16":
case "utf16be":
return Utf16Converter.fromString(text);
case "utf16le":
case "usc2":
return Utf16Converter.fromString(text, true);
default:
throw new Error("Unknown type of encoding '".concat(encoding, "'"));
}
}
}, {
key: "ToUtf8String",
value: function ToUtf8String(buffer) {
var encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : Convert.DEFAULT_UTF8_ENCODING;
switch (encoding) {
case "ascii":
return this.ToBinary(buffer);
case "utf8":
return Utf8Converter.toString(buffer);
case "utf16":
case "utf16be":
return Utf16Converter.toString(buffer);
case "utf16le":
case "usc2":
return Utf16Converter.toString(buffer, true);
default:
throw new Error("Unknown type of encoding '".concat(encoding, "'"));
}
}
}, {
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.buffer;
}
}, {
key: "ToBinary",
value: function ToBinary(buffer) {
var buf = BufferSourceConverter.toUint8Array(buffer);
var res = "";
for (var i = 0; i < buf.length; i++) {
res += String.fromCharCode(buf[i]);
}
return res;
}
}, {
key: "ToHex",
value: function ToHex(buffer) {
var buf = BufferSourceConverter.toUint8Array(buffer);
var result = "";
var len = buf.length;
for (var i = 0; i < len; i++) {
var byte = buf[i];
if (byte < 16) {
result += "0";
}
result += byte.toString(16);
}
return result;
}
}, {
key: "FromHex",
value: function FromHex(hexString) {
var formatted = this.formatString(hexString);
if (!formatted) {
return new ArrayBuffer(0);
}
if (!Convert.isHex(formatted)) {
throw new TypeError("Argument 'hexString' is not HEX encoded");
}
if (formatted.length % 2) {
formatted = "0".concat(formatted);
}
var res = new Uint8Array(formatted.length / 2);
for (var i = 0; i < formatted.length; i = i + 2) {
var c = formatted.slice(i, i + 2);
res[i / 2] = parseInt(c, 16);
}
return res.buffer;
}
}, {
key: "ToUtf16String",
value: function ToUtf16String(buffer) {
var littleEndian = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
return Utf16Converter.toString(buffer, littleEndian);
}
}, {
key: "FromUtf16String",
value: function FromUtf16String(text) {
var littleEndian = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
return Utf16Converter.fromString(text, littleEndian);
}
}, {
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;
}
}, {
key: "formatString",
value: function formatString(data) {
return (data === null || data === void 0 ? void 0 : data.replace(/[\n\r\t ]/g, "")) || "";
}
}]);
return Convert;
}();
Convert.DEFAULT_UTF8_ENCODING = "utf8";
function combine() {
for (var _len2 = arguments.length, buf = new Array(_len2), _key3 = 0; _key3 < _len2; _key3++) {
buf[_key3] = arguments[_key3];
}
var totalByteLength = buf.map(function (item) {
return item.byteLength;
}).reduce(function (prev, cur) {
return prev + cur;
});
var res = new Uint8Array(totalByteLength);
var currentPos = 0;
buf.map(function (item) {
return new Uint8Array(item);
}).forEach(function (arr) {
var _iterator3 = _createForOfIteratorHelper(arr),
_step3;
try {
for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
var item2 = _step3.value;
res[currentPos++] = item2;
}
} catch (err) {
_iterator3.e(err);
} finally {
_iterator3.f();
}
});
return res.buffer;
}
function utilFromBase(inputBuffer, inputBase) {
var result = 0;
if (inputBuffer.length === 1) {
return inputBuffer[0];
}
for (var i = inputBuffer.length - 1; i >= 0; i--) {
result += inputBuffer[inputBuffer.length - 1 - i] * Math.pow(2, inputBase * i);
}
return result;
}
function utilToBase(value, base) {
var reserved = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : -1;
var internalReserved = reserved;
var internalValue = value;
var result = 0;
var biggest = Math.pow(2, base);
for (var i = 1; i < 8; i++) {
if (value < biggest) {
var retBuf = void 0;
if (internalReserved < 0) {
retBuf = new ArrayBuffer(i);
result = i;
} else {
if (internalReserved < i) {
return new ArrayBuffer(0);
}
retBuf = new ArrayBuffer(internalReserved);
result = internalReserved;
}
var retView = new Uint8Array(retBuf);
for (var j = i - 1; j >= 0; j--) {
var basis = Math.pow(2, j * base);
retView[result - j - 1] = Math.floor(internalValue / basis);
internalValue -= retView[result - j - 1] * basis;
}
return retBuf;
}
biggest *= Math.pow(2, base);
}
return new ArrayBuffer(0);
}
function utilConcatView() {
var outputLength = 0;
var prevLength = 0;
for (var _len3 = arguments.length, views = new Array(_len3), _key4 = 0; _key4 < _len3; _key4++) {
views[_key4] = arguments[_key4];
}
for (var _i = 0, _views = views; _i < _views.length; _i++) {
var view = _views[_i];
outputLength += view.length;
}
var retBuf = new ArrayBuffer(outputLength);
var retView = new Uint8Array(retBuf);
for (var _i2 = 0, _views2 = views; _i2 < _views2.length; _i2++) {
var _view = _views2[_i2];
retView.set(_view, prevLength);
prevLength += _view.length;
}
return retView;
}
function utilDecodeTC() {
var buf = new Uint8Array(this.valueHex);
if (this.valueHex.byteLength >= 2) {
var condition1 = buf[0] === 0xFF && buf[1] & 0x80;
var condition2 = buf[0] === 0x00 && (buf[1] & 0x80) === 0x00;
if (condition1 || condition2) {
this.warnings.push("Needlessly long format");
}
}
var bigIntBuffer = new ArrayBuffer(this.valueHex.byteLength);
var bigIntView = new Uint8Array(bigIntBuffer);
for (var i = 0; i < this.valueHex.byteLength; i++) {
bigIntView[i] = 0;
}
bigIntView[0] = buf[0] & 0x80;
var bigInt = utilFromBase(bigIntView, 8);
var smallIntBuffer = new ArrayBuffer(this.valueHex.byteLength);
var smallIntView = new Uint8Array(smallIntBuffer);
for (var j = 0; j < this.valueHex.byteLength; j++) {
smallIntView[j] = buf[j];
}
smallIntView[0] &= 0x7F;
var smallInt = utilFromBase(smallIntView, 8);
return smallInt - bigInt;
}
function utilEncodeTC(value) {
var modValue = value < 0 ? value * -1 : value;
var bigInt = 128;
for (var i = 1; i < 8; i++) {
if (modValue <= bigInt) {
if (value < 0) {
var smallInt = bigInt - modValue;
var _retBuf = utilToBase(smallInt, 8, i);
var _retView = new Uint8Array(_retBuf);
_retView[0] |= 0x80;
return _retBuf;
}
var retBuf = utilToBase(modValue, 8, i);
var retView = new Uint8Array(retBuf);
if (retView[0] & 0x80) {
var tempBuf = retBuf.slice(0);
var tempView = new Uint8Array(tempBuf);
retBuf = new ArrayBuffer(retBuf.byteLength + 1);
retView = new Uint8Array(retBuf);
for (var k = 0; k < tempBuf.byteLength; k++) {
retView[k + 1] = tempView[k];
}
retView[0] = 0x00;
}
return retBuf;
}
bigInt *= Math.pow(2, 8);
}
return new ArrayBuffer(0);
}
function isEqualBuffer(inputBuffer1, inputBuffer2) {
if (inputBuffer1.byteLength !== inputBuffer2.byteLength) {
return false;
}
var view1 = new Uint8Array(inputBuffer1);
var view2 = new Uint8Array(inputBuffer2);
for (var i = 0; i < view1.length; i++) {
if (view1[i] !== view2[i]) {
return false;
}
}
return true;
}
function padNumber(inputNumber, fullLength) {
var str = inputNumber.toString(10);
if (fullLength < str.length) {
return "";
}
var dif = fullLength - str.length;
var padding = new Array(dif);
for (var i = 0; i < dif; i++) {
padding[i] = "0";
}
var paddingString = padding.join("");
return paddingString.concat(str);
}
function assertBigInt() {
if (typeof BigInt === "undefined") {
throw new Error("BigInt is not defined. Your environment doesn't implement BigInt.");
}
}
function concat$1(buffers) {
var outputLength = 0;
var prevLength = 0;
for (var i = 0; i < buffers.length; i++) {
var buffer = buffers[i];
outputLength += buffer.byteLength;
}
var retView = new Uint8Array(outputLength);
for (var _i3 = 0; _i3 < buffers.length; _i3++) {
var _buffer3 = buffers[_i3];
retView.set(new Uint8Array(_buffer3), prevLength);
prevLength += _buffer3.byteLength;
}
return retView.buffer;
}
function checkBufferParams(baseBlock, inputBuffer, inputOffset, inputLength) {
if (!(inputBuffer instanceof Uint8Array)) {
baseBlock.error = "Wrong parameter: inputBuffer must be 'Uint8Array'";
return false;
}
if (!inputBuffer.byteLength) {
baseBlock.error = "Wrong parameter: inputBuffer has zero length";
return false;
}
if (inputOffset < 0) {
baseBlock.error = "Wrong parameter: inputOffset less than zero";
return false;
}
if (inputLength < 0) {
baseBlock.error = "Wrong parameter: inputLength less than zero";
return false;
}
if (inputBuffer.byteLength - inputOffset - inputLength < 0) {
baseBlock.error = "End of input reached before message was fully decoded (inconsistent offset and length values)";
return false;
}
return true;
}
var ViewWriter = function () {
function ViewWriter() {
_classCallCheck(this, ViewWriter);
this.items = [];
}
_createClass(ViewWriter, [{
key: "write",
value: function write(buf) {
this.items.push(buf);
}
}, {
key: "final",
value: function final() {
return concat$1(this.items);
}
}]);
return ViewWriter;
}();
var powers2 = [new Uint8Array([1])];
var digitsString = "0123456789";
var NAME = "name";
var VALUE_HEX_VIEW = "valueHexView";
var IS_HEX_ONLY = "isHexOnly";
var ID_BLOCK = "idBlock";
var TAG_CLASS = "tagClass";
var TAG_NUMBER = "tagNumber";
var IS_CONSTRUCTED = "isConstructed";
var FROM_BER = "fromBER";
var TO_BER = "toBER";
var LOCAL = "local";
var EMPTY_STRING = "";
var EMPTY_BUFFER = new ArrayBuffer(0);
var EMPTY_VIEW = new Uint8Array(0);
var END_OF_CONTENT_NAME = "EndOfContent";
var OCTET_STRING_NAME = "OCTET STRING";
var BIT_STRING_NAME = "BIT STRING";
function HexBlock(BaseClass) {
var _a;
return _a = function (_BaseClass) {
_inherits(Some, _BaseClass);
function Some() {
var _this2;
_classCallCheck(this, Some);
var _a;
for (var _len4 = arguments.length, args = new Array(_len4), _key5 = 0; _key5 < _len4; _key5++) {
args[_key5] = arguments[_key5];
}
_this2 = _callSuper(this, Some, [].concat(args));
var params = args[0] || {};
_this2.isHexOnly = (_a = params.isHexOnly) !== null && _a !== void 0 ? _a : false;
_this2.valueHexView = params.valueHex ? BufferSourceConverter.toUint8Array(params.valueHex) : EMPTY_VIEW;
return _this2;
}
_createClass(Some, [{
key: "valueHex",
get: function get() {
return this.valueHexView.slice().buffer;
},
set: function set(value) {
this.valueHexView = new Uint8Array(value);
}
}, {
key: "fromBER",
value: function fromBER(inputBuffer, inputOffset, inputLength) {
var view = inputBuffer instanceof ArrayBuffer ? new Uint8Array(inputBuffer) : inputBuffer;
if (!checkBufferParams(this, view, inputOffset, inputLength)) {
return -1;
}
var endLength = inputOffset + inputLength;
this.valueHexView = view.subarray(inputOffset, endLength);
if (!this.valueHexView.length) {
this.warnings.push("Zero buffer length");
return inputOffset;
}
this.blockLength = inputLength;
return endLength;
}
}, {
key: "toBER",
value: function toBER() {
var sizeOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
if (!this.isHexOnly) {
this.error = "Flag 'isHexOnly' is not set, abort";
return EMPTY_BUFFER;
}
if (sizeOnly) {
return new ArrayBuffer(this.valueHexView.byteLength);
}
return this.valueHexView.byteLength === this.valueHexView.buffer.byteLength ? this.valueHexView.buffer : this.valueHexView.slice().buffer;
}
}, {
key: "toJSON",
value: function toJSON() {
return _objectSpread(_objectSpread({}, _get(_getPrototypeOf(Some.prototype), "toJSON", this).call(this)), {}, {
isHexOnly: this.isHexOnly,
valueHex: Convert.ToHex(this.valueHexView)
});
}
}]);
return Some;
}(BaseClass), _a.NAME = "hexBlock", _a;
}
var LocalBaseBlock = function () {
function LocalBaseBlock() {
var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref$blockLength = _ref.blockLength,
blockLength = _ref$blockLength === void 0 ? 0 : _ref$blockLength,
_ref$error = _ref.error,
error = _ref$error === void 0 ? EMPTY_STRING : _ref$error,
_ref$warnings = _ref.warnings,
warnings = _ref$warnings === void 0 ? [] : _ref$warnings,
_ref$valueBeforeDecod = _ref.valueBeforeDecode,
valueBeforeDecode = _ref$valueBeforeDecod === void 0 ? EMPTY_VIEW : _ref$valueBeforeDecod;
_classCallCheck(this, LocalBaseBlock);
this.blockLength = blockLength;
this.error = error;
this.warnings = warnings;
this.valueBeforeDecodeView = BufferSourceConverter.toUint8Array(valueBeforeDecode);
}
_createClass(LocalBaseBlock, [{
key: "valueBeforeDecode",
get: function get() {
return this.valueBeforeDecodeView.slice().buffer;
},
set: function set(value) {
this.valueBeforeDecodeView = new Uint8Array(value);
}
}, {
key: "toJSON",
value: function toJSON() {
return {
blockName: this.constructor.NAME,
blockLength: this.blockLength,
error: this.error,
warnings: this.warnings,
valueBeforeDecode: Convert.ToHex(this.valueBeforeDecodeView)
};
}
}], [{
key: "blockName",
value: function blockName() {
return this.NAME;
}
}]);
return LocalBaseBlock;
}();
LocalBaseBlock.NAME = "baseBlock";
var ValueBlock = function (_LocalBaseBlock) {
_inherits(ValueBlock, _LocalBaseBlock);
function ValueBlock() {
_classCallCheck(this, ValueBlock);
return _callSuper(this, ValueBlock, arguments);
}
_createClass(ValueBlock, [{
key: "fromBER",
value: function fromBER(inputBuffer, inputOffset, inputLength) {
throw TypeError("User need to make a specific function in a class which extends 'ValueBlock'");
}
}, {
key: "toBER",
value: function toBER(sizeOnly, writer) {
throw TypeError("User need to make a specific function in a class which extends 'ValueBlock'");
}
}]);
return ValueBlock;
}(LocalBaseBlock);
ValueBlock.NAME = "valueBlock";
var LocalIdentificationBlock = function (_HexBlock) {
_inherits(LocalIdentificationBlock, _HexBlock);
function LocalIdentificationBlock() {
var _this3;
var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
_ref2$idBlock = _ref2.idBlock,
idBlock = _ref2$idBlock === void 0 ? {} : _ref2$idBlock;
_classCallCheck(this, LocalIdentificationBlock);
var _a, _b, _c, _d;
_this3 = _callSuper(this, LocalIdentificationBlock);
if (idBlock) {
_this3.isHexOnly = (_a = idBlock.isHexOnly) !== null && _a !== void 0 ? _a : false;
_this3.valueHexView = idBlock.valueHex ? BufferSourceConverter.toUint8Array(idBlock.valueHex) : EMPTY_VIEW;
_this3.tagClass = (_b = idBlock.tagClass) !== null && _b !== void 0 ? _b : -1;
_this3.tagNumber = (_c = idBlock.tagNumber) !== null && _c !== void 0 ? _c : -1;
_this3.isConstructed = (_d = idBlock.isConstructed) !== null && _d !== void 0 ? _d : false;
} else {
_this3.tagClass = -1;
_this3.tagNumber = -1;
_this3.isConstructed = false;
}
return _this3;
}
_createClass(LocalIdentificationBlock, [{
key: "toBER",
value: function toBER() {
var sizeOnly = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
var firstOctet = 0;
switch (this.tagClass) {
case 1:
firstOctet |= 0x00;
break;
case 2:
firstOctet |= 0x40;
break;
case 3:
firstOctet |= 0x80;
break;
case 4:
firstOctet |= 0xC0;
br