@opendesign-plus/components 0.0.1-rc.10 → 0.0.1-rc.100

package/dist/index.d.ts

@@ -1,19 +1,37 @@
-import { default as OBanner } from './components/OBanner.vue';
-import { default as OCookieNotice } from './components/OCookieNotice.vue';
-import { default as OFooter } from './components/OFooter.vue';
-import { default as OHeaderSearch } from './components/OHeaderSearch.vue';
-import { default as OHeaderUser } from './components/OHeaderUser.vue';
-import { default as OPlusConfigProvider } from './components/OPlusConfigProvider.vue';
-import { default as OSection } from './components/OSection.vue';
-import { default as OSourceCode } from './components/OSourceCode.vue';
-import { default as OThemeSwitcher } from './components/OThemeSwitcher.vue';
-export { OBanner, OCookieNotice, OFooter, OHeaderSearch, OHeaderUser, OPlusConfigProvider, OSection, OSourceCode, OThemeSwitcher };
 export * from './components/activity';
+export * from './components/anchor-bar';
+export * from './components/article';
+export * from './components/article-anchor';
+export * from './components/article-pagination';
+export * from './components/banner';
+export * from './components/brand';
+export * from './components/config-provider';
+export * from './components/cookie-notice';
+export * from './components/doc-layout';
 export * from './components/element-plus';
+export * from './components/empty';
 export * from './components/events';
+export * from './components/feedback-doc';
+export * from './components/float-poster';
+export * from './components/footer';
 export * from './components/header';
+export * from './components/header-language-switcher';
+export * from './components/header-search';
+export * from './components/header-source-code';
+export * from './components/header-theme';
+export * from './components/header-user';
+export * from './components/html-viewer';
+export * from './components/icon';
+export * from './components/logo-swiper';
+export * from './components/markdown';
 export * from './components/meeting';
-declare const _default: {
-    install: (app: any) => void;
-};
-export default _default;
+export * from './components/org';
+export * from './components/recursion-menu';
+export * from './components/search';
+export * from './components/search-doc-result';
+export * from './components/search-result';
+export * from './components/section';
+export * from './components/sig';
+export * from './components/summit';
+export * from './components/user-center';
+export * from './components/video';

package/dist/treeshaking/_virtual/@babel/runtime/helpers/esm/extends.js.mjs

@@ -0,0 +1,11 @@
+// ../../node_modules/.pnpm/@babel+runtime@7.29.2/node_modules/@babel/runtime/helpers/esm/extends.js
+function _extends() {
+	return _extends = Object.assign ? Object.assign.bind() : function(n) {
+		for (var e = 1; e < arguments.length; e++) {
+			var t = arguments[e];
+			for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+		}
+		return n;
+	}, _extends.apply(null, arguments);
+}
+export { _extends as default };

package/dist/treeshaking/_virtual/@babel/runtime/helpers/extends.js.mjs

@@ -0,0 +1,16 @@
+import { __commonJSMin } from "../../../_rolldown/runtime.mjs";
+// ../../node_modules/.pnpm/@babel+runtime@7.29.2/node_modules/@babel/runtime/helpers/extends.js
+var require_extends = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	function _extends() {
+		return module.exports = _extends = Object.assign ? Object.assign.bind() : function(n) {
+			for (var e = 1; e < arguments.length; e++) {
+				var t = arguments[e];
+				for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+			}
+			return n;
+		}, module.exports.__esModule = true, module.exports["default"] = module.exports, _extends.apply(null, arguments);
+	}
+	module.exports = _extends, module.exports.__esModule = true, module.exports["default"] = module.exports;
+}));
+export default require_extends();
+export { require_extends };

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/byte-helpers.js.mjs

