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

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

@@ -0,0 +1,165 @@
+import { bytesMatch, bytesToNumber, numberToBytes, toUint8 } from "./byte-helpers.js.mjs";
+import "./codec-helpers.js.mjs";
+// ../../node_modules/.pnpm/@videojs+vhs-utils@4.1.1/node_modules/@videojs/vhs-utils/es/ebml-helpers.js
+var EBML_TAGS = {
+	EBML: toUint8([
+		26,
+		69,
+		223,
+		163
+	]),
+	DocType: toUint8([66, 130]),
+	Segment: toUint8([
+		24,
+		83,
+		128,
+		103
+	]),
+	SegmentInfo: toUint8([
+		21,
+		73,
+		169,
+		102
+	]),
+	Tracks: toUint8([
+		22,
+		84,
+		174,
+		107
+	]),
+	Track: toUint8([174]),
+	TrackNumber: toUint8([215]),
+	DefaultDuration: toUint8([
+		35,
+		227,
+		131
+	]),
+	TrackEntry: toUint8([174]),
+	TrackType: toUint8([131]),
+	FlagDefault: toUint8([136]),
+	CodecID: toUint8([134]),
+	CodecPrivate: toUint8([99, 162]),
+	VideoTrack: toUint8([224]),
+	AudioTrack: toUint8([225]),
+	Cluster: toUint8([
+		31,
+		67,
+		182,
+		117
+	]),
+	Timestamp: toUint8([231]),
+	TimestampScale: toUint8([
+		42,
+		215,
+		177
+	]),
+	BlockGroup: toUint8([160]),
+	BlockDuration: toUint8([155]),
+	Block: toUint8([161]),
+	SimpleBlock: toUint8([163])
+};
+/**
+* This is a simple table to determine the length
+* of things in ebml. The length is one based (starts at 1,
+* rather than zero) and for every zero bit before a one bit
+* we add one to length. We also need this table because in some
+* case we have to xor all the length bits from another value.
+*/
+var LENGTH_TABLE = [
+	128,
+	64,
+	32,
+	16,
+	8,
+	4,
+	2,
+	1
+];
+var getLength = function getLength(byte) {
+	var len = 1;
+	for (var i = 0; i < LENGTH_TABLE.length; i++) {
+		if (byte & LENGTH_TABLE[i]) break;
+		len++;
+	}
+	return len;
+};
+var getvint = function getvint(bytes, offset, removeLength, signed) {
+	if (removeLength === void 0) removeLength = true;
+	if (signed === void 0) signed = false;
+	var length = getLength(bytes[offset]);
+	var valueBytes = bytes.subarray(offset, offset + length);
+	if (removeLength) {
+		valueBytes = Array.prototype.slice.call(bytes, offset, offset + length);
+		valueBytes[0] ^= LENGTH_TABLE[length - 1];
+	}
+	return {
+		length,
+		value: bytesToNumber(valueBytes, { signed }),
+		bytes: valueBytes
+	};
+};
+var normalizePath = function normalizePath(path) {
+	if (typeof path === "string") return path.match(/.{1,2}/g).map(function(p) {
+		return normalizePath(p);
+	});
+	if (typeof path === "number") return numberToBytes(path);
+	return path;
+};
+var normalizePaths = function normalizePaths(paths) {
+	if (!Array.isArray(paths)) return [normalizePath(paths)];
+	return paths.map(function(p) {
+		return normalizePath(p);
+	});
+};
+var getInfinityDataSize = function getInfinityDataSize(id, bytes, offset) {
+	if (offset >= bytes.length) return bytes.length;
+	var innerid = getvint(bytes, offset, false);
+	if (bytesMatch(id.bytes, innerid.bytes)) return offset;
+	var dataHeader = getvint(bytes, offset + innerid.length);
+	return getInfinityDataSize(id, bytes, offset + dataHeader.length + dataHeader.value + innerid.length);
+};
+/**
+* Notes on the EBLM format.
+*
+* EBLM uses "vints" tags. Every vint tag contains
+* two parts
+*
+* 1. The length from the first byte. You get this by
+*    converting the byte to binary and counting the zeros
+*    before a 1. Then you add 1 to that. Examples
+*    00011111 = length 4 because there are 3 zeros before a 1.
+*    00100000 = length 3 because there are 2 zeros before a 1.
+*    00000011 = length 7 because there are 6 zeros before a 1.
+*
+* 2. The bits used for length are removed from the first byte
+*    Then all the bytes are merged into a value. NOTE: this
+*    is not the case for id ebml tags as there id includes
+*    length bits.
+*
+*/
+var findEbml = function findEbml(bytes, paths) {
+	paths = normalizePaths(paths);
+	bytes = toUint8(bytes);
+	var results = [];
+	if (!paths.length) return results;
+	var i = 0;
+	while (i < bytes.length) {
+		var id = getvint(bytes, i, false);
+		var dataHeader = getvint(bytes, i + id.length);
+		var dataStart = i + id.length + dataHeader.length;
+		if (dataHeader.value === 127) {
+			dataHeader.value = getInfinityDataSize(id, bytes, dataStart);
+			if (dataHeader.value !== bytes.length) dataHeader.value -= dataStart;
+		}
+		var dataEnd = dataStart + dataHeader.value > bytes.length ? bytes.length : dataStart + dataHeader.value;
+		var data = bytes.subarray(dataStart, dataEnd);
+		if (bytesMatch(paths[0], id.bytes)) {
+			if (paths.length === 1) results.push(data);
+			else results = results.concat(findEbml(data, paths.slice(1)));
+		}
+		var totalLength = id.length + dataHeader.length + data.length;
+		i += totalLength;
+	}
+	return results;
+};
+export { EBML_TAGS, findEbml };

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

