@opendesign-plus/components 0.0.1-rc.34 → 0.0.1-rc.36

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

@@ -0,0 +1,17 @@
+var MPEGURL_REGEX = /^(audio|video|application)\/(x-|vnd\.apple\.)?mpegurl/i;
+var DASH_REGEX = /^application\/dash\+xml/i;
+var simpleTypeFromSourceType = function simpleTypeFromSourceType2(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,57 @@
+import { toUint8, bytesMatch, stringToBytes } from "./byte-helpers.js.mjs";
+var normalizePath = function normalizePath2(path) {
+  if (typeof path === "string") {
+    return stringToBytes(path);
+  }
+  if (typeof path === "number") {
+    return path;
+  }
+  return path;
+};
+var normalizePaths = function normalizePaths2(paths) {
+  if (!Array.isArray(paths)) {
+    return [normalizePath(paths)];
+  }
+  return paths.map(function(p) {
+    return normalizePath(p);
+  });
+};
+var findBox = function findBox2(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, findBox2(data, paths.slice(1), complete));
+      }
+    }
+    i = end;
+  }
+  return results;
+};
+export {
+  findBox
+};

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

@@ -0,0 +1,78 @@
+import { toUint8, bytesMatch } from "./byte-helpers.js.mjs";
+var NAL_TYPE_ONE = toUint8([0, 0, 0, 1]);
+var NAL_TYPE_TWO = toUint8([0, 0, 1]);
+var EMULATION_PREVENTION = toUint8([0, 0, 3]);
+var discardEmulationPreventionBytes = function discardEmulationPreventionBytes2(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 findNal2(bytes, dataType, types, nalLimit) {
+  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 findH264Nal2(bytes, type, nalLimit) {
+  return findNal(bytes, "h264", type, nalLimit);
+};
+var findH265Nal = function findH265Nal2(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/resolve-url.js.mjs

@@ -0,0 +1,23 @@
+import window$1 from "../../../global/window.js.mjs";
+var DEFAULT_LOCATION = "https://example.com";
+var resolveUrl = function resolveUrl2(baseUrl, relativeUrl) {
+  if (/^[a-z]+:/i.test(relativeUrl)) {
+    return relativeUrl;
+  }
+  if (/^data:/.test(baseUrl)) {
+    baseUrl = window$1.location && window$1.location.href || "";
+  }
+  var protocolLess = /^\/\//.test(baseUrl);
+  var removeLocation = !window$1.location && !/\/\//i.test(baseUrl);
+  baseUrl = new window$1.URL(baseUrl, window$1.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,51 @@
+var Stream = /* @__PURE__ */ (function() {
+  function Stream2() {
+    this.listeners = {};
+  }
+  var _proto = Stream2.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 Stream2;
+})();
+export {
+  Stream as default
+};

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

@@ -0,0 +1,55 @@
+import { __require as requireWindow } from "../../../global/window.js2.mjs";
+var httpHandler;
+var hasRequiredHttpHandler;
+function requireHttpHandler() {
+  if (hasRequiredHttpHandler) return httpHandler;
+  hasRequiredHttpHandler = 1;
+  var window = requireWindow();
+  var httpResponseHandler = function httpResponseHandler2(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");
+  }
+  httpHandler = httpResponseHandler;
+  return httpHandler;
+}
+export {
+  requireHttpHandler as __require
+};

package/dist/treeshaking/_virtual/@videojs/xhr/lib/index.js.mjs

@@ -0,0 +1,7 @@
+import { getDefaultExportFromCjs } from "../../../_commonjsHelpers.mjs";
+import { __require as requireLib } from "./index.js2.mjs";
+var libExports = requireLib();
+const XHR = /* @__PURE__ */ getDefaultExportFromCjs(libExports);
+export {
+  XHR as default
+};

package/dist/treeshaking/_virtual/@videojs/xhr/lib/index.js2.mjs

@@ -0,0 +1,300 @@
+import { __module as lib } from "./index.js3.mjs";
+import { __require as requireWindow } from "../../../global/window.js2.mjs";
+import { __require as require_extends } from "../../../@babel/runtime/helpers/extends.js.mjs";
+import { __require as requireIsFunction } from "../../../is-function/index.js.mjs";
+import { __require as requireInterceptors } from "./interceptors.js.mjs";
+import { __require as requireRetry } from "./retry.js.mjs";
+import { __require as requireHttpHandler } from "./http-handler.js.mjs";
+var hasRequiredLib;
+function requireLib() {
+  if (hasRequiredLib) return lib.exports;
+  hasRequiredLib = 1;
+  var window = requireWindow();
+  var _extends = require_extends();
+  var isFunction = requireIsFunction();
+  var InterceptorsStorage = requireInterceptors();
+  var RetryManager = requireRetry();
+  createXHR.httpHandler = requireHttpHandler();
+  createXHR.requestInterceptorsStorage = new InterceptorsStorage();
+  createXHR.responseInterceptorsStorage = new InterceptorsStorage();
+  createXHR.retryManager = new RetryManager();
+  /**
+   * @license
+   * slighly modified parse-headers 2.0.2 <https://github.com/kesla/parse-headers/>
+   * Copyright (c) 2014 David Björklund
+   * Available under the MIT license
+   * <https://github.com/kesla/parse-headers/blob/master/LICENCE>
+   */
+  var parseHeaders = function parseHeaders2(headers) {
+    var result = {};
+    if (!headers) {
+      return result;
+    }
+    headers.trim().split("\n").forEach(function(row) {
+      var index = row.indexOf(":");
+      var key = row.slice(0, index).trim().toLowerCase();
+      var value = row.slice(index + 1).trim();
+      if (typeof result[key] === "undefined") {
+        result[key] = value;
+      } else if (Array.isArray(result[key])) {
+        result[key].push(value);
+      } else {
+        result[key] = [result[key], value];
+      }
+    });
+    return result;
+  };
+  lib.exports = createXHR;
+  lib.exports.default = createXHR;
+  createXHR.XMLHttpRequest = window.XMLHttpRequest || noop;
+  createXHR.XDomainRequest = "withCredentials" in new createXHR.XMLHttpRequest() ? createXHR.XMLHttpRequest : window.XDomainRequest;
+  forEachArray(["get", "put", "post", "patch", "head", "delete"], function(method) {
+    createXHR[method === "delete" ? "del" : method] = function(uri, options, callback) {
+      options = initParams(uri, options, callback);
+      options.method = method.toUpperCase();
+      return _createXHR(options);
+    };
+  });
+  function forEachArray(array, iterator) {
+    for (var i = 0; i < array.length; i++) {
+      iterator(array[i]);
+    }
+  }
+  function isEmpty(obj) {
+    for (var i in obj) {
+      if (obj.hasOwnProperty(i)) return false;
+    }
+    return true;
+  }
+  function initParams(uri, options, callback) {
+    var params = uri;
+    if (isFunction(options)) {
+      callback = options;
+      if (typeof uri === "string") {
+        params = {
+          uri
+        };
+      }
+    } else {
+      params = _extends({}, options, {
+        uri
+      });
+    }
+    params.callback = callback;
+    return params;
+  }
+  function createXHR(uri, options, callback) {
+    options = initParams(uri, options, callback);
+    return _createXHR(options);
+  }
+  function _createXHR(options) {
+    if (typeof options.callback === "undefined") {
+      throw new Error("callback argument missing");
+    }
+    if (options.requestType && createXHR.requestInterceptorsStorage.getIsEnabled()) {
+      var requestInterceptorPayload = {
+        uri: options.uri || options.url,
+        headers: options.headers || {},
+        body: options.body,
+        metadata: options.metadata || {},
+        retry: options.retry,
+        timeout: options.timeout
+      };
+      var updatedPayload = createXHR.requestInterceptorsStorage.execute(options.requestType, requestInterceptorPayload);
+      options.uri = updatedPayload.uri;
+      options.headers = updatedPayload.headers;
+      options.body = updatedPayload.body;
+      options.metadata = updatedPayload.metadata;
+      options.retry = updatedPayload.retry;
+      options.timeout = updatedPayload.timeout;
+    }
+    var called = false;
+    var callback = function cbOnce(err, response, body2) {
+      if (!called) {
+        called = true;
+        options.callback(err, response, body2);
+      }
+    };
+    function readystatechange() {
+      if (xhr.readyState === 4 && !createXHR.responseInterceptorsStorage.getIsEnabled()) {
+        setTimeout(loadFunc, 0);
+      }
+    }
+    function getBody() {
+      var body2 = void 0;
+      if (xhr.response) {
+        body2 = xhr.response;
+      } else {
+        body2 = xhr.responseText || getXml(xhr);
+      }
+      if (isJson) {
+        try {
+          body2 = JSON.parse(body2);
+        } catch (e) {
+        }
+      }
+      return body2;
+    }
+    function errorFunc(evt) {
+      clearTimeout(timeoutTimer);
+      clearTimeout(options.retryTimeout);
+      if (!(evt instanceof Error)) {
+        evt = new Error("" + (evt || "Unknown XMLHttpRequest Error"));
+      }
+      evt.statusCode = 0;
+      if (!aborted && createXHR.retryManager.getIsEnabled() && options.retry && options.retry.shouldRetry()) {
+        options.retryTimeout = setTimeout(function() {
+          options.retry.moveToNextAttempt();
+          options.xhr = xhr;
+          _createXHR(options);
+        }, options.retry.getCurrentFuzzedDelay());
+        return;
+      }
+      if (options.requestType && createXHR.responseInterceptorsStorage.getIsEnabled()) {
+        var responseInterceptorPayload = {
+          headers: failureResponse.headers || {},
+          body: failureResponse.body,
+          responseUrl: xhr.responseURL,
+          responseType: xhr.responseType
+        };
+        var _updatedPayload = createXHR.responseInterceptorsStorage.execute(options.requestType, responseInterceptorPayload);
+        failureResponse.body = _updatedPayload.body;
+        failureResponse.headers = _updatedPayload.headers;
+      }
+      return callback(evt, failureResponse);
+    }
+    function loadFunc() {
+      if (aborted) return;
+      var status;
+      clearTimeout(timeoutTimer);
+      clearTimeout(options.retryTimeout);
+      if (options.useXDR && xhr.status === void 0) {
+        status = 200;
+      } else {
+        status = xhr.status === 1223 ? 204 : xhr.status;
+      }
+      var response = failureResponse;
+      var err = null;
+      if (status !== 0) {
+        response = {
+          body: getBody(),
+          statusCode: status,
+          method,
+          headers: {},
+          url: uri,
+          rawRequest: xhr
+        };
+        if (xhr.getAllResponseHeaders) {
+          response.headers = parseHeaders(xhr.getAllResponseHeaders());
+        }
+      } else {
+        err = new Error("Internal XMLHttpRequest Error");
+      }
+      if (options.requestType && createXHR.responseInterceptorsStorage.getIsEnabled()) {
+        var responseInterceptorPayload = {
+          headers: response.headers || {},
+          body: response.body,
+          responseUrl: xhr.responseURL,
+          responseType: xhr.responseType
+        };
+        var _updatedPayload2 = createXHR.responseInterceptorsStorage.execute(options.requestType, responseInterceptorPayload);
+        response.body = _updatedPayload2.body;
+        response.headers = _updatedPayload2.headers;
+      }
+      return callback(err, response, response.body);
+    }
+    var xhr = options.xhr || null;
+    if (!xhr) {
+      if (options.cors || options.useXDR) {
+        xhr = new createXHR.XDomainRequest();
+      } else {
+        xhr = new createXHR.XMLHttpRequest();
+      }
+    }
+    var key;
+    var aborted;
+    var uri = xhr.url = options.uri || options.url;
+    var method = xhr.method = options.method || "GET";
+    var body = options.body || options.data;
+    var headers = xhr.headers = options.headers || {};
+    var sync = !!options.sync;
+    var isJson = false;
+    var timeoutTimer;
+    var failureResponse = {
+      body: void 0,
+      headers: {},
+      statusCode: 0,
+      method,
+      url: uri,
+      rawRequest: xhr
+    };
+    if ("json" in options && options.json !== false) {
+      isJson = true;
+      headers["accept"] || headers["Accept"] || (headers["Accept"] = "application/json");
+      if (method !== "GET" && method !== "HEAD") {
+        headers["content-type"] || headers["Content-Type"] || (headers["Content-Type"] = "application/json");
+        body = JSON.stringify(options.json === true ? body : options.json);
+      }
+    }
+    xhr.onreadystatechange = readystatechange;
+    xhr.onload = loadFunc;
+    xhr.onerror = errorFunc;
+    xhr.onprogress = function() {
+    };
+    xhr.onabort = function() {
+      aborted = true;
+      clearTimeout(options.retryTimeout);
+    };
+    xhr.ontimeout = errorFunc;
+    xhr.open(method, uri, !sync, options.username, options.password);
+    if (!sync) {
+      xhr.withCredentials = !!options.withCredentials;
+    }
+    if (!sync && options.timeout > 0) {
+      timeoutTimer = setTimeout(function() {
+        if (aborted) return;
+        aborted = true;
+        xhr.abort("timeout");
+        var e = new Error("XMLHttpRequest timeout");
+        e.code = "ETIMEDOUT";
+        errorFunc(e);
+      }, options.timeout);
+    }
+    if (xhr.setRequestHeader) {
+      for (key in headers) {
+        if (headers.hasOwnProperty(key)) {
+          xhr.setRequestHeader(key, headers[key]);
+        }
+      }
+    } else if (options.headers && !isEmpty(options.headers)) {
+      throw new Error("Headers cannot be set on an XDomainRequest object");
+    }
+    if ("responseType" in options) {
+      xhr.responseType = options.responseType;
+    }
+    if ("beforeSend" in options && typeof options.beforeSend === "function") {
+      options.beforeSend(xhr);
+    }
+    xhr.send(body || null);
+    return xhr;
+  }
+  function getXml(xhr) {
+    try {
+      if (xhr.responseType === "document") {
+        return xhr.responseXML;
+      }
+      var firefoxBugTakenEffect = xhr.responseXML && xhr.responseXML.documentElement.nodeName === "parsererror";
+      if (xhr.responseType === "" && !firefoxBugTakenEffect) {
+        return xhr.responseXML;
+      }
+    } catch (e) {
+    }
+    return null;
+  }
+  function noop() {
+  }
+  return lib.exports;
+}
+export {
+  requireLib as __require
+};

package/dist/treeshaking/_virtual/@videojs/xhr/lib/index.js3.mjs

@@ -0,0 +1,4 @@
+var lib = { exports: {} };
+export {
+  lib as __module
+};