@@ -0,0 +1,146 @@
+import { __toESM } from "../../../_rolldown/runtime.mjs";
+import { require_window } from "../../../global/window.js.mjs";
+// ../../node_modules/.pnpm/@videojs+vhs-utils@4.1.1/node_modules/@videojs/vhs-utils/es/byte-helpers.js
+var import_window = /* @__PURE__ */ __toESM(require_window());
+var countBits = function countBits(x) {
+	return x.toString(2).length;
+};
+var countBytes = function countBytes(x) {
+	return Math.ceil(countBits(x) / 8);
+};
+var isArrayBufferView = function isArrayBufferView(obj) {
+	if (ArrayBuffer.isView === "function") return ArrayBuffer.isView(obj);
+	return obj && obj.buffer instanceof ArrayBuffer;
+};
+var isTypedArray = function isTypedArray(obj) {
+	return isArrayBufferView(obj);
+};
+var toUint8 = function toUint8(bytes) {
+	if (bytes instanceof Uint8Array) return bytes;
+	if (!Array.isArray(bytes) && !isTypedArray(bytes) && !(bytes instanceof ArrayBuffer)) {
+		if (typeof bytes !== "number" || typeof bytes === "number" && bytes !== bytes) bytes = 0;
+		else bytes = [bytes];
+	}
+	return new Uint8Array(bytes && bytes.buffer || bytes, bytes && bytes.byteOffset || 0, bytes && bytes.byteLength || 0);
+};
+var BigInt = import_window.default.BigInt || Number;
+var BYTE_TABLE = [
+	BigInt("0x1"),
+	BigInt("0x100"),
+	BigInt("0x10000"),
+	BigInt("0x1000000"),
+	BigInt("0x100000000"),
+	BigInt("0x10000000000"),
+	BigInt("0x1000000000000"),
+	BigInt("0x100000000000000"),
+	BigInt("0x10000000000000000")
+];
+(function() {
+	var a = new Uint16Array([65484]);
+	var b = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
+	if (b[0] === 255) return "big";
+	if (b[0] === 204) return "little";
+	return "unknown";
+})();
+var bytesToNumber = function bytesToNumber(bytes, _temp) {
+	var _ref = _temp === void 0 ? {} : _temp, _ref$signed = _ref.signed, signed = _ref$signed === void 0 ? false : _ref$signed, _ref$le = _ref.le, le = _ref$le === void 0 ? false : _ref$le;
+	bytes = toUint8(bytes);
+	var fn = le ? "reduce" : "reduceRight";
+	var number = (bytes[fn] ? bytes[fn] : Array.prototype[fn]).call(bytes, function(total, byte, i) {
+		var exponent = le ? i : Math.abs(i + 1 - bytes.length);
+		return total + BigInt(byte) * BYTE_TABLE[exponent];
+	}, BigInt(0));
+	if (signed) {
+		var max = BYTE_TABLE[bytes.length] / BigInt(2) - BigInt(1);
+		number = BigInt(number);
+		if (number > max) {
+			number -= max;
+			number -= max;
+			number -= BigInt(2);
+		}
+	}
+	return Number(number);
+};
+var numberToBytes = function numberToBytes(number, _temp2) {
+	var _ref2$le = (_temp2 === void 0 ? {} : _temp2).le, le = _ref2$le === void 0 ? false : _ref2$le;
+	if (typeof number !== "bigint" && typeof number !== "number" || typeof number === "number" && number !== number) number = 0;
+	number = BigInt(number);
+	var byteCount = countBytes(number);
+	var bytes = new Uint8Array(new ArrayBuffer(byteCount));
+	for (var i = 0; i < byteCount; i++) {
+		var byteIndex = le ? i : Math.abs(i + 1 - bytes.length);
+		bytes[byteIndex] = Number(number / BYTE_TABLE[i] & BigInt(255));
+		if (number < 0) {
+			bytes[byteIndex] = Math.abs(~bytes[byteIndex]);
+			bytes[byteIndex] -= i === 0 ? 1 : 2;
+		}
+	}
+	return bytes;
+};
+var bytesToString = function bytesToString(bytes) {
+	if (!bytes) return "";
+	bytes = Array.prototype.slice.call(bytes);
+	var string = String.fromCharCode.apply(null, toUint8(bytes));
+	try {
+		return decodeURIComponent(escape(string));
+	} catch (e) {}
+	return string;
+};
+var stringToBytes = function stringToBytes(string, stringIsBytes) {
+	if (typeof string !== "string" && string && typeof string.toString === "function") string = string.toString();
+	if (typeof string !== "string") return /* @__PURE__ */ new Uint8Array();
+	if (!stringIsBytes) string = unescape(encodeURIComponent(string));
+	var view = new Uint8Array(string.length);
+	for (var i = 0; i < string.length; i++) view[i] = string.charCodeAt(i);
+	return view;
+};
+var concatTypedArrays = function concatTypedArrays() {
+	for (var _len = arguments.length, buffers = new Array(_len), _key = 0; _key < _len; _key++) buffers[_key] = arguments[_key];
+	buffers = buffers.filter(function(b) {
+		return b && (b.byteLength || b.length) && typeof b !== "string";
+	});
+	if (buffers.length <= 1) return toUint8(buffers[0]);
+	var totalLen = buffers.reduce(function(total, buf, i) {
+		return total + (buf.byteLength || buf.length);
+	}, 0);
+	var tempBuffer = new Uint8Array(totalLen);
+	var offset = 0;
+	buffers.forEach(function(buf) {
+		buf = toUint8(buf);
+		tempBuffer.set(buf, offset);
+		offset += buf.byteLength;
+	});
+	return tempBuffer;
+};
+/**
+* Check if the bytes "b" are contained within bytes "a".
+*
+* @param {Uint8Array|Array} a
+*        Bytes to check in
+*
+* @param {Uint8Array|Array} b
+*        Bytes to check for
+*
+* @param {Object} options
+*        options
+*
+* @param {Array|Uint8Array} [offset=0]
+*        offset to use when looking at bytes in a
+*
+* @param {Array|Uint8Array} [mask=[]]
+*        mask to use on bytes before comparison.
+*
+* @return {boolean}
+*         If all bytes in b are inside of a, taking into account
+*         bit masks.
+*/
+var bytesMatch = function bytesMatch(a, b, _temp3) {
+	var _ref3 = _temp3 === void 0 ? {} : _temp3, _ref3$offset = _ref3.offset, offset = _ref3$offset === void 0 ? 0 : _ref3$offset, _ref3$mask = _ref3.mask, mask = _ref3$mask === void 0 ? [] : _ref3$mask;
+	a = toUint8(a);
+	b = toUint8(b);
+	var fn = b.every ? b.every : Array.prototype.every;
+	return b.length && a.length - offset >= b.length && fn.call(b, function(bByte, i) {
+		return bByte === (mask[i] ? mask[i] & a[offset + i] : a[offset + i]);
+	});
+};
+export { bytesMatch, bytesToNumber, bytesToString, concatTypedArrays, countBits, countBytes, isArrayBufferView, isTypedArray, numberToBytes, stringToBytes, toUint8 };

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/codec-helpers.js.mjs

