@peculiar/certificates-viewer 2.0.1 → 2.0.2-alpha.0

package/dist/cjs/{dom-760f300f.js → dom-f57e260e.js}

@@ -1,7 +1,10 @@
+/*!
+ * © Peculiar Ventures https://peculiarventures.com/ - MIT License
+ */
 'use strict';
 
 /*
- Stencil Client Patch v1.17.4 | MIT Licensed | https://stenciljs.com
+ Stencil Client Patch Browser v2.17.0 | MIT Licensed | https://stenciljs.com
  */
 (function(){
 var aa=new Set("annotation-xml color-profile font-face font-face-src font-face-uri font-face-format font-face-name missing-glyph".split(" "));function g(a){var b=aa.has(a);a=/^[a-z][.0-9_a-z]*-[\-.0-9_a-z]*$/.test(a);return !b&&a}function l(a){var b=a.isConnected;if(void 0!==b)return b;for(;a&&!(a.__CE_isImportDocument||a instanceof Document);)a=a.parentNode||(window.ShadowRoot&&a instanceof ShadowRoot?a.host:void 0);return !(!a||!(a.__CE_isImportDocument||a instanceof Document))}

package/dist/cjs/download-5e7d5455.js

@@ -0,0 +1,438 @@
+/*!
+ * © Peculiar Ventures https://peculiarventures.com/ - MIT License
+ */
+'use strict';
+
+const _commonjsHelpers = require('./_commonjsHelpers-cb1f949a.js');
+
+/**
+ * @license
+ * Copyright (c) Peculiar Ventures, LLC.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * Download from buffer
+ *
+ * @example
+ * ```js
+ *    import { downloadFromBuffer } from './utils';
+ *
+ *    downloadFromBuffer(arrayBufferValue, 'myFile', 'pdf', 'applciation/pdf');
+ * ```
+ */
+function downloadFromBuffer(value, name, extension, mime = 'application/octet-stream') {
+  const blob = new Blob([value], { type: mime });
+  // @ts-ignore
+  if (navigator.msSaveBlob) { // IE10+ : (has Blob, but not a[download] or URL)
+    // @ts-ignore
+    navigator.msSaveBlob(blob, `${name}.${extension}`);
+    return new Promise((res) => setTimeout(res, 100));
+  }
+  const blobURL = window.URL.createObjectURL(blob);
+  const link = document.createElement('a');
+  const frame = document.createElement('iframe');
+  link.style.display = 'none';
+  frame.style.display = 'none';
+  frame.name = blobURL;
+  document.body.appendChild(frame);
+  link.href = blobURL;
+  link.target = blobURL;
+  link.download = `${name}.${extension}`;
+  document.body.appendChild(link);
+  link.dispatchEvent(new MouseEvent('click'));
+  document.body.removeChild(link);
+  return new Promise((res) => setTimeout(() => {
+    document.body.removeChild(frame);
+    res(undefined);
+  }, 100));
+}
+
+var build = _commonjsHelpers.createCommonjsModule(function (module, exports) {
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const ARRAY_BUFFER_NAME = "[object ArrayBuffer]";
+class BufferSourceConverter {
+    static isArrayBuffer(data) {
+        return Object.prototype.toString.call(data) === ARRAY_BUFFER_NAME;
+    }
+    static toArrayBuffer(data) {
+        if (this.isArrayBuffer(data)) {
+            return data;
+        }
+        if (data.byteLength === data.buffer.byteLength) {
+            return data.buffer;
+        }
+        return this.toUint8Array(data).slice().buffer;
+    }
+    static toUint8Array(data) {
+        return this.toView(data, Uint8Array);
+    }
+    static 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)'");
+    }
+    static isBufferSource(data) {
+        return this.isArrayBufferView(data)
+            || this.isArrayBuffer(data);
+    }
+    static isArrayBufferView(data) {
+        return ArrayBuffer.isView(data)
+            || (data && this.isArrayBuffer(data.buffer));
+    }
+    static isEqual(a, b) {
+        const aView = BufferSourceConverter.toUint8Array(a);
+        const bView = BufferSourceConverter.toUint8Array(b);
+        if (aView.length !== bView.byteLength) {
+            return false;
+        }
+        for (let i = 0; i < aView.length; i++) {
+            if (aView[i] !== bView[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static concat(...args) {
+        if (Array.isArray(args[0])) {
+            const buffers = args[0];
+            let size = 0;
+            for (const buffer of buffers) {
+                size += buffer.byteLength;
+            }
+            const res = new Uint8Array(size);
+            let offset = 0;
+            for (const buffer of buffers) {
+                const view = this.toUint8Array(buffer);
+                res.set(view, offset);
+                offset += view.length;
+            }
+            if (args[1]) {
+                return this.toView(res, args[1]);
+            }
+            return res.buffer;
+        }
+        else {
+            return this.concat(args);
+        }
+    }
+}
+
+class Utf8Converter {
+    static fromString(text) {
+        const s = unescape(encodeURIComponent(text));
+        const uintArray = new Uint8Array(s.length);
+        for (let i = 0; i < s.length; i++) {
+            uintArray[i] = s.charCodeAt(i);
+        }
+        return uintArray.buffer;
+    }
+    static toString(buffer) {
+        const buf = BufferSourceConverter.toUint8Array(buffer);
+        let encodedString = "";
+        for (let i = 0; i < buf.length; i++) {
+            encodedString += String.fromCharCode(buf[i]);
+        }
+        const decodedString = decodeURIComponent(escape(encodedString));
+        return decodedString;
+    }
+}
+class Utf16Converter {
+    static toString(buffer, littleEndian = false) {
+        const arrayBuffer = BufferSourceConverter.toArrayBuffer(buffer);
+        const dataView = new DataView(arrayBuffer);
+        let res = "";
+        for (let i = 0; i < arrayBuffer.byteLength; i += 2) {
+            const code = dataView.getUint16(i, littleEndian);
+            res += String.fromCharCode(code);
+        }
+        return res;
+    }
+    static fromString(text, littleEndian = false) {
+        const res = new ArrayBuffer(text.length * 2);
+        const dataView = new DataView(res);
+        for (let i = 0; i < text.length; i++) {
+            dataView.setUint16(i * 2, text.charCodeAt(i), littleEndian);
+        }
+        return res;
+    }
+}
+class Convert {
+    static isHex(data) {
+        return typeof data === "string"
+            && /^[a-z0-9]+$/i.test(data);
+    }
+    static isBase64(data) {
+        return typeof data === "string"
+            && /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(data);
+    }
+    static isBase64Url(data) {
+        return typeof data === "string"
+            && /^[a-zA-Z0-9-_]+$/i.test(data);
+    }
+    static ToString(buffer, enc = "utf8") {
+        const 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 '${enc}'`);
+        }
+    }
+    static FromString(str, enc = "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 '${enc}'`);
+        }
+    }
+    static ToBase64(buffer) {
+        const buf = BufferSourceConverter.toUint8Array(buffer);
+        if (typeof btoa !== "undefined") {
+            const binary = this.ToString(buf, "binary");
+            return btoa(binary);
+        }
+        else {
+            return Buffer.from(buf).toString("base64");
+        }
+    }
+    static FromBase64(base64) {
+        const 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;
+        }
+    }
+    static FromBase64Url(base64url) {
+        const 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, "/")));
+    }
+    static ToBase64Url(data) {
+        return this.ToBase64(data).replace(/\+/g, "-").replace(/\//g, "_").replace(/\=/g, "");
+    }
+    static FromUtf8String(text, encoding = 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 '${encoding}'`);
+        }
+    }
+    static ToUtf8String(buffer, encoding = 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 '${encoding}'`);
+        }
+    }
+    static FromBinary(text) {
+        const stringLength = text.length;
+        const resultView = new Uint8Array(stringLength);
+        for (let i = 0; i < stringLength; i++) {
+            resultView[i] = text.charCodeAt(i);
+        }
+        return resultView.buffer;
+    }
+    static ToBinary(buffer) {
+        const buf = BufferSourceConverter.toUint8Array(buffer);
+        let res = "";
+        for (let i = 0; i < buf.length; i++) {
+            res += String.fromCharCode(buf[i]);
+        }
+        return res;
+    }
+    static ToHex(buffer) {
+        const buf = BufferSourceConverter.toUint8Array(buffer);
+        const splitter = "";
+        const res = [];
+        const len = buf.length;
+        for (let i = 0; i < len; i++) {
+            const char = buf[i].toString(16).padStart(2, "0");
+            res.push(char);
+        }
+        return res.join(splitter);
+    }
+    static FromHex(hexString) {
+        let 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${formatted}`;
+        }
+        const res = new Uint8Array(formatted.length / 2);
+        for (let i = 0; i < formatted.length; i = i + 2) {
+            const c = formatted.slice(i, i + 2);
+            res[i / 2] = parseInt(c, 16);
+        }
+        return res.buffer;
+    }
+    static ToUtf16String(buffer, littleEndian = false) {
+        return Utf16Converter.toString(buffer, littleEndian);
+    }
+    static FromUtf16String(text, littleEndian = false) {
+        return Utf16Converter.fromString(text, littleEndian);
+    }
+    static Base64Padding(base64) {
+        const padCount = 4 - (base64.length % 4);
+        if (padCount < 4) {
+            for (let i = 0; i < padCount; i++) {
+                base64 += "=";
+            }
+        }
+        return base64;
+    }
+    static formatString(data) {
+        return (data === null || data === void 0 ? void 0 : data.replace(/[\n\r\t ]/g, "")) || "";
+    }
+}
+Convert.DEFAULT_UTF8_ENCODING = "utf8";
+
+function assign(target, ...sources) {
+    const res = arguments[0];
+    for (let i = 1; i < arguments.length; i++) {
+        const obj = arguments[i];
+        for (const prop in obj) {
+            res[prop] = obj[prop];
+        }
+    }
+    return res;
+}
+function combine(...buf) {
+    const totalByteLength = buf.map((item) => item.byteLength).reduce((prev, cur) => prev + cur);
+    const res = new Uint8Array(totalByteLength);
+    let currentPos = 0;
+    buf.map((item) => new Uint8Array(item)).forEach((arr) => {
+        for (const item2 of arr) {
+            res[currentPos++] = item2;
+        }
+    });
+    return res.buffer;
+}
+function isEqual(bytes1, bytes2) {
+    if (!(bytes1 && bytes2)) {
+        return false;
+    }
+    if (bytes1.byteLength !== bytes2.byteLength) {
+        return false;
+    }
+    const b1 = new Uint8Array(bytes1);
+    const b2 = new Uint8Array(bytes2);
+    for (let i = 0; i < bytes1.byteLength; i++) {
+        if (b1[i] !== b2[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+exports.BufferSourceConverter = BufferSourceConverter;
+exports.Convert = Convert;
+exports.assign = assign;
+exports.combine = combine;
+exports.isEqual = isEqual;
+});
+
+/**
+ * @license
+ * Copyright (c) Peculiar Ventures, LLC.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+class Download {
+}
+Download.x509 = {
+  asPEM: (pem, name) => {
+    downloadFromBuffer(build.Convert.FromString(pem), name, 'cer', 'application/pkix-cert');
+  },
+  asDER: (hex, name) => {
+    downloadFromBuffer(build.Convert.FromString(hex), name, 'cer', 'application/pkix-cert');
+  },
+};
+Download.pkcs10 = {
+  asPEM: (pem, name) => {
+    downloadFromBuffer(build.Convert.FromString(pem), name, 'csr', 'application/pkcs10');
+  },
+  asDER: (hex, name) => {
+    downloadFromBuffer(build.Convert.FromString(hex), name, 'csr', 'application/pkcs10');
+  },
+};
+
+exports.Download = Download;
+exports.build = build;
+exports.downloadFromBuffer = downloadFromBuffer;