@quicktvui/ai 1.0.6 → 1.0.7

package/rules/.source/ESAxios/lib/helpers/composeSignals.js

@@ -0,0 +1,61 @@
+import CanceledError from "../cancel/CanceledError.js";
+import AxiosError from "../core/AxiosError.js";
+import utils from "../utils.js";
+
+const composeSignals = (signals, timeout) => {
+  const { length } = (signals = signals ? signals.filter(Boolean) : []);
+
+  if (timeout || length) {
+    let controller = new AbortController();
+
+    let aborted;
+
+    const onabort = function (reason) {
+      if (!aborted) {
+        aborted = true;
+        unsubscribe();
+        const err = reason instanceof Error ? reason : this.reason;
+        controller.abort(
+          err instanceof AxiosError
+            ? err
+            : new CanceledError(err instanceof Error ? err.message : err),
+        );
+      }
+    };
+
+    let timer =
+      timeout &&
+      setTimeout(() => {
+        timer = null;
+        onabort(
+          new AxiosError(
+            `timeout ${timeout} of ms exceeded`,
+            AxiosError.ETIMEDOUT,
+          ),
+        );
+      }, timeout);
+
+    const unsubscribe = () => {
+      if (signals) {
+        timer && clearTimeout(timer);
+        timer = null;
+        signals.forEach((signal) => {
+          signal.unsubscribe
+            ? signal.unsubscribe(onabort)
+            : signal.removeEventListener("abort", onabort);
+        });
+        signals = null;
+      }
+    };
+
+    signals.forEach((signal) => signal.addEventListener("abort", onabort));
+
+    const { signal } = controller;
+
+    signal.unsubscribe = () => utils.asap(unsubscribe);
+
+    return signal;
+  }
+};
+
+export default composeSignals;

package/rules/.source/ESAxios/lib/helpers/cookies.js

@@ -0,0 +1,40 @@
+import utils from "./../utils.js";
+import platform from "../platform/index.js";
+
+export default platform.hasStandardBrowserEnv
+  ? // Standard browser envs support document.cookie
+    {
+      write(name, value, expires, path, domain, secure) {
+        const cookie = [name + "=" + encodeURIComponent(value)];
+
+        utils.isNumber(expires) &&
+          cookie.push("expires=" + new Date(expires).toGMTString());
+
+        utils.isString(path) && cookie.push("path=" + path);
+
+        utils.isString(domain) && cookie.push("domain=" + domain);
+
+        secure === true && cookie.push("secure");
+
+        document.cookie = cookie.join("; ");
+      },
+
+      read(name) {
+        const match = document.cookie.match(
+          new RegExp("(^|;\\s*)(" + name + ")=([^;]*)"),
+        );
+        return match ? decodeURIComponent(match[3]) : null;
+      },
+
+      remove(name) {
+        this.write(name, "", Date.now() - 86400000);
+      },
+    }
+  : // Non-standard browser env (web workers, react-native) lack needed support.
+    {
+      write() {},
+      read() {
+        return null;
+      },
+      remove() {},
+    };

package/rules/.source/ESAxios/lib/helpers/deprecatedMethod.js

@@ -0,0 +1,31 @@
+"use strict";
+
+/*eslint no-console:0*/
+
+/**
+ * Supply a warning to the developer that a method they are using
+ * has been deprecated.
+ *
+ * @param {string} method The name of the deprecated method
+ * @param {string} [instead] The alternate method to use if applicable
+ * @param {string} [docs] The documentation URL to get further details
+ *
+ * @returns {void}
+ */
+export default function deprecatedMethod(method, instead, docs) {
+  try {
+    console.warn(
+      "DEPRECATED method `" +
+        method +
+        "`." +
+        (instead ? " Use `" + instead + "` instead." : "") +
+        " This method will be removed in a future release.",
+    );
+
+    if (docs) {
+      console.warn("For more information about usage see " + docs);
+    }
+  } catch (e) {
+    /* Ignore */
+  }
+}

package/rules/.source/ESAxios/lib/helpers/formDataToJSON.js