@@ -0,0 +1 @@
+import "./byte-helpers.js.mjs";

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/codecs.js.mjs

@@ -0,0 +1,164 @@
+import { __toESM } from "../../../_rolldown/runtime.mjs";
+import { require_window } from "../../../global/window.js.mjs";
+// ../../node_modules/.pnpm/@videojs+vhs-utils@4.1.1/node_modules/@videojs/vhs-utils/es/codecs.js
+var import_window = /* @__PURE__ */ __toESM(require_window());
+var regexs = {
+	mp4: /^(av0?1|avc0?[1234]|vp0?9|flac|opus|mp3|mp4a|mp4v|stpp.ttml.im1t)/,
+	webm: /^(vp0?[89]|av0?1|opus|vorbis)/,
+	ogg: /^(vp0?[89]|theora|flac|opus|vorbis)/,
+	video: /^(av0?1|avc0?[1234]|vp0?[89]|hvc1|hev1|theora|mp4v)/,
+	audio: /^(mp4a|flac|vorbis|opus|ac-[34]|ec-3|alac|mp3|speex|aac)/,
+	text: /^(stpp.ttml.im1t)/,
+	muxerVideo: /^(avc0?1)/,
+	muxerAudio: /^(mp4a)/,
+	muxerText: /a^/
+};
+var mediaTypes = [
+	"video",
+	"audio",
+	"text"
+];
+var upperMediaTypes = [
+	"Video",
+	"Audio",
+	"Text"
+];
+/**
+* Replace the old apple-style `avc1.<dd>.<dd>` codec string with the standard
+* `avc1.<hhhhhh>`
+*
+* @param {string} codec
+*        Codec string to translate
+* @return {string}
+*         The translated codec string
+*/
+var translateLegacyCodec = function translateLegacyCodec(codec) {
+	if (!codec) return codec;
+	return codec.replace(/avc1\.(\d+)\.(\d+)/i, function(orig, profile, avcLevel) {
+		var profileHex = ("00" + Number(profile).toString(16)).slice(-2);
+		var avcLevelHex = ("00" + Number(avcLevel).toString(16)).slice(-2);
+		return "avc1." + profileHex + "00" + avcLevelHex;
+	});
+};
+/**
+* @typedef {Object} ParsedCodecInfo
+* @property {number} codecCount
+*           Number of codecs parsed
+* @property {string} [videoCodec]
+*           Parsed video codec (if found)
+* @property {string} [videoObjectTypeIndicator]
+*           Video object type indicator (if found)
+* @property {string|null} audioProfile
+*           Audio profile
+*/
+/**
+* Parses a codec string to retrieve the number of codecs specified, the video codec and
+* object type indicator, and the audio profile.
+*
+* @param {string} [codecString]
+*        The codec string to parse
+* @return {ParsedCodecInfo}
+*         Parsed codec info
+*/
+var parseCodecs = function parseCodecs(codecString) {
+	if (codecString === void 0) codecString = "";
+	var codecs = codecString.split(",");
+	var result = [];
+	codecs.forEach(function(codec) {
+		codec = codec.trim();
+		var codecType;
+		mediaTypes.forEach(function(name) {
+			var match = regexs[name].exec(codec.toLowerCase());
+			if (!match || match.length <= 1) return;
+			codecType = name;
+			var type = codec.substring(0, match[1].length);
+			var details = codec.replace(type, "");
+			result.push({
+				type,
+				details,
+				mediaType: name
+			});
+		});
+		if (!codecType) result.push({
+			type: codec,
+			details: "",
+			mediaType: "unknown"
+		});
+	});
+	return result;
+};
+/**
+* Returns a ParsedCodecInfo object for the default alternate audio playlist if there is
+* a default alternate audio playlist for the provided audio group.
+*
+* @param {Object} master
+*        The master playlist
+* @param {string} audioGroupId
+*        ID of the audio group for which to find the default codec info
+* @return {ParsedCodecInfo}
+*         Parsed codec info
+*/
+var codecsFromDefault = function codecsFromDefault(master, audioGroupId) {
+	if (!master.mediaGroups.AUDIO || !audioGroupId) return null;
+	var audioGroup = master.mediaGroups.AUDIO[audioGroupId];
+	if (!audioGroup) return null;
+	for (var name in audioGroup) {
+		var audioType = audioGroup[name];
+		if (audioType.default && audioType.playlists) return parseCodecs(audioType.playlists[0].attributes.CODECS);
+	}
+	return null;
+};
+var isAudioCodec = function isAudioCodec(codec) {
+	if (codec === void 0) codec = "";
+	return regexs.audio.test(codec.trim().toLowerCase());
+};
+var isTextCodec = function isTextCodec(codec) {
+	if (codec === void 0) codec = "";
+	return regexs.text.test(codec.trim().toLowerCase());
+};
+var getMimeForCodec = function getMimeForCodec(codecString) {
+	if (!codecString || typeof codecString !== "string") return;
+	var codecs = codecString.toLowerCase().split(",").map(function(c) {
+		return translateLegacyCodec(c.trim());
+	});
+	var type = "video";
+	if (codecs.length === 1 && isAudioCodec(codecs[0])) type = "audio";
+	else if (codecs.length === 1 && isTextCodec(codecs[0])) type = "application";
+	var container = "mp4";
+	if (codecs.every(function(c) {
+		return regexs.mp4.test(c);
+	})) container = "mp4";
+	else if (codecs.every(function(c) {
+		return regexs.webm.test(c);
+	})) container = "webm";
+	else if (codecs.every(function(c) {
+		return regexs.ogg.test(c);
+	})) container = "ogg";
+	return type + "/" + container + ";codecs=\"" + codecString + "\"";
+};
+/**
+* Tests whether the codec is supported by MediaSource. Optionally also tests ManagedMediaSource.
+*
+* @param {string} codecString
+*        Codec to test
+* @param {boolean} [withMMS]
+*        Whether to check if ManagedMediaSource supports it
+* @return {boolean}
+*          Codec is supported
+*/
+var browserSupportsCodec = function browserSupportsCodec(codecString, withMMS) {
+	if (codecString === void 0) codecString = "";
+	if (withMMS === void 0) withMMS = false;
+	return import_window.default.MediaSource && import_window.default.MediaSource.isTypeSupported && import_window.default.MediaSource.isTypeSupported(getMimeForCodec(codecString)) || withMMS && import_window.default.ManagedMediaSource && import_window.default.ManagedMediaSource.isTypeSupported && import_window.default.ManagedMediaSource.isTypeSupported(getMimeForCodec(codecString)) || false;
+};
+var muxerSupportsCodec = function muxerSupportsCodec(codecString) {
+	if (codecString === void 0) codecString = "";
+	return codecString.toLowerCase().split(",").every(function(codec) {
+		codec = codec.trim();
+		for (var i = 0; i < upperMediaTypes.length; i++) if (regexs["muxer" + upperMediaTypes[i]].test(codec)) return true;
+		return false;
+	});
+};
+var DEFAULT_AUDIO_CODEC = "mp4a.40.2";
+var DEFAULT_VIDEO_CODEC = "avc1.4d400d";
+export { DEFAULT_AUDIO_CODEC, DEFAULT_VIDEO_CODEC, browserSupportsCodec, codecsFromDefault, getMimeForCodec, isAudioCodec, isTextCodec, muxerSupportsCodec, parseCodecs, translateLegacyCodec };

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/containers.js.mjs