@@ -0,0 +1,23 @@
+import { bytesMatch, toUint8 } from "./byte-helpers.js.mjs";
+// ../../node_modules/.pnpm/@videojs+vhs-utils@4.1.1/node_modules/@videojs/vhs-utils/es/id3-helpers.js
+var ID3 = toUint8([
+	73,
+	68,
+	51
+]);
+var getId3Size = function getId3Size(bytes, offset) {
+	if (offset === void 0) offset = 0;
+	bytes = toUint8(bytes);
+	var flags = bytes[offset + 5];
+	var returnSize = bytes[offset + 6] << 21 | bytes[offset + 7] << 14 | bytes[offset + 8] << 7 | bytes[offset + 9];
+	if ((flags & 16) >> 4) return returnSize + 20;
+	return returnSize + 10;
+};
+var getId3Offset = function getId3Offset(bytes, offset) {
+	if (offset === void 0) offset = 0;
+	bytes = toUint8(bytes);
+	if (bytes.length - offset < 10 || !bytesMatch(bytes, ID3, { offset })) return offset;
+	offset += getId3Size(bytes, offset);
+	return getId3Offset(bytes, offset);
+};
+export { getId3Offset, getId3Size };

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

@@ -0,0 +1,21 @@
+// ../../node_modules/.pnpm/@videojs+vhs-utils@4.1.1/node_modules/@videojs/vhs-utils/es/media-groups.js
+/**
+* Loops through all supported media groups in master and calls the provided
+* callback for each group
+*
+* @param {Object} master
+*        The parsed master manifest object
+* @param {string[]} groups
+*        The media groups to call the callback for
+* @param {Function} callback
+*        Callback to call for each media group
+*/
+var forEachMediaGroup = function forEachMediaGroup(master, groups, callback) {
+	groups.forEach(function(mediaType) {
+		for (var groupKey in master.mediaGroups[mediaType]) for (var labelKey in master.mediaGroups[mediaType][groupKey]) {
+			var mediaProperties = master.mediaGroups[mediaType][groupKey][labelKey];
+			callback(mediaProperties, mediaType, groupKey, labelKey);
+		}
+	});
+};
+export { forEachMediaGroup };

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

@@ -0,0 +1,21 @@
+// ../../node_modules/.pnpm/@videojs+vhs-utils@4.1.1/node_modules/@videojs/vhs-utils/es/media-types.js
+var MPEGURL_REGEX = /^(audio|video|application)\/(x-|vnd\.apple\.)?mpegurl/i;
+var DASH_REGEX = /^application\/dash\+xml/i;
+/**
+* Returns a string that describes the type of source based on a video source object's
+* media type.
+*
+* @see {@link https://dev.w3.org/html5/pf-summary/video.html#dom-source-type|Source Type}
+*
+* @param {string} type
+*        Video source object media type
+* @return {('hls'|'dash'|'vhs-json'|null)}
+*         VHS source type string
+*/
+var simpleTypeFromSourceType = function simpleTypeFromSourceType(type) {
+	if (MPEGURL_REGEX.test(type)) return "hls";
+	if (DASH_REGEX.test(type)) return "dash";
+	if (type === "application/vnd.videojs.vhs+json") return "vhs-json";
+	return null;
+};
+export { simpleTypeFromSourceType };

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