@@ -0,0 +1,95 @@
+"use strict";
+
+import utils from "../utils.js";
+
+/**
+ * It takes a string like `foo[x][y][z]` and returns an array like `['foo', 'x', 'y', 'z']
+ *
+ * @param {string} name - The name of the property to get.
+ *
+ * @returns An array of strings.
+ */
+function parsePropPath(name) {
+  // foo[x][y][z]
+  // foo.x.y.z
+  // foo-x-y-z
+  // foo x y z
+  return utils.matchAll(/\w+|\[(\w*)]/g, name).map((match) => {
+    return match[0] === "[]" ? "" : match[1] || match[0];
+  });
+}
+
+/**
+ * Convert an array to an object.
+ *
+ * @param {Array<any>} arr - The array to convert to an object.
+ *
+ * @returns An object with the same keys and values as the array.
+ */
+function arrayToObject(arr) {
+  const obj = {};
+  const keys = Object.keys(arr);
+  let i;
+  const len = keys.length;
+  let key;
+  for (i = 0; i < len; i++) {
+    key = keys[i];
+    obj[key] = arr[key];
+  }
+  return obj;
+}
+
+/**
+ * It takes a FormData object and returns a JavaScript object
+ *
+ * @param {string} formData The FormData object to convert to JSON.
+ *
+ * @returns {Object<string, any> | null} The converted object.
+ */
+function formDataToJSON(formData) {
+  function buildPath(path, value, target, index) {
+    let name = path[index++];
+
+    if (name === "__proto__") return true;
+
+    const isNumericKey = Number.isFinite(+name);
+    const isLast = index >= path.length;
+    name = !name && utils.isArray(target) ? target.length : name;
+
+    if (isLast) {
+      if (utils.hasOwnProp(target, name)) {
+        target[name] = [target[name], value];
+      } else {
+        target[name] = value;
+      }
+
+      return !isNumericKey;
+    }
+
+    if (!target[name] || !utils.isObject(target[name])) {
+      target[name] = [];
+    }
+
+    const result = buildPath(path, value, target[name], index);
+
+    if (result && utils.isArray(target[name])) {
+      target[name] = arrayToObject(target[name]);
+    }
+
+    return !isNumericKey;
+  }
+
+  if (utils.isFormData(formData) && utils.isFunction(formData.entries)) {
+    const obj = {};
+
+    utils.forEachEntry(formData, (name, value) => {
+      buildPath(parsePropPath(name), value, obj, 0);
+    });
+
+    return obj;
+  }
+
+  return null;
+}
+
+export default formDataToJSON;

package/rules/.source/ESAxios/lib/helpers/formDataToStream.js