@@ -0,0 +1,187 @@
+import { bytesMatch, toUint8 } from "./byte-helpers.js.mjs";
+import { getId3Offset } from "./id3-helpers.js.mjs";
+import { findBox } from "./mp4-helpers.js.mjs";
+import { EBML_TAGS, findEbml } from "./ebml-helpers.js.mjs";
+import { findH264Nal, findH265Nal } from "./nal-helpers.js.mjs";
+// ../../node_modules/.pnpm/@videojs+vhs-utils@4.1.1/node_modules/@videojs/vhs-utils/es/containers.js
+var CONSTANTS = {
+	"webm": toUint8([
+		119,
+		101,
+		98,
+		109
+	]),
+	"matroska": toUint8([
+		109,
+		97,
+		116,
+		114,
+		111,
+		115,
+		107,
+		97
+	]),
+	"flac": toUint8([
+		102,
+		76,
+		97,
+		67
+	]),
+	"ogg": toUint8([
+		79,
+		103,
+		103,
+		83
+	]),
+	"ac3": toUint8([11, 119]),
+	"riff": toUint8([
+		82,
+		73,
+		70,
+		70
+	]),
+	"avi": toUint8([
+		65,
+		86,
+		73
+	]),
+	"wav": toUint8([
+		87,
+		65,
+		86,
+		69
+	]),
+	"3gp": toUint8([
+		102,
+		116,
+		121,
+		112,
+		51,
+		103
+	]),
+	"mp4": toUint8([
+		102,
+		116,
+		121,
+		112
+	]),
+	"fmp4": toUint8([
+		115,
+		116,
+		121,
+		112
+	]),
+	"mov": toUint8([
+		102,
+		116,
+		121,
+		112,
+		113,
+		116
+	]),
+	"moov": toUint8([
+		109,
+		111,
+		111,
+		118
+	]),
+	"moof": toUint8([
+		109,
+		111,
+		111,
+		102
+	])
+};
+var _isLikely = {
+	aac: function aac(bytes) {
+		var offset = getId3Offset(bytes);
+		return bytesMatch(bytes, [255, 16], {
+			offset,
+			mask: [255, 22]
+		});
+	},
+	mp3: function mp3(bytes) {
+		var offset = getId3Offset(bytes);
+		return bytesMatch(bytes, [255, 2], {
+			offset,
+			mask: [255, 6]
+		});
+	},
+	webm: function webm(bytes) {
+		var docType = findEbml(bytes, [EBML_TAGS.EBML, EBML_TAGS.DocType])[0];
+		return bytesMatch(docType, CONSTANTS.webm);
+	},
+	mkv: function mkv(bytes) {
+		var docType = findEbml(bytes, [EBML_TAGS.EBML, EBML_TAGS.DocType])[0];
+		return bytesMatch(docType, CONSTANTS.matroska);
+	},
+	mp4: function mp4(bytes) {
+		if (_isLikely["3gp"](bytes) || _isLikely.mov(bytes)) return false;
+		if (bytesMatch(bytes, CONSTANTS.mp4, { offset: 4 }) || bytesMatch(bytes, CONSTANTS.fmp4, { offset: 4 })) return true;
+		if (bytesMatch(bytes, CONSTANTS.moof, { offset: 4 }) || bytesMatch(bytes, CONSTANTS.moov, { offset: 4 })) return true;
+	},
+	mov: function mov(bytes) {
+		return bytesMatch(bytes, CONSTANTS.mov, { offset: 4 });
+	},
+	"3gp": function gp(bytes) {
+		return bytesMatch(bytes, CONSTANTS["3gp"], { offset: 4 });
+	},
+	ac3: function ac3(bytes) {
+		var offset = getId3Offset(bytes);
+		return bytesMatch(bytes, CONSTANTS.ac3, { offset });
+	},
+	ts: function ts(bytes) {
+		if (bytes.length < 189 && bytes.length >= 1) return bytes[0] === 71;
+		var i = 0;
+		while (i + 188 < bytes.length && i < 188) {
+			if (bytes[i] === 71 && bytes[i + 188] === 71) return true;
+			i += 1;
+		}
+		return false;
+	},
+	flac: function flac(bytes) {
+		var offset = getId3Offset(bytes);
+		return bytesMatch(bytes, CONSTANTS.flac, { offset });
+	},
+	ogg: function ogg(bytes) {
+		return bytesMatch(bytes, CONSTANTS.ogg);
+	},
+	avi: function avi(bytes) {
+		return bytesMatch(bytes, CONSTANTS.riff) && bytesMatch(bytes, CONSTANTS.avi, { offset: 8 });
+	},
+	wav: function wav(bytes) {
+		return bytesMatch(bytes, CONSTANTS.riff) && bytesMatch(bytes, CONSTANTS.wav, { offset: 8 });
+	},
+	"h264": function h264(bytes) {
+		return findH264Nal(bytes, 7, 3).length;
+	},
+	"h265": function h265(bytes) {
+		return findH265Nal(bytes, [32, 33], 3).length;
+	}
+};
+var isLikelyTypes = Object.keys(_isLikely).filter(function(t) {
+	return t !== "ts" && t !== "h264" && t !== "h265";
+}).concat([
+	"ts",
+	"h264",
+	"h265"
+]);
+isLikelyTypes.forEach(function(type) {
+	var isLikelyFn = _isLikely[type];
+	_isLikely[type] = function(bytes) {
+		return isLikelyFn(toUint8(bytes));
+	};
+});
+var isLikely = _isLikely;
+var detectContainerForBytes = function detectContainerForBytes(bytes) {
+	bytes = toUint8(bytes);
+	for (var i = 0; i < isLikelyTypes.length; i++) {
+		var type = isLikelyTypes[i];
+		if (isLikely[type](bytes)) return type;
+	}
+	return "";
+};
+var isLikelyFmp4MediaSegment = function isLikelyFmp4MediaSegment(bytes) {
+	return findBox(bytes, ["moof"]).length > 0;
+};
+export { detectContainerForBytes, isLikely, isLikelyFmp4MediaSegment };

package/dist/treeshaking/_virtual/@videojs/vhs-utils/es/decode-b64-to-uint8-array.js.mjs

@@ -0,0 +1,14 @@
+import { __toESM } from "../../../_rolldown/runtime.mjs";
+import { require_window } from "../../../global/window.js.mjs";
+// ../../node_modules/.pnpm/@videojs+vhs-utils@4.1.1/node_modules/@videojs/vhs-utils/es/decode-b64-to-uint8-array.js
+var import_window = /* @__PURE__ */ __toESM(require_window());
+var atob = function atob(s) {
+	return import_window.default.atob ? import_window.default.atob(s) : Buffer.from(s, "base64").toString("binary");
+};
+function decodeB64ToUint8Array(b64Text) {
+	var decodedString = atob(b64Text);
+	var array = new Uint8Array(decodedString.length);
+	for (var i = 0; i < decodedString.length; i++) array[i] = decodedString.charCodeAt(i);
+	return array;
+}
+export { decodeB64ToUint8Array as default };