@@ -0,0 +1,154 @@
+import { bytesMatch, bytesToString, stringToBytes, toUint8 } from "./byte-helpers.js.mjs";
+import "./codec-helpers.js.mjs";
+import "./opus-helpers.js.mjs";
+// ../../node_modules/.pnpm/@videojs+vhs-utils@4.1.1/node_modules/@videojs/vhs-utils/es/mp4-helpers.js
+var normalizePath = function normalizePath(path) {
+	if (typeof path === "string") return stringToBytes(path);
+	if (typeof path === "number") return path;
+	return path;
+};
+var normalizePaths = function normalizePaths(paths) {
+	if (!Array.isArray(paths)) return [normalizePath(paths)];
+	return paths.map(function(p) {
+		return normalizePath(p);
+	});
+};
+var DESCRIPTORS;
+var parseDescriptors = function parseDescriptors(bytes) {
+	bytes = toUint8(bytes);
+	var results = [];
+	var i = 0;
+	while (bytes.length > i) {
+		var tag = bytes[i];
+		var size = 0;
+		var headerSize = 0;
+		headerSize++;
+		var byte = bytes[headerSize];
+		headerSize++;
+		while (byte & 128) {
+			size = (byte & 127) << 7;
+			byte = bytes[headerSize];
+			headerSize++;
+		}
+		size += byte & 127;
+		for (var z = 0; z < DESCRIPTORS.length; z++) {
+			var _DESCRIPTORS$z = DESCRIPTORS[z], id = _DESCRIPTORS$z.id, parser = _DESCRIPTORS$z.parser;
+			if (tag === id) {
+				results.push(parser(bytes.subarray(headerSize, headerSize + size)));
+				break;
+			}
+		}
+		i += size + headerSize;
+	}
+	return results;
+};
+DESCRIPTORS = [
+	{
+		id: 3,
+		parser: function parser(bytes) {
+			var desc = {
+				tag: 3,
+				id: bytes[0] << 8 | bytes[1],
+				flags: bytes[2],
+				size: 3,
+				dependsOnEsId: 0,
+				ocrEsId: 0,
+				descriptors: [],
+				url: ""
+			};
+			if (desc.flags & 128) {
+				desc.dependsOnEsId = bytes[desc.size] << 8 | bytes[desc.size + 1];
+				desc.size += 2;
+			}
+			if (desc.flags & 64) {
+				var len = bytes[desc.size];
+				desc.url = bytesToString(bytes.subarray(desc.size + 1, desc.size + 1 + len));
+				desc.size += len;
+			}
+			if (desc.flags & 32) {
+				desc.ocrEsId = bytes[desc.size] << 8 | bytes[desc.size + 1];
+				desc.size += 2;
+			}
+			desc.descriptors = parseDescriptors(bytes.subarray(desc.size)) || [];
+			return desc;
+		}
+	},
+	{
+		id: 4,
+		parser: function parser(bytes) {
+			return {
+				tag: 4,
+				oti: bytes[0],
+				streamType: bytes[1],
+				bufferSize: bytes[2] << 16 | bytes[3] << 8 | bytes[4],
+				maxBitrate: bytes[5] << 24 | bytes[6] << 16 | bytes[7] << 8 | bytes[8],
+				avgBitrate: bytes[9] << 24 | bytes[10] << 16 | bytes[11] << 8 | bytes[12],
+				descriptors: parseDescriptors(bytes.subarray(13))
+			};
+		}
+	},
+	{
+		id: 5,
+		parser: function parser(bytes) {
+			return {
+				tag: 5,
+				bytes
+			};
+		}
+	},
+	{
+		id: 6,
+		parser: function parser(bytes) {
+			return {
+				tag: 6,
+				bytes
+			};
+		}
+	}
+];
+/**
+* find any number of boxes by name given a path to it in an iso bmff
+* such as mp4.
+*
+* @param {TypedArray} bytes
+*        bytes for the iso bmff to search for boxes in
+*
+* @param {Uint8Array[]|string[]|string|Uint8Array} name
+*        An array of paths or a single path representing the name
+*        of boxes to search through in bytes. Paths may be
+*        uint8 (character codes) or strings.
+*
+* @param {boolean} [complete=false]
+*        Should we search only for complete boxes on the final path.
+*        This is very useful when you do not want to get back partial boxes
+*        in the case of streaming files.
+*
+* @return {Uint8Array[]}
+*         An array of the end paths that we found.
+*/
+var findBox = function findBox(bytes, paths, complete) {
+	if (complete === void 0) complete = false;
+	paths = normalizePaths(paths);
+	bytes = toUint8(bytes);
+	var results = [];
+	if (!paths.length) return results;
+	var i = 0;
+	while (i < bytes.length) {
+		var size = (bytes[i] << 24 | bytes[i + 1] << 16 | bytes[i + 2] << 8 | bytes[i + 3]) >>> 0;
+		var type = bytes.subarray(i + 4, i + 8);
+		if (size === 0) break;
+		var end = i + size;
+		if (end > bytes.length) {
+			if (complete) break;
+			end = bytes.length;
+		}
+		var data = bytes.subarray(i + 8, end);
+		if (bytesMatch(type, paths[0])) {
+			if (paths.length === 1) results.push(data);
+			else results.push.apply(results, findBox(data, paths.slice(1), complete));
+		}
+		i = end;
+	}
+	return results;
+};
+export { findBox, parseDescriptors };

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

