@lvce-editor/server 0.0.27 → 0.0.28

package/static/eb65b4e/static/js/ky.js

@@ -1,345 +0,0 @@
-class HTTPError extends Error {
-  constructor(response, request, options) {
-    const code = response.status || response.status === 0 ? response.status : "";
-    const title = response.statusText || "";
-    const status = `${code} ${title}`.trim();
-    const reason = status ? `status code ${status}` : "an unknown error";
-    super(`Request failed with ${reason}`);
-    this.name = "HTTPError";
-    this.response = response;
-    this.request = request;
-    this.options = options;
-  }
-}
-class TimeoutError extends Error {
-  constructor(request) {
-    super("Request timed out");
-    this.name = "TimeoutError";
-    this.request = request;
-  }
-}
-const isObject = (value) => value !== null && typeof value === "object";
-const validateAndMerge = (...sources) => {
-  for (const source of sources) {
-    if ((!isObject(source) || Array.isArray(source)) && typeof source !== "undefined") {
-      throw new TypeError("The `options` argument must be an object");
-    }
-  }
-  return deepMerge({}, ...sources);
-};
-const mergeHeaders = (source1 = {}, source2 = {}) => {
-  const result = new globalThis.Headers(source1);
-  const isHeadersInstance = source2 instanceof globalThis.Headers;
-  const source = new globalThis.Headers(source2);
-  for (const [key, value] of source.entries()) {
-    if (isHeadersInstance && value === "undefined" || value === void 0) {
-      result.delete(key);
-    } else {
-      result.set(key, value);
-    }
-  }
-  return result;
-};
-const deepMerge = (...sources) => {
-  let returnValue = {};
-  let headers = {};
-  for (const source of sources) {
-    if (Array.isArray(source)) {
-      if (!Array.isArray(returnValue)) {
-        returnValue = [];
-      }
-      returnValue = [...returnValue, ...source];
-    } else if (isObject(source)) {
-      for (let [key, value] of Object.entries(source)) {
-        if (isObject(value) && key in returnValue) {
-          value = deepMerge(returnValue[key], value);
-        }
-        returnValue = {...returnValue, [key]: value};
-      }
-      if (isObject(source.headers)) {
-        headers = mergeHeaders(headers, source.headers);
-        returnValue.headers = headers;
-      }
-    }
-  }
-  return returnValue;
-};
-const supportsAbortController = typeof globalThis.AbortController === "function";
-const supportsStreams = typeof globalThis.ReadableStream === "function";
-const supportsFormData = typeof globalThis.FormData === "function";
-const requestMethods = ["get", "post", "put", "patch", "head", "delete"];
-const responseTypes = {
-  json: "application/json",
-  text: "text/*",
-  formData: "multipart/form-data",
-  arrayBuffer: "*/*",
-  blob: "*/*"
-};
-const maxSafeTimeout = 2147483647;
-const stop = Symbol("stop");
-const normalizeRequestMethod = (input) => requestMethods.includes(input) ? input.toUpperCase() : input;
-const retryMethods = ["get", "put", "head", "delete", "options", "trace"];
-const retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
-const retryAfterStatusCodes = [413, 429, 503];
-const defaultRetryOptions = {
-  limit: 2,
-  methods: retryMethods,
-  statusCodes: retryStatusCodes,
-  afterStatusCodes: retryAfterStatusCodes,
-  maxRetryAfter: Number.POSITIVE_INFINITY
-};
-const normalizeRetryOptions = (retry = {}) => {
-  if (typeof retry === "number") {
-    return {
-      ...defaultRetryOptions,
-      limit: retry
-    };
-  }
-  if (retry.methods && !Array.isArray(retry.methods)) {
-    throw new Error("retry.methods must be an array");
-  }
-  if (retry.statusCodes && !Array.isArray(retry.statusCodes)) {
-    throw new Error("retry.statusCodes must be an array");
-  }
-  return {
-    ...defaultRetryOptions,
-    ...retry,
-    afterStatusCodes: retryAfterStatusCodes
-  };
-};
-const timeout = async (request, abortController, options) => new Promise((resolve, reject) => {
-  const timeoutId = setTimeout(() => {
-    if (abortController) {
-      abortController.abort();
-    }
-    reject(new TimeoutError(request));
-  }, options.timeout);
-  void options.fetch(request).then(resolve).catch(reject).then(() => {
-    clearTimeout(timeoutId);
-  });
-});
-const delay = async (ms) => new Promise((resolve) => {
-  setTimeout(resolve, ms);
-});
-class Ky {
-  constructor(input, options = {}) {
-    var _a, _b;
-    this._retryCount = 0;
-    this._input = input;
-    this._options = {
-      credentials: this._input.credentials || "same-origin",
-      ...options,
-      headers: mergeHeaders(this._input.headers, options.headers),
-      hooks: deepMerge({
-        beforeRequest: [],
-        beforeRetry: [],
-        afterResponse: []
-      }, options.hooks),
-      method: normalizeRequestMethod((_a = options.method) !== null && _a !== void 0 ? _a : this._input.method),
-      prefixUrl: String(options.prefixUrl || ""),
-      retry: normalizeRetryOptions(options.retry),
-      throwHttpErrors: options.throwHttpErrors !== false,
-      timeout: typeof options.timeout === "undefined" ? 1e4 : options.timeout,
-      fetch: (_b = options.fetch) !== null && _b !== void 0 ? _b : globalThis.fetch.bind(globalThis)
-    };
-    if (typeof this._input !== "string" && !(this._input instanceof URL || this._input instanceof globalThis.Request)) {
-      throw new TypeError("`input` must be a string, URL, or Request");
-    }
-    if (this._options.prefixUrl && typeof this._input === "string") {
-      if (this._input.startsWith("/")) {
-        throw new Error("`input` must not begin with a slash when using `prefixUrl`");
-      }
-      if (!this._options.prefixUrl.endsWith("/")) {
-        this._options.prefixUrl += "/";
-      }
-      this._input = this._options.prefixUrl + this._input;
-    }
-    if (supportsAbortController) {
-      this.abortController = new globalThis.AbortController();
-      if (this._options.signal) {
-        this._options.signal.addEventListener("abort", () => {
-          this.abortController.abort();
-        });
-      }
-      this._options.signal = this.abortController.signal;
-    }
-    this.request = new globalThis.Request(this._input, this._options);
-    if (this._options.searchParams) {
-      const textSearchParams = typeof this._options.searchParams === "string" ? this._options.searchParams.replace(/^\?/, "") : new URLSearchParams(this._options.searchParams).toString();
-      const searchParams = "?" + textSearchParams;
-      const url = this.request.url.replace(/(?:\?.*?)?(?=#|$)/, searchParams);
-      if ((supportsFormData && this._options.body instanceof globalThis.FormData || this._options.body instanceof URLSearchParams) && !(this._options.headers && this._options.headers["content-type"])) {
-        this.request.headers.delete("content-type");
-      }
-      this.request = new globalThis.Request(new globalThis.Request(url, this.request), this._options);
-    }
-    if (this._options.json !== void 0) {
-      this._options.body = JSON.stringify(this._options.json);
-      this.request.headers.set("content-type", "application/json");
-      this.request = new globalThis.Request(this.request, {body: this._options.body});
-    }
-  }
-  static create(input, options) {
-    const ky2 = new Ky(input, options);
-    const fn = async () => {
-      if (ky2._options.timeout > maxSafeTimeout) {
-        throw new RangeError(`The \`timeout\` option cannot be greater than ${maxSafeTimeout}`);
-      }
-      await Promise.resolve();
-      let response = await ky2._fetch();
-      for (const hook of ky2._options.hooks.afterResponse) {
-        const modifiedResponse = await hook(ky2.request, ky2._options, ky2._decorateResponse(response.clone()));
-        if (modifiedResponse instanceof globalThis.Response) {
-          response = modifiedResponse;
-        }
-      }
-      ky2._decorateResponse(response);
-      if (!response.ok && ky2._options.throwHttpErrors) {
-        throw new HTTPError(response, ky2.request, ky2._options);
-      }
-      if (ky2._options.onDownloadProgress) {
-        if (typeof ky2._options.onDownloadProgress !== "function") {
-          throw new TypeError("The `onDownloadProgress` option must be a function");
-        }
-        if (!supportsStreams) {
-          throw new Error("Streams are not supported in your environment. `ReadableStream` is missing.");
-        }
-        return ky2._stream(response.clone(), ky2._options.onDownloadProgress);
-      }
-      return response;
-    };
-    const isRetriableMethod = ky2._options.retry.methods.includes(ky2.request.method.toLowerCase());
-    const result = isRetriableMethod ? ky2._retry(fn) : fn();
-    for (const [type, mimeType] of Object.entries(responseTypes)) {
-      result[type] = async () => {
-        ky2.request.headers.set("accept", ky2.request.headers.get("accept") || mimeType);
-        const response = (await result).clone();
-        if (type === "json") {
-          if (response.status === 204) {
-            return "";
-          }
-          if (options.parseJson) {
-            return options.parseJson(await response.text());
-          }
-        }
-        return response[type]();
-      };
-    }
-    return result;
-  }
-  _calculateRetryDelay(error) {
-    this._retryCount++;
-    if (this._retryCount < this._options.retry.limit && !(error instanceof TimeoutError)) {
-      if (error instanceof HTTPError) {
-        if (!this._options.retry.statusCodes.includes(error.response.status)) {
-          return 0;
-        }
-        const retryAfter = error.response.headers.get("Retry-After");
-        if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
-          let after = Number(retryAfter);
-          if (Number.isNaN(after)) {
-            after = Date.parse(retryAfter) - Date.now();
-          } else {
-            after *= 1e3;
-          }
-          if (typeof this._options.retry.maxRetryAfter !== "undefined" && after > this._options.retry.maxRetryAfter) {
-            return 0;
-          }
-          return after;
-        }
-        if (error.response.status === 413) {
-          return 0;
-        }
-      }
-      const BACKOFF_FACTOR = 0.3;
-      return BACKOFF_FACTOR * 2 ** (this._retryCount - 1) * 1e3;
-    }
-    return 0;
-  }
-  _decorateResponse(response) {
-    if (this._options.parseJson) {
-      response.json = async () => this._options.parseJson(await response.text());
-    }
-    return response;
-  }
-  async _retry(fn) {
-    try {
-      return await fn();
-    } catch (error) {
-      const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
-      if (ms !== 0 && this._retryCount > 0) {
-        await delay(ms);
-        for (const hook of this._options.hooks.beforeRetry) {
-          const hookResult = await hook({
-            request: this.request,
-            options: this._options,
-            error,
-            retryCount: this._retryCount
-          });
-          if (hookResult === stop) {
-            return;
-          }
-        }
-        return this._retry(fn);
-      }
-      throw error;
-    }
-  }
-  async _fetch() {
-    for (const hook of this._options.hooks.beforeRequest) {
-      const result = await hook(this.request, this._options);
-      if (result instanceof Request) {
-        this.request = result;
-        break;
-      }
-      if (result instanceof Response) {
-        return result;
-      }
-    }
-    if (this._options.timeout === false) {
-      return this._options.fetch(this.request.clone());
-    }
-    return timeout(this.request.clone(), this.abortController, this._options);
-  }
-  _stream(response, onDownloadProgress) {
-    const totalBytes = Number(response.headers.get("content-length")) || 0;
-    let transferredBytes = 0;
-    return new globalThis.Response(new globalThis.ReadableStream({
-      async start(controller) {
-        const reader = response.body.getReader();
-        if (onDownloadProgress) {
-          onDownloadProgress({percent: 0, transferredBytes: 0, totalBytes}, new Uint8Array());
-        }
-        async function read() {
-          const {done, value} = await reader.read();
-          if (done) {
-            controller.close();
-            return;
-          }
-          if (onDownloadProgress) {
-            transferredBytes += value.byteLength;
-            const percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
-            onDownloadProgress({percent, transferredBytes, totalBytes}, value);
-          }
-          controller.enqueue(value);
-          await read();
-        }
-        await read();
-      }
-    }));
-  }
-}
-/*! MIT License © Sindre Sorhus */
-const createInstance = (defaults) => {
-  const ky2 = (input, options) => Ky.create(input, validateAndMerge(defaults, options));
-  for (const method of requestMethods) {
-    ky2[method] = (input, options) => Ky.create(input, validateAndMerge(defaults, options, {method}));
-  }
-  ky2.create = (newDefaults) => createInstance(validateAndMerge(newDefaults));
-  ky2.extend = (newDefaults) => createInstance(validateAndMerge(defaults, newDefaults));
-  ky2.stop = stop;
-  return ky2;
-};
-const ky = createInstance();
-export default ky;
-export {HTTPError, TimeoutError};

package/static/eb65b4e/static/js/pretty-bytes.js

@@ -1,88 +0,0 @@
-const BYTE_UNITS = [
-  "B",
-  "kB",
-  "MB",
-  "GB",
-  "TB",
-  "PB",
-  "EB",
-  "ZB",
-  "YB"
-];
-const BIBYTE_UNITS = [
-  "B",
-  "kiB",
-  "MiB",
-  "GiB",
-  "TiB",
-  "PiB",
-  "EiB",
-  "ZiB",
-  "YiB"
-];
-const BIT_UNITS = [
-  "b",
-  "kbit",
-  "Mbit",
-  "Gbit",
-  "Tbit",
-  "Pbit",
-  "Ebit",
-  "Zbit",
-  "Ybit"
-];
-const BIBIT_UNITS = [
-  "b",
-  "kibit",
-  "Mibit",
-  "Gibit",
-  "Tibit",
-  "Pibit",
-  "Eibit",
-  "Zibit",
-  "Yibit"
-];
-const toLocaleString = (number, locale, options) => {
-  let result = number;
-  if (typeof locale === "string" || Array.isArray(locale)) {
-    result = number.toLocaleString(locale, options);
-  } else if (locale === true || options !== void 0) {
-    result = number.toLocaleString(void 0, options);
-  }
-  return result;
-};
-var prettyBytes = (number, options) => {
-  if (!Number.isFinite(number)) {
-    throw new TypeError(`Expected a finite number, got ${typeof number}: ${number}`);
-  }
-  options = Object.assign({bits: false, binary: false}, options);
-  const UNITS = options.bits ? options.binary ? BIBIT_UNITS : BIT_UNITS : options.binary ? BIBYTE_UNITS : BYTE_UNITS;
-  if (options.signed && number === 0) {
-    return ` 0 ${UNITS[0]}`;
-  }
-  const isNegative = number < 0;
-  const prefix = isNegative ? "-" : options.signed ? "+" : "";
-  if (isNegative) {
-    number = -number;
-  }
-  let localeOptions;
-  if (options.minimumFractionDigits !== void 0) {
-    localeOptions = {minimumFractionDigits: options.minimumFractionDigits};
-  }
-  if (options.maximumFractionDigits !== void 0) {
-    localeOptions = Object.assign({maximumFractionDigits: options.maximumFractionDigits}, localeOptions);
-  }
-  if (number < 1) {
-    const numberString2 = toLocaleString(number, options.locale, localeOptions);
-    return prefix + numberString2 + " " + UNITS[0];
-  }
-  const exponent = Math.min(Math.floor(options.binary ? Math.log(number) / Math.log(1024) : Math.log10(number) / 3), UNITS.length - 1);
-  number /= Math.pow(options.binary ? 1024 : 1e3, exponent);
-  if (!localeOptions) {
-    number = number.toPrecision(3);
-  }
-  const numberString = toLocaleString(Number(number), options.locale, localeOptions);
-  const unit = UNITS[exponent];
-  return prefix + numberString + " " + unit;
-};
-export default prettyBytes;