@lvce-editor/server 0.0.2

package/static/1914fad/static/js/ky.js

@@ -0,0 +1,345 @@
+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/1914fad/static/js/p-min-delay.js

@@ -0,0 +1,9 @@
+import delay from "./yoctodelay.js";
+async function pMinDelay(promise, minimumDelay, {delayRejection = true} = {}) {
+  await Promise[delayRejection ? "allSettled" : "all"]([
+    promise,
+    delay(minimumDelay)
+  ]);
+  return promise;
+}
+export default pMinDelay;

package/static/1914fad/static/js/pretty-bytes.js

@@ -0,0 +1,88 @@
+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;