@@ -0,0 +1,82 @@
+import { bytesMatch, toUint8 } from "./byte-helpers.js.mjs";
+// ../../node_modules/.pnpm/@videojs+vhs-utils@4.1.1/node_modules/@videojs/vhs-utils/es/nal-helpers.js
+var NAL_TYPE_ONE = toUint8([
+	0,
+	0,
+	0,
+	1
+]);
+var NAL_TYPE_TWO = toUint8([
+	0,
+	0,
+	1
+]);
+var EMULATION_PREVENTION = toUint8([
+	0,
+	0,
+	3
+]);
+/**
+* Expunge any "Emulation Prevention" bytes from a "Raw Byte
+* Sequence Payload"
+*
+* @param data {Uint8Array} the bytes of a RBSP from a NAL
+* unit
+* @return {Uint8Array} the RBSP without any Emulation
+* Prevention Bytes
+*/
+var discardEmulationPreventionBytes = function discardEmulationPreventionBytes(bytes) {
+	var positions = [];
+	var i = 1;
+	while (i < bytes.length - 2) {
+		if (bytesMatch(bytes.subarray(i, i + 3), EMULATION_PREVENTION)) {
+			positions.push(i + 2);
+			i++;
+		}
+		i++;
+	}
+	if (positions.length === 0) return bytes;
+	var newLength = bytes.length - positions.length;
+	var newData = new Uint8Array(newLength);
+	var sourceIndex = 0;
+	for (i = 0; i < newLength; sourceIndex++, i++) {
+		if (sourceIndex === positions[0]) {
+			sourceIndex++;
+			positions.shift();
+		}
+		newData[i] = bytes[sourceIndex];
+	}
+	return newData;
+};
+var findNal = function findNal(bytes, dataType, types, nalLimit) {
+	if (nalLimit === void 0) nalLimit = Infinity;
+	bytes = toUint8(bytes);
+	types = [].concat(types);
+	var i = 0;
+	var nalStart;
+	var nalsFound = 0;
+	while (i < bytes.length && (nalsFound < nalLimit || nalStart)) {
+		var nalOffset = void 0;
+		if (bytesMatch(bytes.subarray(i), NAL_TYPE_ONE)) nalOffset = 4;
+		else if (bytesMatch(bytes.subarray(i), NAL_TYPE_TWO)) nalOffset = 3;
+		if (!nalOffset) {
+			i++;
+			continue;
+		}
+		nalsFound++;
+		if (nalStart) return discardEmulationPreventionBytes(bytes.subarray(nalStart, i));
+		var nalType = void 0;
+		if (dataType === "h264") nalType = bytes[i + nalOffset] & 31;
+		else if (dataType === "h265") nalType = bytes[i + nalOffset] >> 1 & 63;
+		if (types.indexOf(nalType) !== -1) nalStart = i + nalOffset;
+		i += nalOffset + (dataType === "h264" ? 1 : 2);
+	}
+	return bytes.subarray(0, 0);
+};
+var findH264Nal = function findH264Nal(bytes, type, nalLimit) {
+	return findNal(bytes, "h264", type, nalLimit);
+};
+var findH265Nal = function findH265Nal(bytes, type, nalLimit) {
+	return findNal(bytes, "h265", type, nalLimit);
+};
+export { EMULATION_PREVENTION, NAL_TYPE_ONE, NAL_TYPE_TWO, discardEmulationPreventionBytes, findH264Nal, findH265Nal, findNal };

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

@@ -0,0 +1,10 @@
+new Uint8Array([
+	79,
+	112,
+	117,
+	115,
+	72,
+	101,
+	97,
+	100
+]);

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