@@ -0,0 +1,122 @@
+import util from "util";
+import { Readable } from "stream";
+import utils from "../utils.js";
+import readBlob from "./readBlob.js";
+
+const BOUNDARY_ALPHABET = utils.ALPHABET.ALPHA_DIGIT + "-_";
+
+const textEncoder =
+  typeof TextEncoder === "function"
+    ? new TextEncoder()
+    : new util.TextEncoder();
+
+const CRLF = "\r\n";
+const CRLF_BYTES = textEncoder.encode(CRLF);
+const CRLF_BYTES_COUNT = 2;
+
+class FormDataPart {
+  constructor(name, value) {
+    const { escapeName } = this.constructor;
+    const isStringValue = utils.isString(value);
+
+    let headers = `Content-Disposition: form-data; name="${escapeName(name)}"${
+      !isStringValue && value.name
+        ? `; filename="${escapeName(value.name)}"`
+        : ""
+    }${CRLF}`;
+
+    if (isStringValue) {
+      value = textEncoder.encode(String(value).replace(/\r?\n|\r\n?/g, CRLF));
+    } else {
+      headers += `Content-Type: ${value.type || "application/octet-stream"}${CRLF}`;
+    }
+
+    this.headers = textEncoder.encode(headers + CRLF);
+
+    this.contentLength = isStringValue ? value.byteLength : value.size;
+
+    this.size = this.headers.byteLength + this.contentLength + CRLF_BYTES_COUNT;
+
+    this.name = name;
+    this.value = value;
+  }
+
+  async *encode() {
+    yield this.headers;
+
+    const { value } = this;
+
+    if (utils.isTypedArray(value)) {
+      yield value;
+    } else {
+      yield* readBlob(value);
+    }
+
+    yield CRLF_BYTES;
+  }
+
+  static escapeName(name) {
+    return String(name).replace(
+      /[\r\n"]/g,
+      (match) =>
+        ({
+          "\r": "%0D",
+          "\n": "%0A",
+          '"': "%22",
+        })[match],
+    );
+  }
+}
+
+const formDataToStream = (form, headersHandler, options) => {
+  const {
+    tag = "form-data-boundary",
+    size = 25,
+    boundary = tag + "-" + utils.generateString(size, BOUNDARY_ALPHABET),
+  } = options || {};
+
+  if (!utils.isFormData(form)) {
+    throw TypeError("FormData instance required");
+  }
+
+  if (boundary.length < 1 || boundary.length > 70) {
+    throw Error("boundary must be 10-70 characters long");
+  }
+
+  const boundaryBytes = textEncoder.encode("--" + boundary + CRLF);
+  const footerBytes = textEncoder.encode("--" + boundary + "--" + CRLF + CRLF);
+  let contentLength = footerBytes.byteLength;
+
+  const parts = Array.from(form.entries()).map(([name, value]) => {
+    const part = new FormDataPart(name, value);
+    contentLength += part.size;
+    return part;
+  });
+
+  contentLength += boundaryBytes.byteLength * parts.length;
+
+  contentLength = utils.toFiniteNumber(contentLength);
+
+  const computedHeaders = {
+    "Content-Type": `multipart/form-data; boundary=${boundary}`,
+  };
+
+  if (Number.isFinite(contentLength)) {
+    computedHeaders["Content-Length"] = contentLength;
+  }
+
+  headersHandler && headersHandler(computedHeaders);
+
+  return Readable.from(
+    (async function* () {
+      for (const part of parts) {
+        yield boundaryBytes;
+        yield* part.encode();
+      }
+
+      yield footerBytes;
+    })(),
+  );
+};
+
+export default formDataToStream;

package/rules/.source/ESAxios/lib/helpers/fromDataURI.js

@@ -0,0 +1,62 @@
+"use strict";
+
+import AxiosError from "../core/AxiosError.js";
+import parseProtocol from "./parseProtocol.js";
+import platform from "../platform/index.js";
+
+const DATA_URL_PATTERN = /^(?:([^;]+);)?(?:[^;]+;)?(base64|),([\s\S]*)$/;
+
+/**
+ * Parse data uri to a Buffer or Blob
+ *
+ * @param {String} uri
+ * @param {?Boolean} asBlob
+ * @param {?Object} options
+ * @param {?Function} options.Blob
+ *
+ * @returns {Buffer|Blob}
+ */
+export default function fromDataURI(uri, asBlob, options) {
+  const _Blob = (options && options.Blob) || platform.classes.Blob;
+  const protocol = parseProtocol(uri);
+
+  if (asBlob === undefined && _Blob) {
+    asBlob = true;
+  }
+
+  if (protocol === "data") {
+    uri = protocol.length ? uri.slice(protocol.length + 1) : uri;
+
+    const match = DATA_URL_PATTERN.exec(uri);
+
+    if (!match) {
+      throw new AxiosError("Invalid URL", AxiosError.ERR_INVALID_URL);
+    }
+
+    const mime = match[1];
+    const isBase64 = match[2];
+    const body = match[3];
+    const buffer = Buffer.from(
+      decodeURIComponent(body),
+      isBase64 ? "base64" : "utf8",
+    );
+
+    if (asBlob) {
+      if (!_Blob) {
+        throw new AxiosError(
+          "Blob is not supported",
+          AxiosError.ERR_NOT_SUPPORT,
+        );
+      }
+
+      return new _Blob([buffer], { type: mime });
+    }
+
+    return buffer;
+  }
+
+  throw new AxiosError(
+    "Unsupported protocol " + protocol,
+    AxiosError.ERR_NOT_SUPPORT,
+  );
+}

package/rules/.source/ESAxios/lib/helpers/isAbsoluteURL.js

@@ -0,0 +1,15 @@
+"use strict";
+
+/**
+ * Determines whether the specified URL is absolute
+ *
+ * @param {string} url The URL to test
+ *
+ * @returns {boolean} True if the specified URL is absolute, otherwise false
+ */
+export default function isAbsoluteURL(url) {
+  // A URL is considered absolute if it begins with "<scheme>://" or "//" (protocol-relative URL).
+  // RFC 3986 defines scheme name as a sequence of characters beginning with a letter and followed
+  // by any combination of letters, digits, plus, period, or hyphen.
+  return /^([a-z][a-z\d+\-.]*:)?\/\//i.test(url);
+}

package/rules/.source/ESAxios/lib/helpers/isAxiosError.js

@@ -0,0 +1,14 @@
+"use strict";
+
+import utils from "./../utils.js";
+
+/**
+ * Determines whether the payload is an error thrown by Axios
+ *
+ * @param {*} payload The value to test
+ *
+ * @returns {boolean} True if the payload is an error thrown by Axios, otherwise false
+ */
+export default function isAxiosError(payload) {
+  return utils.isObject(payload) && payload.isAxiosError === true;
+}

package/rules/.source/ESAxios/lib/helpers/isURLSameOrigin.js

@@ -0,0 +1,17 @@
+import platform from "../platform/index.js";
+
+export default platform.hasStandardBrowserEnv
+  ? ((origin, isMSIE) => (url) => {
+      url = new URL(url, platform.origin);
+
+      return (
+        origin.protocol === url.protocol &&
+        origin.host === url.host &&
+        (isMSIE || origin.port === url.port)
+      );
+    })(
+      new URL(platform.origin),
+      platform.navigator &&
+        /(msie|trident)/i.test(platform.navigator.userAgent),
+    )
+  : () => true;

package/rules/.source/ESAxios/lib/helpers/null.js

@@ -0,0 +1,2 @@
+// eslint-disable-next-line strict
+export default null;

package/rules/.source/ESAxios/lib/helpers/parseHeaders.js

@@ -0,0 +1,69 @@
+"use strict";
+
+import utils from "./../utils.js";
+
+// RawAxiosHeaders whose duplicates are ignored by node
+// c.f. https://nodejs.org/api/http.html#http_message_headers
+const ignoreDuplicateOf = utils.toObjectSet([
+  "age",
+  "authorization",
+  "content-length",
+  "content-type",
+  "etag",
+  "expires",
+  "from",
+  "host",
+  "if-modified-since",
+  "if-unmodified-since",
+  "last-modified",
+  "location",
+  "max-forwards",
+  "proxy-authorization",
+  "referer",
+  "retry-after",
+  "user-agent",
+]);
+
+/**
+ * Parse headers into an object
+ *
+ * ```
+ * Date: Wed, 27 Aug 2014 08:58:49 GMT
+ * Content-Type: application/json
+ * Connection: keep-alive
+ * Transfer-Encoding: chunked
+ * ```
+ *
+ * @param {String} rawHeaders Headers needing to be parsed
+ *
+ * @returns {Object} Headers parsed into an object
+ */
+export default (rawHeaders) => {
+  const parsed = {};
+  let key;
+  let val;
+  let i;
+
+  rawHeaders &&
+    rawHeaders.split("\n").forEach(function parser(line) {
+      i = line.indexOf(":");
+      key = line.substring(0, i).trim().toLowerCase();
+      val = line.substring(i + 1).trim();
+
+      if (!key || (parsed[key] && ignoreDuplicateOf[key])) {
+        return;
+      }
+
+      if (key === "set-cookie") {
+        if (parsed[key]) {
+          parsed[key].push(val);
+        } else {
+          parsed[key] = [val];
+        }
+      } else {
+        parsed[key] = parsed[key] ? parsed[key] + ", " + val : val;
+      }
+    });
+
+  return parsed;
+};

package/rules/.source/ESAxios/lib/helpers/parseProtocol.js

@@ -0,0 +1,6 @@
+"use strict";
+
+export default function parseProtocol(url) {
+  const match = /^([-+\w]{1,25})(:?\/\/|:)/.exec(url);
+  return (match && match[1]) || "";
+}

package/rules/.source/ESAxios/lib/helpers/progressEventReducer.js

@@ -0,0 +1,51 @@
+import speedometer from "./speedometer.js";
+import throttle from "./throttle.js";
+import utils from "../utils.js";
+
+export const progressEventReducer = (listener, isDownloadStream, freq = 3) => {
+  let bytesNotified = 0;
+  const _speedometer = speedometer(50, 250);
+
+  return throttle((e) => {
+    const loaded = e.loaded;
+    const total = e.lengthComputable ? e.total : undefined;
+    const progressBytes = loaded - bytesNotified;
+    const rate = _speedometer(progressBytes);
+    const inRange = loaded <= total;
+
+    bytesNotified = loaded;
+
+    const data = {
+      loaded,
+      total,
+      progress: total ? loaded / total : undefined,
+      bytes: progressBytes,
+      rate: rate ? rate : undefined,
+      estimated: rate && total && inRange ? (total - loaded) / rate : undefined,
+      event: e,
+      lengthComputable: total != null,
+      [isDownloadStream ? "download" : "upload"]: true,
+    };
+
+    listener(data);
+  }, freq);
+};
+
+export const progressEventDecorator = (total, throttled) => {
+  const lengthComputable = total != null;
+
+  return [
+    (loaded) =>
+      throttled[0]({
+        lengthComputable,
+        total,
+        loaded,
+      }),
+    throttled[1],
+  ];
+};
+
+export const asyncDecorator =
+  (fn) =>
+  (...args) =>
+    utils.asap(() => fn(...args));

package/rules/.source/ESAxios/lib/helpers/readBlob.js

@@ -0,0 +1,15 @@
+const { asyncIterator } = Symbol;
+
+const readBlob = async function* (blob) {
+  if (blob.stream) {
+    yield* blob.stream();
+  } else if (blob.arrayBuffer) {
+    yield await blob.arrayBuffer();
+  } else if (blob[asyncIterator]) {
+    yield* blob[asyncIterator]();
+  } else {
+    yield blob;
+  }
+};
+
+export default readBlob;

package/rules/.source/ESAxios/lib/helpers/resolveConfig.js

@@ -0,0 +1,83 @@
+import platform from "../platform/index.js";
+import utils from "../utils.js";
+import isURLSameOrigin from "./isURLSameOrigin.js";
+import cookies from "./cookies.js";
+import buildFullPath from "../core/buildFullPath.js";
+import mergeConfig from "../core/mergeConfig.js";
+import AxiosHeaders from "../core/AxiosHeaders.js";
+import buildURL from "./buildURL.js";
+
+export default (config) => {
+  const newConfig = mergeConfig({}, config);
+
+  let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } =
+    newConfig;
+
+  newConfig.headers = headers = AxiosHeaders.from(headers);
+
+  newConfig.url = buildURL(
+    buildFullPath(newConfig.baseURL, newConfig.url),
+    config.params,
+    config.paramsSerializer,
+  );
+
+  // HTTP basic authentication
+  if (auth) {
+    headers.set(
+      "Authorization",
+      "Basic " +
+        btoa(
+          (auth.username || "") +
+            ":" +
+            (auth.password ? unescape(encodeURIComponent(auth.password)) : ""),
+        ),
+    );
+  }
+
+  let contentType;
+
+  if (utils.isFormData(data)) {
+    if (
+      platform.hasStandardBrowserEnv ||
+      platform.hasStandardBrowserWebWorkerEnv
+    ) {
+      headers.setContentType(undefined); // Let the browser set it
+    } else if ((contentType = headers.getContentType()) !== false) {
+      // fix semicolon duplication issue for ReactNative FormData implementation
+      const [type, ...tokens] = contentType
+        ? contentType
+            .split(";")
+            .map((token) => token.trim())
+            .filter(Boolean)
+        : [];
+      headers.setContentType(
+        [type || "multipart/form-data", ...tokens].join("; "),
+      );
+    }
+  }
+
+  // Add xsrf header
+  // This is only done if running in a standard browser environment.
+  // Specifically not if we're in a web worker, or react-native.
+
+  if (platform.hasStandardBrowserEnv) {
+    withXSRFToken &&
+      utils.isFunction(withXSRFToken) &&
+      (withXSRFToken = withXSRFToken(newConfig));
+
+    if (
+      withXSRFToken ||
+      (withXSRFToken !== false && isURLSameOrigin(newConfig.url))
+    ) {
+      // Add xsrf header
+      const xsrfValue =
+        xsrfHeaderName && xsrfCookieName && cookies.read(xsrfCookieName);
+
+      if (xsrfValue) {
+        headers.set(xsrfHeaderName, xsrfValue);
+      }
+    }
+  }
+
+  return newConfig;
+};