@@ -0,0 +1,17 @@
+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/resolve-url.js
+var import_window = /* @__PURE__ */ __toESM(require_window());
+var DEFAULT_LOCATION = "https://example.com";
+var resolveUrl = function resolveUrl(baseUrl, relativeUrl) {
+	if (/^[a-z]+:/i.test(relativeUrl)) return relativeUrl;
+	if (/^data:/.test(baseUrl)) baseUrl = import_window.default.location && import_window.default.location.href || "";
+	var protocolLess = /^\/\//.test(baseUrl);
+	var removeLocation = !import_window.default.location && !/\/\//i.test(baseUrl);
+	baseUrl = new import_window.default.URL(baseUrl, import_window.default.location || DEFAULT_LOCATION);
+	var newUrl = new URL(relativeUrl, baseUrl);
+	if (removeLocation) return newUrl.href.slice(DEFAULT_LOCATION.length);
+	else if (protocolLess) return newUrl.href.slice(newUrl.protocol.length);
+	return newUrl.href;
+};
+export { resolveUrl as default };

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

@@ -0,0 +1,55 @@
+// ../../node_modules/.pnpm/@videojs+vhs-utils@4.1.1/node_modules/@videojs/vhs-utils/es/stream.js
+/**
+* @file stream.js
+*/
+/**
+* A lightweight readable stream implemention that handles event dispatching.
+*
+* @class Stream
+*/
+var Stream = /*#__PURE__*/ function() {
+	function Stream() {
+		this.listeners = {};
+	}
+	/**
+	* Add a listener for a specified event type.
+	*
+	* @param {string} type the event name
+	* @param {Function} listener the callback to be invoked when an event of
+	* the specified type occurs
+	*/
+	var _proto = Stream.prototype;
+	_proto.on = function on(type, listener) {
+		if (!this.listeners[type]) this.listeners[type] = [];
+		this.listeners[type].push(listener);
+	};
+	_proto.off = function off(type, listener) {
+		if (!this.listeners[type]) return false;
+		var index = this.listeners[type].indexOf(listener);
+		this.listeners[type] = this.listeners[type].slice(0);
+		this.listeners[type].splice(index, 1);
+		return index > -1;
+	};
+	_proto.trigger = function trigger(type) {
+		var callbacks = this.listeners[type];
+		if (!callbacks) return;
+		if (arguments.length === 2) {
+			var length = callbacks.length;
+			for (var i = 0; i < length; ++i) callbacks[i].call(this, arguments[1]);
+		} else {
+			var args = Array.prototype.slice.call(arguments, 1);
+			var _length = callbacks.length;
+			for (var _i = 0; _i < _length; ++_i) callbacks[_i].apply(this, args);
+		}
+	};
+	_proto.dispose = function dispose() {
+		this.listeners = {};
+	};
+	_proto.pipe = function pipe(destination) {
+		this.on("data", function(data) {
+			destination.push(data);
+		});
+	};
+	return Stream;
+}();
+export { Stream as default };

package/dist/treeshaking/_virtual/@videojs/xhr/lib/http-handler.js.mjs

@@ -0,0 +1,40 @@
+import { __commonJSMin } from "../../../_rolldown/runtime.mjs";
+import { require_window } from "../../../global/window.js.mjs";
+// ../../node_modules/.pnpm/@videojs+xhr@2.7.0/node_modules/@videojs/xhr/lib/http-handler.js
+var require_http_handler = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var window = require_window();
+	var httpResponseHandler = function httpResponseHandler(callback, decodeResponseBody) {
+		if (decodeResponseBody === void 0) decodeResponseBody = false;
+		return function(err, response, responseBody) {
+			if (err) {
+				callback(err);
+				return;
+			}
+			if (response.statusCode >= 400 && response.statusCode <= 599) {
+				var cause = responseBody;
+				if (decodeResponseBody) {
+					if (window.TextDecoder) {
+						var charset = getCharset(response.headers && response.headers["content-type"]);
+						try {
+							cause = new TextDecoder(charset).decode(responseBody);
+						} catch (e) {}
+					} else cause = String.fromCharCode.apply(null, new Uint8Array(responseBody));
+				}
+				callback({ cause });
+				return;
+			}
+			callback(null, responseBody);
+		};
+	};
+	function getCharset(contentTypeHeader) {
+		if (contentTypeHeader === void 0) contentTypeHeader = "";
+		return contentTypeHeader.toLowerCase().split(";").reduce(function(charset, contentType) {
+			var _contentType$split = contentType.split("="), type = _contentType$split[0], value = _contentType$split[1];
+			if (type.trim() === "charset") return value.trim();
+			return charset;
+		}, "utf-8");
+	}
+	module.exports = httpResponseHandler;
+}));
+export default require_http_handler();
+export { require_http_handler };