google-spreadsheet 4.1.5 → 5.0.1

package/dist/index.js

@@ -0,0 +1,4047 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// node_modules/.pnpm/ky@1.8.2/node_modules/ky/distribution/errors/HTTPError.js
+var HTTPError = class extends Error {
+  static {
+    __name(this, "HTTPError");
+  }
+  response;
+  request;
+  options;
+  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}: ${request.method} ${request.url}`);
+    this.name = "HTTPError";
+    this.response = response;
+    this.request = request;
+    this.options = options;
+  }
+};
+
+// node_modules/.pnpm/ky@1.8.2/node_modules/ky/distribution/errors/TimeoutError.js
+var TimeoutError = class extends Error {
+  static {
+    __name(this, "TimeoutError");
+  }
+  request;
+  constructor(request) {
+    super(`Request timed out: ${request.method} ${request.url}`);
+    this.name = "TimeoutError";
+    this.request = request;
+  }
+};
+
+// node_modules/.pnpm/ky@1.8.2/node_modules/ky/distribution/core/constants.js
+var supportsRequestStreams = (() => {
+  let duplexAccessed = false;
+  let hasContentType = false;
+  const supportsReadableStream = typeof globalThis.ReadableStream === "function";
+  const supportsRequest = typeof globalThis.Request === "function";
+  if (supportsReadableStream && supportsRequest) {
+    try {
+      hasContentType = new globalThis.Request("https://empty.invalid", {
+        body: new globalThis.ReadableStream(),
+        method: "POST",
+        // @ts-expect-error - Types are outdated.
+        get duplex() {
+          duplexAccessed = true;
+          return "half";
+        }
+      }).headers.has("Content-Type");
+    } catch (error) {
+      if (error instanceof Error && error.message === "unsupported BodyInit type") {
+        return false;
+      }
+      throw error;
+    }
+  }
+  return duplexAccessed && !hasContentType;
+})();
+var supportsAbortController = typeof globalThis.AbortController === "function";
+var supportsAbortSignal = typeof globalThis.AbortSignal === "function" && typeof globalThis.AbortSignal.any === "function";
+var supportsResponseStreams = typeof globalThis.ReadableStream === "function";
+var supportsFormData = typeof globalThis.FormData === "function";
+var requestMethods = ["get", "post", "put", "patch", "head", "delete"];
+var validate = /* @__PURE__ */ __name(() => void 0, "validate");
+validate();
+var responseTypes = {
+  json: "application/json",
+  text: "text/*",
+  formData: "multipart/form-data",
+  arrayBuffer: "*/*",
+  blob: "*/*"
+};
+var maxSafeTimeout = 2147483647;
+var usualFormBoundarySize = new TextEncoder().encode("------WebKitFormBoundaryaxpyiPgbbPti10Rw").length;
+var stop = Symbol("stop");
+var kyOptionKeys = {
+  json: true,
+  parseJson: true,
+  stringifyJson: true,
+  searchParams: true,
+  prefixUrl: true,
+  retry: true,
+  timeout: true,
+  hooks: true,
+  throwHttpErrors: true,
+  onDownloadProgress: true,
+  onUploadProgress: true,
+  fetch: true
+};
+var requestOptionsRegistry = {
+  method: true,
+  headers: true,
+  body: true,
+  mode: true,
+  credentials: true,
+  cache: true,
+  redirect: true,
+  referrer: true,
+  referrerPolicy: true,
+  integrity: true,
+  keepalive: true,
+  signal: true,
+  window: true,
+  dispatcher: true,
+  duplex: true,
+  priority: true
+};
+
+// node_modules/.pnpm/ky@1.8.2/node_modules/ky/distribution/utils/body.js
+var getBodySize = /* @__PURE__ */ __name((body) => {
+  if (!body) {
+    return 0;
+  }
+  if (body instanceof FormData) {
+    let size = 0;
+    for (const [key, value] of body) {
+      size += usualFormBoundarySize;
+      size += new TextEncoder().encode(`Content-Disposition: form-data; name="${key}"`).length;
+      size += typeof value === "string" ? new TextEncoder().encode(value).length : value.size;
+    }
+    return size;
+  }
+  if (body instanceof Blob) {
+    return body.size;
+  }
+  if (body instanceof ArrayBuffer) {
+    return body.byteLength;
+  }
+  if (typeof body === "string") {
+    return new TextEncoder().encode(body).length;
+  }
+  if (body instanceof URLSearchParams) {
+    return new TextEncoder().encode(body.toString()).length;
+  }
+  if ("byteLength" in body) {
+    return body.byteLength;
+  }
+  if (typeof body === "object" && body !== null) {
+    try {
+      const jsonString = JSON.stringify(body);
+      return new TextEncoder().encode(jsonString).length;
+    } catch {
+      return 0;
+    }
+  }
+  return 0;
+}, "getBodySize");
+var streamResponse = /* @__PURE__ */ __name((response, onDownloadProgress) => {
+  const totalBytes = Number(response.headers.get("content-length")) || 0;
+  let transferredBytes = 0;
+  if (response.status === 204) {
+    if (onDownloadProgress) {
+      onDownloadProgress({ percent: 1, totalBytes, transferredBytes }, new Uint8Array());
+    }
+    return new Response(null, {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers
+    });
+  }
+  return new Response(new 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();
+      }
+      __name(read, "read");
+      await read();
+    }
+  }), {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}, "streamResponse");
+var streamRequest = /* @__PURE__ */ __name((request, onUploadProgress) => {
+  const totalBytes = getBodySize(request.body);
+  let transferredBytes = 0;
+  return new Request(request, {
+    // @ts-expect-error - Types are outdated.
+    duplex: "half",
+    body: new ReadableStream({
+      async start(controller) {
+        const reader = request.body instanceof ReadableStream ? request.body.getReader() : new Response("").body.getReader();
+        async function read() {
+          const { done, value } = await reader.read();
+          if (done) {
+            if (onUploadProgress) {
+              onUploadProgress({ percent: 1, transferredBytes, totalBytes: Math.max(totalBytes, transferredBytes) }, new Uint8Array());
+            }
+            controller.close();
+            return;
+          }
+          transferredBytes += value.byteLength;
+          let percent = totalBytes === 0 ? 0 : transferredBytes / totalBytes;
+          if (totalBytes < transferredBytes || percent === 1) {
+            percent = 0.99;
+          }
+          if (onUploadProgress) {
+            onUploadProgress({ percent: Number(percent.toFixed(2)), transferredBytes, totalBytes }, value);
+          }
+          controller.enqueue(value);
+          await read();
+        }
+        __name(read, "read");
+        await read();
+      }
+    })
+  });
+}, "streamRequest");
+
+// node_modules/.pnpm/ky@1.8.2/node_modules/ky/distribution/utils/is.js
+var isObject = /* @__PURE__ */ __name((value) => value !== null && typeof value === "object", "isObject");
+
+// node_modules/.pnpm/ky@1.8.2/node_modules/ky/distribution/utils/merge.js
+var validateAndMerge = /* @__PURE__ */ __name((...sources) => {
+  for (const source of sources) {
+    if ((!isObject(source) || Array.isArray(source)) && source !== void 0) {
+      throw new TypeError("The `options` argument must be an object");
+    }
+  }
+  return deepMerge({}, ...sources);
+}, "validateAndMerge");
+var mergeHeaders = /* @__PURE__ */ __name((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;
+}, "mergeHeaders");
+function newHookValue(original, incoming, property2) {
+  return Object.hasOwn(incoming, property2) && incoming[property2] === void 0 ? [] : deepMerge(original[property2] ?? [], incoming[property2] ?? []);
+}
+__name(newHookValue, "newHookValue");
+var mergeHooks = /* @__PURE__ */ __name((original = {}, incoming = {}) => ({
+  beforeRequest: newHookValue(original, incoming, "beforeRequest"),
+  beforeRetry: newHookValue(original, incoming, "beforeRetry"),
+  afterResponse: newHookValue(original, incoming, "afterResponse"),
+  beforeError: newHookValue(original, incoming, "beforeError")
+}), "mergeHooks");
+var deepMerge = /* @__PURE__ */ __name((...sources) => {
+  let returnValue = {};
+  let headers = {};
+  let hooks = {};
+  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.hooks)) {
+        hooks = mergeHooks(hooks, source.hooks);
+        returnValue.hooks = hooks;
+      }
+      if (isObject(source.headers)) {
+        headers = mergeHeaders(headers, source.headers);
+        returnValue.headers = headers;
+      }
+    }
+  }
+  return returnValue;
+}, "deepMerge");
+
+// node_modules/.pnpm/ky@1.8.2/node_modules/ky/distribution/utils/normalize.js
+var normalizeRequestMethod = /* @__PURE__ */ __name((input) => requestMethods.includes(input) ? input.toUpperCase() : input, "normalizeRequestMethod");
+var retryMethods = ["get", "put", "head", "delete", "options", "trace"];
+var retryStatusCodes = [408, 413, 429, 500, 502, 503, 504];
+var retryAfterStatusCodes = [413, 429, 503];
+var defaultRetryOptions = {
+  limit: 2,
+  methods: retryMethods,
+  statusCodes: retryStatusCodes,
+  afterStatusCodes: retryAfterStatusCodes,
+  maxRetryAfter: Number.POSITIVE_INFINITY,
+  backoffLimit: Number.POSITIVE_INFINITY,
+  delay: /* @__PURE__ */ __name((attemptCount) => 0.3 * 2 ** (attemptCount - 1) * 1e3, "delay")
+};
+var normalizeRetryOptions = /* @__PURE__ */ __name((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
+  };
+}, "normalizeRetryOptions");
+
+// node_modules/.pnpm/ky@1.8.2/node_modules/ky/distribution/utils/timeout.js
+async function timeout(request, init, abortController, options) {
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      if (abortController) {
+        abortController.abort();
+      }
+      reject(new TimeoutError(request));
+    }, options.timeout);
+    void options.fetch(request, init).then(resolve).catch(reject).then(() => {
+      clearTimeout(timeoutId);
+    });
+  });
+}
+__name(timeout, "timeout");
+
+// node_modules/.pnpm/ky@1.8.2/node_modules/ky/distribution/utils/delay.js
+async function delay(ms, { signal }) {
+  return new Promise((resolve, reject) => {
+    if (signal) {
+      signal.throwIfAborted();
+      signal.addEventListener("abort", abortHandler, { once: true });
+    }
+    function abortHandler() {
+      clearTimeout(timeoutId);
+      reject(signal.reason);
+    }
+    __name(abortHandler, "abortHandler");
+    const timeoutId = setTimeout(() => {
+      signal?.removeEventListener("abort", abortHandler);
+      resolve();
+    }, ms);
+  });
+}
+__name(delay, "delay");
+
+// node_modules/.pnpm/ky@1.8.2/node_modules/ky/distribution/utils/options.js
+var findUnknownOptions = /* @__PURE__ */ __name((request, options) => {
+  const unknownOptions = {};
+  for (const key in options) {
+    if (!(key in requestOptionsRegistry) && !(key in kyOptionKeys) && !(key in request)) {
+      unknownOptions[key] = options[key];
+    }
+  }
+  return unknownOptions;
+}, "findUnknownOptions");
+
+// node_modules/.pnpm/ky@1.8.2/node_modules/ky/distribution/core/Ky.js
+var Ky = class _Ky {
+  static {
+    __name(this, "Ky");
+  }
+  static create(input, options) {
+    const ky2 = new _Ky(input, options);
+    const function_ = /* @__PURE__ */ __name(async () => {
+      if (typeof ky2._options.timeout === "number" && 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) {
+        let error = new HTTPError(response, ky2.request, ky2._options);
+        for (const hook of ky2._options.hooks.beforeError) {
+          error = await hook(error);
+        }
+        throw error;
+      }
+      if (ky2._options.onDownloadProgress) {
+        if (typeof ky2._options.onDownloadProgress !== "function") {
+          throw new TypeError("The `onDownloadProgress` option must be a function");
+        }
+        if (!supportsResponseStreams) {
+          throw new Error("Streams are not supported in your environment. `ReadableStream` is missing.");
+        }
+        return streamResponse(response.clone(), ky2._options.onDownloadProgress);
+      }
+      return response;
+    }, "function_");
+    const isRetriableMethod = ky2._options.retry.methods.includes(ky2.request.method.toLowerCase());
+    const result = (isRetriableMethod ? ky2._retry(function_) : function_()).finally(async () => {
+      if (!ky2.request.bodyUsed) {
+        await ky2.request.body?.cancel();
+      }
+    });
+    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;
+        if (type === "json") {
+          if (response.status === 204) {
+            return "";
+          }
+          const arrayBuffer = await response.clone().arrayBuffer();
+          const responseSize = arrayBuffer.byteLength;
+          if (responseSize === 0) {
+            return "";
+          }
+          if (options.parseJson) {
+            return options.parseJson(await response.text());
+          }
+        }
+        return response[type]();
+      };
+    }
+    return result;
+  }
+  request;
+  abortController;
+  _retryCount = 0;
+  _input;
+  _options;
+  // eslint-disable-next-line complexity
+  constructor(input, options = {}) {
+    this._input = input;
+    this._options = {
+      ...options,
+      headers: mergeHeaders(this._input.headers, options.headers),
+      hooks: mergeHooks({
+        beforeRequest: [],
+        beforeRetry: [],
+        beforeError: [],
+        afterResponse: []
+      }, options.hooks),
+      method: normalizeRequestMethod(options.method ?? this._input.method ?? "GET"),
+      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+      prefixUrl: String(options.prefixUrl || ""),
+      retry: normalizeRetryOptions(options.retry),
+      throwHttpErrors: options.throwHttpErrors !== false,
+      timeout: options.timeout ?? 1e4,
+      fetch: options.fetch ?? 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 && supportsAbortSignal) {
+      const originalSignal = this._options.signal ?? this._input.signal;
+      this.abortController = new globalThis.AbortController();
+      this._options.signal = originalSignal ? AbortSignal.any([originalSignal, this.abortController.signal]) : this.abortController.signal;
+    }
+    if (supportsRequestStreams) {
+      this._options.duplex = "half";
+    }
+    if (this._options.json !== void 0) {
+      this._options.body = this._options.stringifyJson?.(this._options.json) ?? JSON.stringify(this._options.json);
+      this._options.headers.set("content-type", this._options.headers.get("content-type") ?? "application/json");
+    }
+    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.onUploadProgress) {
+      if (typeof this._options.onUploadProgress !== "function") {
+        throw new TypeError("The `onUploadProgress` option must be a function");
+      }
+      if (!supportsRequestStreams) {
+        throw new Error("Request streams are not supported in your environment. The `duplex` option for `Request` is not available.");
+      }
+      const originalBody = this.request.body;
+      if (originalBody) {
+        this.request = streamRequest(this.request, this._options.onUploadProgress);
+      }
+    }
+  }
+  _calculateRetryDelay(error) {
+    this._retryCount++;
+    if (this._retryCount > this._options.retry.limit || error instanceof TimeoutError) {
+      throw error;
+    }
+    if (error instanceof HTTPError) {
+      if (!this._options.retry.statusCodes.includes(error.response.status)) {
+        throw error;
+      }
+      const retryAfter = error.response.headers.get("Retry-After") ?? error.response.headers.get("RateLimit-Reset") ?? error.response.headers.get("X-RateLimit-Reset") ?? error.response.headers.get("X-Rate-Limit-Reset");
+      if (retryAfter && this._options.retry.afterStatusCodes.includes(error.response.status)) {
+        let after = Number(retryAfter) * 1e3;
+        if (Number.isNaN(after)) {
+          after = Date.parse(retryAfter) - Date.now();
+        } else if (after >= Date.parse("2024-01-01")) {
+          after -= Date.now();
+        }
+        const max = this._options.retry.maxRetryAfter ?? after;
+        return after < max ? after : max;
+      }
+      if (error.response.status === 413) {
+        throw error;
+      }
+    }
+    const retryDelay = this._options.retry.delay(this._retryCount);
+    return Math.min(this._options.retry.backoffLimit, retryDelay);
+  }
+  _decorateResponse(response) {
+    if (this._options.parseJson) {
+      response.json = async () => this._options.parseJson(await response.text());
+    }
+    return response;
+  }
+  async _retry(function_) {
+    try {
+      return await function_();
+    } catch (error) {
+      const ms = Math.min(this._calculateRetryDelay(error), maxSafeTimeout);
+      if (this._retryCount < 1) {
+        throw error;
+      }
+      await delay(ms, { signal: this._options.signal });
+      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(function_);
+    }
+  }
+  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;
+      }
+    }
+    const nonRequestOptions = findUnknownOptions(this.request, this._options);
+    const mainRequest = this.request;
+    this.request = mainRequest.clone();
+    if (this._options.timeout === false) {
+      return this._options.fetch(mainRequest, nonRequestOptions);
+    }
+    return timeout(mainRequest, nonRequestOptions, this.abortController, this._options);
+  }
+};
+
+// node_modules/.pnpm/ky@1.8.2/node_modules/ky/distribution/index.js
+var createInstance = /* @__PURE__ */ __name((defaults) => {
+  const ky2 = /* @__PURE__ */ __name((input, options) => Ky.create(input, validateAndMerge(defaults, options)), "ky");
+  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) => {
+    if (typeof newDefaults === "function") {
+      newDefaults = newDefaults(defaults ?? {});
+    }
+    return createInstance(validateAndMerge(defaults, newDefaults));
+  };
+  ky2.stop = stop;
+  return ky2;
+}, "createInstance");
+var ky = createInstance();
+var distribution_default = ky;
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/predicate/isLength.mjs
+function isLength(value) {
+  return Number.isSafeInteger(value) && value >= 0;
+}
+__name(isLength, "isLength");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/isArrayLike.mjs
+function isArrayLike(value) {
+  return value != null && typeof value !== "function" && isLength(value.length);
+}
+__name(isArrayLike, "isArrayLike");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/array/compact.mjs
+function compact(arr) {
+  const result = [];
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    if (item) {
+      result.push(item);
+    }
+  }
+  return result;
+}
+__name(compact, "compact");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/array/compact.mjs
+function compact2(arr) {
+  if (!isArrayLike(arr)) {
+    return [];
+  }
+  return compact(Array.from(arr));
+}
+__name(compact2, "compact");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/array/flatten.mjs
+function flatten(arr, depth = 1) {
+  const result = [];
+  const flooredDepth = Math.floor(depth);
+  const recursive = /* @__PURE__ */ __name((arr2, currentDepth) => {
+    for (let i = 0; i < arr2.length; i++) {
+      const item = arr2[i];
+      if (Array.isArray(item) && currentDepth < flooredDepth) {
+        recursive(item, currentDepth + 1);
+      } else {
+        result.push(item);
+      }
+    }
+  }, "recursive");
+  recursive(arr, 0);
+  return result;
+}
+__name(flatten, "flatten");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/function/identity.mjs
+function identity(x) {
+  return x;
+}
+__name(identity, "identity");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/_internal/isUnsafeProperty.mjs
+function isUnsafeProperty(key) {
+  return key === "__proto__";
+}
+__name(isUnsafeProperty, "isUnsafeProperty");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/_internal/isDeepKey.mjs
+function isDeepKey(key) {
+  switch (typeof key) {
+    case "number":
+    case "symbol": {
+      return false;
+    }
+    case "string": {
+      return key.includes(".") || key.includes("[") || key.includes("]");
+    }
+  }
+}
+__name(isDeepKey, "isDeepKey");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/_internal/toKey.mjs
+function toKey(value) {
+  if (typeof value === "string" || typeof value === "symbol") {
+    return value;
+  }
+  if (Object.is(value?.valueOf?.(), -0)) {
+    return "-0";
+  }
+  return String(value);
+}
+__name(toKey, "toKey");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/util/toPath.mjs
+function toPath(deepKey) {
+  const result = [];
+  const length = deepKey.length;
+  if (length === 0) {
+    return result;
+  }
+  let index = 0;
+  let key = "";
+  let quoteChar = "";
+  let bracket = false;
+  if (deepKey.charCodeAt(0) === 46) {
+    result.push("");
+    index++;
+  }
+  while (index < length) {
+    const char = deepKey[index];
+    if (quoteChar) {
+      if (char === "\\" && index + 1 < length) {
+        index++;
+        key += deepKey[index];
+      } else if (char === quoteChar) {
+        quoteChar = "";
+      } else {
+        key += char;
+      }
+    } else if (bracket) {
+      if (char === '"' || char === "'") {
+        quoteChar = char;
+      } else if (char === "]") {
+        bracket = false;
+        result.push(key);
+        key = "";
+      } else {
+        key += char;
+      }
+    } else {
+      if (char === "[") {
+        bracket = true;
+        if (key) {
+          result.push(key);
+          key = "";
+        }
+      } else if (char === ".") {
+        if (key) {
+          result.push(key);
+          key = "";
+        }
+      } else {
+        key += char;
+      }
+    }
+    index++;
+  }
+  if (key) {
+    result.push(key);
+  }
+  return result;
+}
+__name(toPath, "toPath");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/object/get.mjs
+function get(object, path, defaultValue) {
+  if (object == null) {
+    return defaultValue;
+  }
+  switch (typeof path) {
+    case "string": {
+      if (isUnsafeProperty(path)) {
+        return defaultValue;
+      }
+      const result = object[path];
+      if (result === void 0) {
+        if (isDeepKey(path)) {
+          return get(object, toPath(path), defaultValue);
+        } else {
+          return defaultValue;
+        }
+      }
+      return result;
+    }
+    case "number":
+    case "symbol": {
+      if (typeof path === "number") {
+        path = toKey(path);
+      }
+      const result = object[path];
+      if (result === void 0) {
+        return defaultValue;
+      }
+      return result;
+    }
+    default: {
+      if (Array.isArray(path)) {
+        return getWithPath(object, path, defaultValue);
+      }
+      if (Object.is(path?.valueOf(), -0)) {
+        path = "-0";
+      } else {
+        path = String(path);
+      }
+      if (isUnsafeProperty(path)) {
+        return defaultValue;
+      }
+      const result = object[path];
+      if (result === void 0) {
+        return defaultValue;
+      }
+      return result;
+    }
+  }
+}
+__name(get, "get");
+function getWithPath(object, path, defaultValue) {
+  if (path.length === 0) {
+    return defaultValue;
+  }
+  let current = object;
+  for (let index = 0; index < path.length; index++) {
+    if (current == null) {
+      return defaultValue;
+    }
+    if (isUnsafeProperty(path[index])) {
+      return defaultValue;
+    }
+    current = current[path[index]];
+  }
+  if (current === void 0) {
+    return defaultValue;
+  }
+  return current;
+}
+__name(getWithPath, "getWithPath");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/object/property.mjs
+function property(path) {
+  return function(object) {
+    return get(object, path);
+  };
+}
+__name(property, "property");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/isObject.mjs
+function isObject2(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function");
+}
+__name(isObject2, "isObject");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/predicate/isPrimitive.mjs
+function isPrimitive(value) {
+  return value == null || typeof value !== "object" && typeof value !== "function";
+}
+__name(isPrimitive, "isPrimitive");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/util/eq.mjs
+function eq(value, other) {
+  return value === other || Number.isNaN(value) && Number.isNaN(other);
+}
+__name(eq, "eq");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/isMatchWith.mjs
+function isMatchWith(target, source, compare) {
+  if (typeof compare !== "function") {
+    return isMatch(target, source);
+  }
+  return isMatchWithInternal(target, source, /* @__PURE__ */ __name(function doesMatch(objValue, srcValue, key, object, source2, stack) {
+    const isEqual2 = compare(objValue, srcValue, key, object, source2, stack);
+    if (isEqual2 !== void 0) {
+      return Boolean(isEqual2);
+    }
+    return isMatchWithInternal(objValue, srcValue, doesMatch, stack);
+  }, "doesMatch"), /* @__PURE__ */ new Map());
+}
+__name(isMatchWith, "isMatchWith");
+function isMatchWithInternal(target, source, compare, stack) {
+  if (source === target) {
+    return true;
+  }
+  switch (typeof source) {
+    case "object": {
+      return isObjectMatch(target, source, compare, stack);
+    }
+    case "function": {
+      const sourceKeys = Object.keys(source);
+      if (sourceKeys.length > 0) {
+        return isMatchWithInternal(target, { ...source }, compare, stack);
+      }
+      return eq(target, source);
+    }
+    default: {
+      if (!isObject2(target)) {
+        return eq(target, source);
+      }
+      if (typeof source === "string") {
+        return source === "";
+      }
+      return true;
+    }
+  }
+}
+__name(isMatchWithInternal, "isMatchWithInternal");
+function isObjectMatch(target, source, compare, stack) {
+  if (source == null) {
+    return true;
+  }
+  if (Array.isArray(source)) {
+    return isArrayMatch(target, source, compare, stack);
+  }
+  if (source instanceof Map) {
+    return isMapMatch(target, source, compare, stack);
+  }
+  if (source instanceof Set) {
+    return isSetMatch(target, source, compare, stack);
+  }
+  const keys2 = Object.keys(source);
+  if (target == null) {
+    return keys2.length === 0;
+  }
+  if (keys2.length === 0) {
+    return true;
+  }
+  if (stack && stack.has(source)) {
+    return stack.get(source) === target;
+  }
+  if (stack) {
+    stack.set(source, target);
+  }
+  try {
+    for (let i = 0; i < keys2.length; i++) {
+      const key = keys2[i];
+      if (!isPrimitive(target) && !(key in target)) {
+        return false;
+      }
+      if (source[key] === void 0 && target[key] !== void 0) {
+        return false;
+      }
+      if (source[key] === null && target[key] !== null) {
+        return false;
+      }
+      const isEqual2 = compare(target[key], source[key], key, target, source, stack);
+      if (!isEqual2) {
+        return false;
+      }
+    }
+    return true;
+  } finally {
+    if (stack) {
+      stack.delete(source);
+    }
+  }
+}
+__name(isObjectMatch, "isObjectMatch");
+function isMapMatch(target, source, compare, stack) {
+  if (source.size === 0) {
+    return true;
+  }
+  if (!(target instanceof Map)) {
+    return false;
+  }
+  for (const [key, sourceValue] of source.entries()) {
+    const targetValue = target.get(key);
+    const isEqual2 = compare(targetValue, sourceValue, key, target, source, stack);
+    if (isEqual2 === false) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(isMapMatch, "isMapMatch");
+function isArrayMatch(target, source, compare, stack) {
+  if (source.length === 0) {
+    return true;
+  }
+  if (!Array.isArray(target)) {
+    return false;
+  }
+  const countedIndex = /* @__PURE__ */ new Set();
+  for (let i = 0; i < source.length; i++) {
+    const sourceItem = source[i];
+    let found = false;
+    for (let j = 0; j < target.length; j++) {
+      if (countedIndex.has(j)) {
+        continue;
+      }
+      const targetItem = target[j];
+      let matches2 = false;
+      const isEqual2 = compare(targetItem, sourceItem, i, target, source, stack);
+      if (isEqual2) {
+        matches2 = true;
+      }
+      if (matches2) {
+        countedIndex.add(j);
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(isArrayMatch, "isArrayMatch");
+function isSetMatch(target, source, compare, stack) {
+  if (source.size === 0) {
+    return true;
+  }
+  if (!(target instanceof Set)) {
+    return false;
+  }
+  return isArrayMatch([...target], [...source], compare, stack);
+}
+__name(isSetMatch, "isSetMatch");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/isMatch.mjs
+function isMatch(target, source) {
+  return isMatchWith(target, source, () => void 0);
+}
+__name(isMatch, "isMatch");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/_internal/getSymbols.mjs
+function getSymbols(object) {
+  return Object.getOwnPropertySymbols(object).filter((symbol) => Object.prototype.propertyIsEnumerable.call(object, symbol));
+}
+__name(getSymbols, "getSymbols");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/_internal/getTag.mjs
+function getTag(value) {
+  if (value == null) {
+    return value === void 0 ? "[object Undefined]" : "[object Null]";
+  }
+  return Object.prototype.toString.call(value);
+}
+__name(getTag, "getTag");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/_internal/tags.mjs
+var regexpTag = "[object RegExp]";
+var stringTag = "[object String]";
+var numberTag = "[object Number]";
+var booleanTag = "[object Boolean]";
+var argumentsTag = "[object Arguments]";
+var symbolTag = "[object Symbol]";
+var dateTag = "[object Date]";
+var mapTag = "[object Map]";
+var setTag = "[object Set]";
+var arrayTag = "[object Array]";
+var functionTag = "[object Function]";
+var arrayBufferTag = "[object ArrayBuffer]";
+var objectTag = "[object Object]";
+var errorTag = "[object Error]";
+var dataViewTag = "[object DataView]";
+var uint8ArrayTag = "[object Uint8Array]";
+var uint8ClampedArrayTag = "[object Uint8ClampedArray]";
+var uint16ArrayTag = "[object Uint16Array]";
+var uint32ArrayTag = "[object Uint32Array]";
+var bigUint64ArrayTag = "[object BigUint64Array]";
+var int8ArrayTag = "[object Int8Array]";
+var int16ArrayTag = "[object Int16Array]";
+var int32ArrayTag = "[object Int32Array]";
+var bigInt64ArrayTag = "[object BigInt64Array]";
+var float32ArrayTag = "[object Float32Array]";
+var float64ArrayTag = "[object Float64Array]";
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/predicate/isTypedArray.mjs
+function isTypedArray(x) {
+  return ArrayBuffer.isView(x) && !(x instanceof DataView);
+}
+__name(isTypedArray, "isTypedArray");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/object/cloneDeepWith.mjs
+function cloneDeepWith(obj, cloneValue) {
+  return cloneDeepWithImpl(obj, void 0, obj, /* @__PURE__ */ new Map(), cloneValue);
+}
+__name(cloneDeepWith, "cloneDeepWith");
+function cloneDeepWithImpl(valueToClone, keyToClone, objectToClone, stack = /* @__PURE__ */ new Map(), cloneValue = void 0) {
+  const cloned = cloneValue?.(valueToClone, keyToClone, objectToClone, stack);
+  if (cloned != null) {
+    return cloned;
+  }
+  if (isPrimitive(valueToClone)) {
+    return valueToClone;
+  }
+  if (stack.has(valueToClone)) {
+    return stack.get(valueToClone);
+  }
+  if (Array.isArray(valueToClone)) {
+    const result = new Array(valueToClone.length);
+    stack.set(valueToClone, result);
+    for (let i = 0; i < valueToClone.length; i++) {
+      result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+    }
+    if (Object.hasOwn(valueToClone, "index")) {
+      result.index = valueToClone.index;
+    }
+    if (Object.hasOwn(valueToClone, "input")) {
+      result.input = valueToClone.input;
+    }
+    return result;
+  }
+  if (valueToClone instanceof Date) {
+    return new Date(valueToClone.getTime());
+  }
+  if (valueToClone instanceof RegExp) {
+    const result = new RegExp(valueToClone.source, valueToClone.flags);
+    result.lastIndex = valueToClone.lastIndex;
+    return result;
+  }
+  if (valueToClone instanceof Map) {
+    const result = /* @__PURE__ */ new Map();
+    stack.set(valueToClone, result);
+    for (const [key, value] of valueToClone) {
+      result.set(key, cloneDeepWithImpl(value, key, objectToClone, stack, cloneValue));
+    }
+    return result;
+  }
+  if (valueToClone instanceof Set) {
+    const result = /* @__PURE__ */ new Set();
+    stack.set(valueToClone, result);
+    for (const value of valueToClone) {
+      result.add(cloneDeepWithImpl(value, void 0, objectToClone, stack, cloneValue));
+    }
+    return result;
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(valueToClone)) {
+    return valueToClone.subarray();
+  }
+  if (isTypedArray(valueToClone)) {
+    const result = new (Object.getPrototypeOf(valueToClone)).constructor(valueToClone.length);
+    stack.set(valueToClone, result);
+    for (let i = 0; i < valueToClone.length; i++) {
+      result[i] = cloneDeepWithImpl(valueToClone[i], i, objectToClone, stack, cloneValue);
+    }
+    return result;
+  }
+  if (valueToClone instanceof ArrayBuffer || typeof SharedArrayBuffer !== "undefined" && valueToClone instanceof SharedArrayBuffer) {
+    return valueToClone.slice(0);
+  }
+  if (valueToClone instanceof DataView) {
+    const result = new DataView(valueToClone.buffer.slice(0), valueToClone.byteOffset, valueToClone.byteLength);
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (typeof File !== "undefined" && valueToClone instanceof File) {
+    const result = new File([valueToClone], valueToClone.name, {
+      type: valueToClone.type
+    });
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof Blob) {
+    const result = new Blob([valueToClone], { type: valueToClone.type });
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (valueToClone instanceof Error) {
+    const result = new valueToClone.constructor();
+    stack.set(valueToClone, result);
+    result.message = valueToClone.message;
+    result.name = valueToClone.name;
+    result.stack = valueToClone.stack;
+    result.cause = valueToClone.cause;
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  if (typeof valueToClone === "object" && isCloneableObject(valueToClone)) {
+    const result = Object.create(Object.getPrototypeOf(valueToClone));
+    stack.set(valueToClone, result);
+    copyProperties(result, valueToClone, objectToClone, stack, cloneValue);
+    return result;
+  }
+  return valueToClone;
+}
+__name(cloneDeepWithImpl, "cloneDeepWithImpl");
+function copyProperties(target, source, objectToClone = target, stack, cloneValue) {
+  const keys2 = [...Object.keys(source), ...getSymbols(source)];
+  for (let i = 0; i < keys2.length; i++) {
+    const key = keys2[i];
+    const descriptor = Object.getOwnPropertyDescriptor(target, key);
+    if (descriptor == null || descriptor.writable) {
+      target[key] = cloneDeepWithImpl(source[key], key, objectToClone, stack, cloneValue);
+    }
+  }
+}
+__name(copyProperties, "copyProperties");
+function isCloneableObject(object) {
+  switch (getTag(object)) {
+    case argumentsTag:
+    case arrayTag:
+    case arrayBufferTag:
+    case dataViewTag:
+    case booleanTag:
+    case dateTag:
+    case float32ArrayTag:
+    case float64ArrayTag:
+    case int8ArrayTag:
+    case int16ArrayTag:
+    case int32ArrayTag:
+    case mapTag:
+    case numberTag:
+    case objectTag:
+    case regexpTag:
+    case setTag:
+    case stringTag:
+    case symbolTag:
+    case uint8ArrayTag:
+    case uint8ClampedArrayTag:
+    case uint16ArrayTag:
+    case uint32ArrayTag: {
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
+}
+__name(isCloneableObject, "isCloneableObject");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/object/cloneDeep.mjs
+function cloneDeep(obj) {
+  return cloneDeepWithImpl(obj, void 0, obj, /* @__PURE__ */ new Map(), void 0);
+}
+__name(cloneDeep, "cloneDeep");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/matches.mjs
+function matches(source) {
+  source = cloneDeep(source);
+  return (target) => {
+    return isMatch(target, source);
+  };
+}
+__name(matches, "matches");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/object/cloneDeepWith.mjs
+function cloneDeepWith2(obj, customizer) {
+  return cloneDeepWith(obj, (value, key, object, stack) => {
+    const cloned = customizer?.(value, key, object, stack);
+    if (cloned != null) {
+      return cloned;
+    }
+    if (typeof obj !== "object") {
+      return void 0;
+    }
+    switch (Object.prototype.toString.call(obj)) {
+      case numberTag:
+      case stringTag:
+      case booleanTag: {
+        const result = new obj.constructor(obj?.valueOf());
+        copyProperties(result, obj);
+        return result;
+      }
+      case argumentsTag: {
+        const result = {};
+        copyProperties(result, obj);
+        result.length = obj.length;
+        result[Symbol.iterator] = obj[Symbol.iterator];
+        return result;
+      }
+      default: {
+        return void 0;
+      }
+    }
+  });
+}
+__name(cloneDeepWith2, "cloneDeepWith");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/object/cloneDeep.mjs
+function cloneDeep2(obj) {
+  return cloneDeepWith2(obj);
+}
+__name(cloneDeep2, "cloneDeep");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/_internal/isIndex.mjs
+var IS_UNSIGNED_INTEGER = /^(?:0|[1-9]\d*)$/;
+function isIndex(value, length = Number.MAX_SAFE_INTEGER) {
+  switch (typeof value) {
+    case "number": {
+      return Number.isInteger(value) && value >= 0 && value < length;
+    }
+    case "symbol": {
+      return false;
+    }
+    case "string": {
+      return IS_UNSIGNED_INTEGER.test(value);
+    }
+  }
+}
+__name(isIndex, "isIndex");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/isArguments.mjs
+function isArguments(value) {
+  return value !== null && typeof value === "object" && getTag(value) === "[object Arguments]";
+}
+__name(isArguments, "isArguments");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/object/has.mjs
+function has(object, path) {
+  let resolvedPath;
+  if (Array.isArray(path)) {
+    resolvedPath = path;
+  } else if (typeof path === "string" && isDeepKey(path) && object?.[path] == null) {
+    resolvedPath = toPath(path);
+  } else {
+    resolvedPath = [path];
+  }
+  if (resolvedPath.length === 0) {
+    return false;
+  }
+  let current = object;
+  for (let i = 0; i < resolvedPath.length; i++) {
+    const key = resolvedPath[i];
+    if (current == null || !Object.hasOwn(current, key)) {
+      const isSparseIndex = (Array.isArray(current) || isArguments(current)) && isIndex(key) && key < current.length;
+      if (!isSparseIndex) {
+        return false;
+      }
+    }
+    current = current[key];
+  }
+  return true;
+}
+__name(has, "has");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/matchesProperty.mjs
+function matchesProperty(property2, source) {
+  switch (typeof property2) {
+    case "object": {
+      if (Object.is(property2?.valueOf(), -0)) {
+        property2 = "-0";
+      }
+      break;
+    }
+    case "number": {
+      property2 = toKey(property2);
+      break;
+    }
+  }
+  source = cloneDeep2(source);
+  return function(target) {
+    const result = get(target, property2);
+    if (result === void 0) {
+      return has(target, property2);
+    }
+    if (source === void 0) {
+      return result === void 0;
+    }
+    return isMatch(result, source);
+  };
+}
+__name(matchesProperty, "matchesProperty");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/util/iteratee.mjs
+function iteratee(value) {
+  if (value == null) {
+    return identity;
+  }
+  switch (typeof value) {
+    case "function": {
+      return value;
+    }
+    case "object": {
+      if (Array.isArray(value) && value.length === 2) {
+        return matchesProperty(value[0], value[1]);
+      }
+      return matches(value);
+    }
+    case "string":
+    case "symbol":
+    case "number": {
+      return property(value);
+    }
+  }
+}
+__name(iteratee, "iteratee");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/isObjectLike.mjs
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null;
+}
+__name(isObjectLike, "isObjectLike");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/isSymbol.mjs
+function isSymbol(value) {
+  return typeof value === "symbol" || value instanceof Symbol;
+}
+__name(isSymbol, "isSymbol");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/util/toNumber.mjs
+function toNumber(value) {
+  if (isSymbol(value)) {
+    return NaN;
+  }
+  return Number(value);
+}
+__name(toNumber, "toNumber");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/util/toFinite.mjs
+function toFinite(value) {
+  if (!value) {
+    return value === 0 ? value : 0;
+  }
+  value = toNumber(value);
+  if (value === Infinity || value === -Infinity) {
+    const sign = value < 0 ? -1 : 1;
+    return sign * Number.MAX_VALUE;
+  }
+  return value === value ? value : 0;
+}
+__name(toFinite, "toFinite");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/util/toInteger.mjs
+function toInteger(value) {
+  const finite = toFinite(value);
+  const remainder = finite % 1;
+  return remainder ? finite - remainder : finite;
+}
+__name(toInteger, "toInteger");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/math/range.mjs
+function range(start, end, step = 1) {
+  if (end == null) {
+    end = start;
+    start = 0;
+  }
+  if (!Number.isInteger(step) || step === 0) {
+    throw new Error(`The step value must be a non-zero integer.`);
+  }
+  const length = Math.max(Math.ceil((end - start) / step), 0);
+  const result = new Array(length);
+  for (let i = 0; i < length; i++) {
+    result[i] = start + i * step;
+  }
+  return result;
+}
+__name(range, "range");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/array/forEach.mjs
+function forEach(collection, callback = identity) {
+  if (!collection) {
+    return collection;
+  }
+  const keys2 = isArrayLike(collection) || Array.isArray(collection) ? range(0, collection.length) : Object.keys(collection);
+  for (let i = 0; i < keys2.length; i++) {
+    const key = keys2[i];
+    const value = collection[key];
+    const result = callback(value, key, collection);
+    if (result === false) {
+      break;
+    }
+  }
+  return collection;
+}
+__name(forEach, "forEach");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/_internal/isIterateeCall.mjs
+function isIterateeCall(value, index, object) {
+  if (!isObject2(object)) {
+    return false;
+  }
+  if (typeof index === "number" && isArrayLike(object) && isIndex(index) && index < object.length || typeof index === "string" && index in object) {
+    return eq(object[index], value);
+  }
+  return false;
+}
+__name(isIterateeCall, "isIterateeCall");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/isString.mjs
+function isString(value) {
+  return typeof value === "string" || value instanceof String;
+}
+__name(isString, "isString");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/array/filter.mjs
+function filter(source, predicate = identity) {
+  if (!source) {
+    return [];
+  }
+  predicate = iteratee(predicate);
+  if (!Array.isArray(source)) {
+    const result2 = [];
+    const keys2 = Object.keys(source);
+    const length2 = isArrayLike(source) ? source.length : keys2.length;
+    for (let i = 0; i < length2; i++) {
+      const key = keys2[i];
+      const value = source[key];
+      if (predicate(value, key, source)) {
+        result2.push(value);
+      }
+    }
+    return result2;
+  }
+  const result = [];
+  const length = source.length;
+  for (let i = 0; i < length; i++) {
+    const value = source[i];
+    if (predicate(value, i, source)) {
+      result.push(value);
+    }
+  }
+  return result;
+}
+__name(filter, "filter");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/array/find.mjs
+function find(source, _doesMatch = identity, fromIndex = 0) {
+  if (!source) {
+    return void 0;
+  }
+  if (fromIndex < 0) {
+    fromIndex = Math.max(source.length + fromIndex, 0);
+  }
+  const doesMatch = iteratee(_doesMatch);
+  if (typeof doesMatch === "function" && !Array.isArray(source)) {
+    const keys2 = Object.keys(source);
+    for (let i = fromIndex; i < keys2.length; i++) {
+      const key = keys2[i];
+      const value = source[key];
+      if (doesMatch(value, key, source)) {
+        return value;
+      }
+    }
+    return void 0;
+  }
+  const values2 = Array.isArray(source) ? source.slice(fromIndex) : Object.values(source).slice(fromIndex);
+  return values2.find(doesMatch);
+}
+__name(find, "find");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/array/flatten.mjs
+function flatten2(value, depth = 1) {
+  const result = [];
+  const flooredDepth = Math.floor(depth);
+  if (!isArrayLike(value)) {
+    return result;
+  }
+  const recursive = /* @__PURE__ */ __name((arr, currentDepth) => {
+    for (let i = 0; i < arr.length; i++) {
+      const item = arr[i];
+      if (currentDepth < flooredDepth && (Array.isArray(item) || Boolean(item?.[Symbol.isConcatSpreadable]) || item !== null && typeof item === "object" && Object.prototype.toString.call(item) === "[object Arguments]")) {
+        if (Array.isArray(item)) {
+          recursive(item, currentDepth + 1);
+        } else {
+          recursive(Array.from(item), currentDepth + 1);
+        }
+      } else {
+        result.push(item);
+      }
+    }
+  }, "recursive");
+  recursive(Array.from(value), 0);
+  return result;
+}
+__name(flatten2, "flatten");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/array/map.mjs
+function map(collection, _iteratee) {
+  if (!collection) {
+    return [];
+  }
+  const keys2 = isArrayLike(collection) || Array.isArray(collection) ? range(0, collection.length) : Object.keys(collection);
+  const iteratee$1 = iteratee(_iteratee ?? identity);
+  const result = new Array(keys2.length);
+  for (let i = 0; i < keys2.length; i++) {
+    const key = keys2[i];
+    const value = collection[key];
+    result[i] = iteratee$1(value, key, collection);
+  }
+  return result;
+}
+__name(map, "map");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/array/groupBy.mjs
+function groupBy(arr, getKeyFromItem) {
+  const result = {};
+  for (let i = 0; i < arr.length; i++) {
+    const item = arr[i];
+    const key = getKeyFromItem(item);
+    if (!Object.hasOwn(result, key)) {
+      result[key] = [];
+    }
+    result[key].push(item);
+  }
+  return result;
+}
+__name(groupBy, "groupBy");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/array/groupBy.mjs
+function groupBy2(source, _getKeyFromItem) {
+  if (source == null) {
+    return {};
+  }
+  const items = isArrayLike(source) ? Array.from(source) : Object.values(source);
+  const getKeyFromItem = iteratee(_getKeyFromItem ?? identity);
+  return groupBy(items, getKeyFromItem);
+}
+__name(groupBy2, "groupBy");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/array/reduce.mjs
+function reduce(collection, iteratee2 = identity, accumulator) {
+  if (!collection) {
+    return accumulator;
+  }
+  let keys2;
+  let startIndex = 0;
+  if (isArrayLike(collection)) {
+    keys2 = range(0, collection.length);
+    if (accumulator == null && collection.length > 0) {
+      accumulator = collection[0];
+      startIndex += 1;
+    }
+  } else {
+    keys2 = Object.keys(collection);
+    if (accumulator == null) {
+      accumulator = collection[keys2[0]];
+      startIndex += 1;
+    }
+  }
+  for (let i = startIndex; i < keys2.length; i++) {
+    const key = keys2[i];
+    const value = collection[key];
+    accumulator = iteratee2(accumulator, value, key, collection);
+  }
+  return accumulator;
+}
+__name(reduce, "reduce");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/array/keyBy.mjs
+function keyBy(collection, iteratee$1) {
+  if (!isArrayLike(collection) && !isObjectLike(collection)) {
+    return {};
+  }
+  const keyFn = iteratee(iteratee$1 ?? identity);
+  return reduce(collection, (result, value) => {
+    const key = keyFn(value);
+    result[key] = value;
+    return result;
+  }, {});
+}
+__name(keyBy, "keyBy");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/_internal/compareValues.mjs
+function getPriority(a) {
+  if (typeof a === "symbol") {
+    return 1;
+  }
+  if (a === null) {
+    return 2;
+  }
+  if (a === void 0) {
+    return 3;
+  }
+  if (a !== a) {
+    return 4;
+  }
+  return 0;
+}
+__name(getPriority, "getPriority");
+var compareValues = /* @__PURE__ */ __name((a, b, order) => {
+  if (a !== b) {
+    const aPriority = getPriority(a);
+    const bPriority = getPriority(b);
+    if (aPriority === bPriority && aPriority === 0) {
+      if (a < b) {
+        return order === "desc" ? 1 : -1;
+      }
+      if (a > b) {
+        return order === "desc" ? -1 : 1;
+      }
+    }
+    return order === "desc" ? bPriority - aPriority : aPriority - bPriority;
+  }
+  return 0;
+}, "compareValues");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/_internal/isKey.mjs
+var regexIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/;
+var regexIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+  if (Array.isArray(value)) {
+    return false;
+  }
+  if (typeof value === "number" || typeof value === "boolean" || value == null || isSymbol(value)) {
+    return true;
+  }
+  return typeof value === "string" && (regexIsPlainProp.test(value) || !regexIsDeepProp.test(value)) || object != null && Object.hasOwn(object, value);
+}
+__name(isKey, "isKey");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/array/orderBy.mjs
+function orderBy(collection, criteria, orders, guard) {
+  if (collection == null) {
+    return [];
+  }
+  orders = guard ? void 0 : orders;
+  if (!Array.isArray(collection)) {
+    collection = Object.values(collection);
+  }
+  if (!Array.isArray(criteria)) {
+    criteria = criteria == null ? [null] : [criteria];
+  }
+  if (criteria.length === 0) {
+    criteria = [null];
+  }
+  if (!Array.isArray(orders)) {
+    orders = orders == null ? [] : [orders];
+  }
+  orders = orders.map((order) => String(order));
+  const getValueByNestedPath = /* @__PURE__ */ __name((object, path) => {
+    let target = object;
+    for (let i = 0; i < path.length && target != null; ++i) {
+      target = target[path[i]];
+    }
+    return target;
+  }, "getValueByNestedPath");
+  const getValueByCriterion = /* @__PURE__ */ __name((criterion, object) => {
+    if (object == null || criterion == null) {
+      return object;
+    }
+    if (typeof criterion === "object" && "key" in criterion) {
+      if (Object.hasOwn(object, criterion.key)) {
+        return object[criterion.key];
+      }
+      return getValueByNestedPath(object, criterion.path);
+    }
+    if (typeof criterion === "function") {
+      return criterion(object);
+    }
+    if (Array.isArray(criterion)) {
+      return getValueByNestedPath(object, criterion);
+    }
+    if (typeof object === "object") {
+      return object[criterion];
+    }
+    return object;
+  }, "getValueByCriterion");
+  const preparedCriteria = criteria.map((criterion) => {
+    if (Array.isArray(criterion) && criterion.length === 1) {
+      criterion = criterion[0];
+    }
+    if (criterion == null || typeof criterion === "function" || Array.isArray(criterion) || isKey(criterion)) {
+      return criterion;
+    }
+    return { key: criterion, path: toPath(criterion) };
+  });
+  const preparedCollection = collection.map((item) => ({
+    original: item,
+    criteria: preparedCriteria.map((criterion) => getValueByCriterion(criterion, item))
+  }));
+  return preparedCollection.slice().sort((a, b) => {
+    for (let i = 0; i < preparedCriteria.length; i++) {
+      const comparedResult = compareValues(a.criteria[i], b.criteria[i], orders[i]);
+      if (comparedResult !== 0) {
+        return comparedResult;
+      }
+    }
+    return 0;
+  }).map((item) => item.original);
+}
+__name(orderBy, "orderBy");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/object/unset.mjs
+function unset(obj, path) {
+  if (obj == null) {
+    return true;
+  }
+  switch (typeof path) {
+    case "symbol":
+    case "number":
+    case "object": {
+      if (Array.isArray(path)) {
+        return unsetWithPath(obj, path);
+      }
+      if (typeof path === "number") {
+        path = toKey(path);
+      } else if (typeof path === "object") {
+        if (Object.is(path?.valueOf(), -0)) {
+          path = "-0";
+        } else {
+          path = String(path);
+        }
+      }
+      if (isUnsafeProperty(path)) {
+        return false;
+      }
+      if (obj?.[path] === void 0) {
+        return true;
+      }
+      try {
+        delete obj[path];
+        return true;
+      } catch {
+        return false;
+      }
+    }
+    case "string": {
+      if (obj?.[path] === void 0 && isDeepKey(path)) {
+        return unsetWithPath(obj, toPath(path));
+      }
+      if (isUnsafeProperty(path)) {
+        return false;
+      }
+      try {
+        delete obj[path];
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  }
+}
+__name(unset, "unset");
+function unsetWithPath(obj, path) {
+  const parent = get(obj, path.slice(0, -1), obj);
+  const lastKey = path[path.length - 1];
+  if (parent?.[lastKey] === void 0) {
+    return true;
+  }
+  if (isUnsafeProperty(lastKey)) {
+    return false;
+  }
+  try {
+    delete parent[lastKey];
+    return true;
+  } catch {
+    return false;
+  }
+}
+__name(unsetWithPath, "unsetWithPath");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/isArray.mjs
+function isArray(value) {
+  return Array.isArray(value);
+}
+__name(isArray, "isArray");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/object/values.mjs
+function values(object) {
+  if (object == null) {
+    return [];
+  }
+  return Object.values(object);
+}
+__name(values, "values");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/isNil.mjs
+function isNil(x) {
+  return x == null;
+}
+__name(isNil, "isNil");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/array/some.mjs
+function some(source, predicate, guard) {
+  if (!source) {
+    return false;
+  }
+  if (guard != null) {
+    predicate = void 0;
+  }
+  if (!predicate) {
+    predicate = identity;
+  }
+  const values2 = Array.isArray(source) ? source : Object.values(source);
+  switch (typeof predicate) {
+    case "function": {
+      if (!Array.isArray(source)) {
+        const keys2 = Object.keys(source);
+        for (let i = 0; i < keys2.length; i++) {
+          const key = keys2[i];
+          const value = source[key];
+          if (predicate(value, key, source)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      for (let i = 0; i < source.length; i++) {
+        if (predicate(source[i], i, source)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    case "object": {
+      if (Array.isArray(predicate) && predicate.length === 2) {
+        const key = predicate[0];
+        const value = predicate[1];
+        const matchFunc = matchesProperty(key, value);
+        if (Array.isArray(source)) {
+          for (let i = 0; i < source.length; i++) {
+            if (matchFunc(source[i])) {
+              return true;
+            }
+          }
+          return false;
+        }
+        return values2.some(matchFunc);
+      } else {
+        const matchFunc = matches(predicate);
+        if (Array.isArray(source)) {
+          for (let i = 0; i < source.length; i++) {
+            if (matchFunc(source[i])) {
+              return true;
+            }
+          }
+          return false;
+        }
+        return values2.some(matchFunc);
+      }
+    }
+    case "number":
+    case "symbol":
+    case "string": {
+      const propFunc = property(predicate);
+      if (Array.isArray(source)) {
+        for (let i = 0; i < source.length; i++) {
+          if (propFunc(source[i])) {
+            return true;
+          }
+        }
+        return false;
+      }
+      return values2.some(propFunc);
+    }
+  }
+}
+__name(some, "some");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/array/sortBy.mjs
+function sortBy(collection, ...criteria) {
+  const length = criteria.length;
+  if (length > 1 && isIterateeCall(collection, criteria[0], criteria[1])) {
+    criteria = [];
+  } else if (length > 2 && isIterateeCall(criteria[0], criteria[1], criteria[2])) {
+    criteria = [criteria[0]];
+  }
+  return orderBy(collection, flatten(criteria), ["asc"]);
+}
+__name(sortBy, "sortBy");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/function/identity.mjs
+function identity2(x) {
+  return x;
+}
+__name(identity2, "identity");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/_internal/assignValue.mjs
+var assignValue = /* @__PURE__ */ __name((object, key, value) => {
+  const objValue = object[key];
+  if (!(Object.hasOwn(object, key) && eq(objValue, value)) || value === void 0 && !(key in object)) {
+    object[key] = value;
+  }
+}, "assignValue");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/object/updateWith.mjs
+function updateWith(obj, path, updater, customizer) {
+  if (obj == null && !isObject2(obj)) {
+    return obj;
+  }
+  const resolvedPath = isKey(path, obj) ? [path] : Array.isArray(path) ? path : typeof path === "string" ? toPath(path) : [path];
+  let current = obj;
+  for (let i = 0; i < resolvedPath.length && current != null; i++) {
+    const key = toKey(resolvedPath[i]);
+    if (isUnsafeProperty(key)) {
+      continue;
+    }
+    let newValue;
+    if (i === resolvedPath.length - 1) {
+      newValue = updater(current[key]);
+    } else {
+      const objValue = current[key];
+      const customizerResult = customizer?.(objValue, key, obj);
+      newValue = customizerResult !== void 0 ? customizerResult : isObject2(objValue) ? objValue : isIndex(resolvedPath[i + 1]) ? [] : {};
+    }
+    assignValue(current, key, newValue);
+    current = current[key];
+  }
+  return obj;
+}
+__name(updateWith, "updateWith");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/object/set.mjs
+function set(obj, path, value) {
+  return updateWith(obj, path, () => value, () => void 0);
+}
+__name(set, "set");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/predicate/isPlainObject.mjs
+function isPlainObject(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const proto = Object.getPrototypeOf(value);
+  const hasObjectPrototype = proto === null || proto === Object.prototype || Object.getPrototypeOf(proto) === null;
+  if (!hasObjectPrototype) {
+    return false;
+  }
+  return Object.prototype.toString.call(value) === "[object Object]";
+}
+__name(isPlainObject, "isPlainObject");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/predicate/isEqualWith.mjs
+function isEqualWith(a, b, areValuesEqual) {
+  return isEqualWithImpl(a, b, void 0, void 0, void 0, void 0, areValuesEqual);
+}
+__name(isEqualWith, "isEqualWith");
+function isEqualWithImpl(a, b, property2, aParent, bParent, stack, areValuesEqual) {
+  const result = areValuesEqual(a, b, property2, aParent, bParent, stack);
+  if (result !== void 0) {
+    return result;
+  }
+  if (typeof a === typeof b) {
+    switch (typeof a) {
+      case "bigint":
+      case "string":
+      case "boolean":
+      case "symbol":
+      case "undefined": {
+        return a === b;
+      }
+      case "number": {
+        return a === b || Object.is(a, b);
+      }
+      case "function": {
+        return a === b;
+      }
+      case "object": {
+        return areObjectsEqual(a, b, stack, areValuesEqual);
+      }
+    }
+  }
+  return areObjectsEqual(a, b, stack, areValuesEqual);
+}
+__name(isEqualWithImpl, "isEqualWithImpl");
+function areObjectsEqual(a, b, stack, areValuesEqual) {
+  if (Object.is(a, b)) {
+    return true;
+  }
+  let aTag = getTag(a);
+  let bTag = getTag(b);
+  if (aTag === argumentsTag) {
+    aTag = objectTag;
+  }
+  if (bTag === argumentsTag) {
+    bTag = objectTag;
+  }
+  if (aTag !== bTag) {
+    return false;
+  }
+  switch (aTag) {
+    case stringTag:
+      return a.toString() === b.toString();
+    case numberTag: {
+      const x = a.valueOf();
+      const y = b.valueOf();
+      return eq(x, y);
+    }
+    case booleanTag:
+    case dateTag:
+    case symbolTag:
+      return Object.is(a.valueOf(), b.valueOf());
+    case regexpTag: {
+      return a.source === b.source && a.flags === b.flags;
+    }
+    case functionTag: {
+      return a === b;
+    }
+  }
+  stack = stack ?? /* @__PURE__ */ new Map();
+  const aStack = stack.get(a);
+  const bStack = stack.get(b);
+  if (aStack != null && bStack != null) {
+    return aStack === b;
+  }
+  stack.set(a, b);
+  stack.set(b, a);
+  try {
+    switch (aTag) {
+      case mapTag: {
+        if (a.size !== b.size) {
+          return false;
+        }
+        for (const [key, value] of a.entries()) {
+          if (!b.has(key) || !isEqualWithImpl(value, b.get(key), key, a, b, stack, areValuesEqual)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      case setTag: {
+        if (a.size !== b.size) {
+          return false;
+        }
+        const aValues = Array.from(a.values());
+        const bValues = Array.from(b.values());
+        for (let i = 0; i < aValues.length; i++) {
+          const aValue = aValues[i];
+          const index = bValues.findIndex((bValue) => {
+            return isEqualWithImpl(aValue, bValue, void 0, a, b, stack, areValuesEqual);
+          });
+          if (index === -1) {
+            return false;
+          }
+          bValues.splice(index, 1);
+        }
+        return true;
+      }
+      case arrayTag:
+      case uint8ArrayTag:
+      case uint8ClampedArrayTag:
+      case uint16ArrayTag:
+      case uint32ArrayTag:
+      case bigUint64ArrayTag:
+      case int8ArrayTag:
+      case int16ArrayTag:
+      case int32ArrayTag:
+      case bigInt64ArrayTag:
+      case float32ArrayTag:
+      case float64ArrayTag: {
+        if (typeof Buffer !== "undefined" && Buffer.isBuffer(a) !== Buffer.isBuffer(b)) {
+          return false;
+        }
+        if (a.length !== b.length) {
+          return false;
+        }
+        for (let i = 0; i < a.length; i++) {
+          if (!isEqualWithImpl(a[i], b[i], i, a, b, stack, areValuesEqual)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      case arrayBufferTag: {
+        if (a.byteLength !== b.byteLength) {
+          return false;
+        }
+        return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
+      }
+      case dataViewTag: {
+        if (a.byteLength !== b.byteLength || a.byteOffset !== b.byteOffset) {
+          return false;
+        }
+        return areObjectsEqual(new Uint8Array(a), new Uint8Array(b), stack, areValuesEqual);
+      }
+      case errorTag: {
+        return a.name === b.name && a.message === b.message;
+      }
+      case objectTag: {
+        const areEqualInstances = areObjectsEqual(a.constructor, b.constructor, stack, areValuesEqual) || isPlainObject(a) && isPlainObject(b);
+        if (!areEqualInstances) {
+          return false;
+        }
+        const aKeys = [...Object.keys(a), ...getSymbols(a)];
+        const bKeys = [...Object.keys(b), ...getSymbols(b)];
+        if (aKeys.length !== bKeys.length) {
+          return false;
+        }
+        for (let i = 0; i < aKeys.length; i++) {
+          const propKey = aKeys[i];
+          const aProp = a[propKey];
+          if (!Object.hasOwn(b, propKey)) {
+            return false;
+          }
+          const bProp = b[propKey];
+          if (!isEqualWithImpl(aProp, bProp, propKey, a, b, stack, areValuesEqual)) {
+            return false;
+          }
+        }
+        return true;
+      }
+      default: {
+        return false;
+      }
+    }
+  } finally {
+    stack.delete(a);
+    stack.delete(b);
+  }
+}
+__name(areObjectsEqual, "areObjectsEqual");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/function/noop.mjs
+function noop() {
+}
+__name(noop, "noop");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/predicate/isEqual.mjs
+function isEqual(a, b) {
+  return isEqualWith(a, b, noop);
+}
+__name(isEqual, "isEqual");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/predicate/isBuffer.mjs
+function isBuffer(x) {
+  return typeof Buffer !== "undefined" && Buffer.isBuffer(x);
+}
+__name(isBuffer, "isBuffer");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/_internal/isPrototype.mjs
+function isPrototype(value) {
+  const constructor = value?.constructor;
+  const prototype = typeof constructor === "function" ? constructor.prototype : Object.prototype;
+  return value === prototype;
+}
+__name(isPrototype, "isPrototype");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/isTypedArray.mjs
+function isTypedArray2(x) {
+  return isTypedArray(x);
+}
+__name(isTypedArray2, "isTypedArray");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/util/times.mjs
+function times(n, getValue) {
+  n = toInteger(n);
+  if (n < 1 || !Number.isSafeInteger(n)) {
+    return [];
+  }
+  const result = new Array(n);
+  for (let i = 0; i < n; i++) {
+    result[i] = typeof getValue === "function" ? getValue(i) : i;
+  }
+  return result;
+}
+__name(times, "times");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/object/keys.mjs
+function keys(object) {
+  if (isArrayLike(object)) {
+    return arrayLikeKeys(object);
+  }
+  const result = Object.keys(Object(object));
+  if (!isPrototype(object)) {
+    return result;
+  }
+  return result.filter((key) => key !== "constructor");
+}
+__name(keys, "keys");
+function arrayLikeKeys(object) {
+  const indices = times(object.length, (index) => `${index}`);
+  const filteredKeys = new Set(indices);
+  if (isBuffer(object)) {
+    filteredKeys.add("offset");
+    filteredKeys.add("parent");
+  }
+  if (isTypedArray2(object)) {
+    filteredKeys.add("buffer");
+    filteredKeys.add("byteLength");
+    filteredKeys.add("byteOffset");
+  }
+  return [...indices, ...Object.keys(object).filter((key) => !filteredKeys.has(key))];
+}
+__name(arrayLikeKeys, "arrayLikeKeys");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/object/keysIn.mjs
+function keysIn(object) {
+  if (object == null) {
+    return [];
+  }
+  switch (typeof object) {
+    case "object":
+    case "function": {
+      if (isArrayLike(object)) {
+        return arrayLikeKeysIn(object);
+      }
+      if (isPrototype(object)) {
+        return prototypeKeysIn(object);
+      }
+      return keysInImpl(object);
+    }
+    default: {
+      return keysInImpl(Object(object));
+    }
+  }
+}
+__name(keysIn, "keysIn");
+function keysInImpl(object) {
+  const result = [];
+  for (const key in object) {
+    result.push(key);
+  }
+  return result;
+}
+__name(keysInImpl, "keysInImpl");
+function prototypeKeysIn(object) {
+  const keys2 = keysInImpl(object);
+  return keys2.filter((key) => key !== "constructor");
+}
+__name(prototypeKeysIn, "prototypeKeysIn");
+function arrayLikeKeysIn(object) {
+  const indices = times(object.length, (index) => `${index}`);
+  const filteredKeys = new Set(indices);
+  if (isBuffer(object)) {
+    filteredKeys.add("offset");
+    filteredKeys.add("parent");
+  }
+  if (isTypedArray2(object)) {
+    filteredKeys.add("buffer");
+    filteredKeys.add("byteLength");
+    filteredKeys.add("byteOffset");
+  }
+  return [...indices, ...keysInImpl(object).filter((key) => !filteredKeys.has(key))];
+}
+__name(arrayLikeKeysIn, "arrayLikeKeysIn");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/object/omit.mjs
+function omit(obj, ...keysArr) {
+  if (obj == null) {
+    return {};
+  }
+  const result = cloneDeep(obj);
+  for (let i = 0; i < keysArr.length; i++) {
+    let keys2 = keysArr[i];
+    switch (typeof keys2) {
+      case "object": {
+        if (!Array.isArray(keys2)) {
+          keys2 = Array.from(keys2);
+        }
+        for (let j = 0; j < keys2.length; j++) {
+          const key = keys2[j];
+          unset(result, key);
+        }
+        break;
+      }
+      case "string":
+      case "symbol":
+      case "number": {
+        unset(result, keys2);
+        break;
+      }
+    }
+  }
+  return result;
+}
+__name(omit, "omit");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/_internal/getSymbolsIn.mjs
+function getSymbolsIn(object) {
+  const result = [];
+  while (object) {
+    result.push(...getSymbols(object));
+    object = Object.getPrototypeOf(object);
+  }
+  return result;
+}
+__name(getSymbolsIn, "getSymbolsIn");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/object/pickBy.mjs
+function pickBy(obj, shouldPick) {
+  if (obj == null) {
+    return {};
+  }
+  const predicate = iteratee(shouldPick ?? identity2);
+  const result = {};
+  const keys2 = isArrayLike(obj) ? range(0, obj.length) : [...keysIn(obj), ...getSymbolsIn(obj)];
+  for (let i = 0; i < keys2.length; i++) {
+    const key = isSymbol(keys2[i]) ? keys2[i] : keys2[i].toString();
+    const value = obj[key];
+    if (predicate(value, key, obj)) {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+__name(pickBy, "pickBy");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/isBoolean.mjs
+function isBoolean(value) {
+  return typeof value === "boolean" || value instanceof Boolean;
+}
+__name(isBoolean, "isBoolean");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/isFinite.mjs
+function isFinite(value) {
+  return Number.isFinite(value);
+}
+__name(isFinite, "isFinite");
+
+// node_modules/.pnpm/es-toolkit@1.39.8/node_modules/es-toolkit/dist/compat/predicate/isInteger.mjs
+function isInteger(value) {
+  return Number.isInteger(value);
+}
+__name(isInteger, "isInteger");
+
+// src/lib/utils.ts
+function getFieldMask(obj) {
+  let fromGrid = "";
+  const fromRoot = Object.keys(obj).filter((key) => key !== "gridProperties").join(",");
+  if (obj.gridProperties) {
+    fromGrid = Object.keys(obj.gridProperties).map((key) => `gridProperties.${key}`).join(",");
+    if (fromGrid.length && fromRoot.length) {
+      fromGrid = `${fromGrid},`;
+    }
+  }
+  return fromGrid + fromRoot;
+}
+__name(getFieldMask, "getFieldMask");
+function columnToLetter(column) {
+  let temp;
+  let letter = "";
+  let col = column;
+  while (col > 0) {
+    temp = (col - 1) % 26;
+    letter = String.fromCharCode(temp + 65) + letter;
+    col = (col - temp - 1) / 26;
+  }
+  return letter;
+}
+__name(columnToLetter, "columnToLetter");
+function letterToColumn(letter) {
+  let column = 0;
+  const { length } = letter;
+  for (let i = 0; i < length; i++) {
+    column += (letter.charCodeAt(i) - 64) * 26 ** (length - i - 1);
+  }
+  return column;
+}
+__name(letterToColumn, "letterToColumn");
+function checkForDuplicateHeaders(headers) {
+  const checkForDupes = groupBy2(headers);
+  forEach(checkForDupes, (grouped, header) => {
+    if (!header) return;
+    if (grouped.length > 1) {
+      throw new Error(`Duplicate header detected: "${header}". Please make sure all non-empty headers are unique`);
+    }
+  });
+}
+__name(checkForDuplicateHeaders, "checkForDuplicateHeaders");
+
+// src/lib/GoogleSpreadsheetRow.ts
+var GoogleSpreadsheetRow = class {
+  constructor(_worksheet, _rowNumber, _rawData) {
+    this._worksheet = _worksheet;
+    this._rowNumber = _rowNumber;
+    this._rawData = _rawData;
+  }
+  static {
+    __name(this, "GoogleSpreadsheetRow");
+  }
+  _deleted = false;
+  get deleted() {
+    return this._deleted;
+  }
+  /** row number (matches A1 notation, ie first row is 1) */
+  get rowNumber() {
+    return this._rowNumber;
+  }
+  /**
+   * @internal
+   * Used internally to update row numbers after deleting rows.
+   * Should not be called directly.
+  */
+  _updateRowNumber(newRowNumber) {
+    this._rowNumber = newRowNumber;
+  }
+  get a1Range() {
+    return [
+      this._worksheet.a1SheetName,
+      "!",
+      `A${this._rowNumber}`,
+      ":",
+      `${columnToLetter(this._worksheet.headerValues.length)}${this._rowNumber}`
+    ].join("");
+  }
+  /** get row's value of specific cell (by header key) */
+  get(key) {
+    const index = this._worksheet.headerValues.indexOf(key);
+    return this._rawData[index];
+  }
+  /** set row's value of specific cell (by header key) */
+  set(key, val) {
+    const index = this._worksheet.headerValues.indexOf(key);
+    this._rawData[index] = val;
+  }
+  /** set multiple values in the row at once from an object */
+  assign(obj) {
+    for (const key in obj) this.set(key, obj[key]);
+  }
+  /** return raw object of row data */
+  toObject() {
+    const o = {};
+    for (let i = 0; i < this._worksheet.headerValues.length; i++) {
+      const key = this._worksheet.headerValues[i];
+      if (!key) continue;
+      o[key] = this._rawData[i];
+    }
+    return o;
+  }
+  /** save row values */
+  async save(options) {
+    if (this._deleted) throw new Error("This row has been deleted - call getRows again before making updates.");
+    const response = await this._worksheet._spreadsheet.sheetsApi.put(`values/${encodeURIComponent(this.a1Range)}`, {
+      searchParams: {
+        valueInputOption: options?.raw ? "RAW" : "USER_ENTERED",
+        includeValuesInResponse: true
+      },
+      json: {
+        range: this.a1Range,
+        majorDimension: "ROWS",
+        values: [this._rawData]
+      }
+    });
+    const data = await response.json();
+    this._rawData = data.updatedData.values[0];
+  }
+  /** delete this row */
+  async delete() {
+    if (this._deleted) throw new Error("This row has been deleted - call getRows again before making updates.");
+    const result = await this._worksheet._makeSingleUpdateRequest("deleteRange", {
+      range: {
+        sheetId: this._worksheet.sheetId,
+        startRowIndex: this._rowNumber - 1,
+        // this format is zero indexed, because of course...
+        endRowIndex: this._rowNumber
+      },
+      shiftDimension: "ROWS"
+    });
+    this._deleted = true;
+    this._worksheet._shiftRowCache(this.rowNumber);
+    return result;
+  }
+  /**
+   * @internal
+   * Used internally to clear row data after calling sheet.clearRows
+   * Should not be called directly.
+  */
+  _clearRowData() {
+    for (let i = 0; i < this._rawData.length; i++) {
+      this._rawData[i] = "";
+    }
+  }
+};
+
+// src/lib/GoogleSpreadsheetCellErrorValue.ts
+var GoogleSpreadsheetCellErrorValue = class {
+  static {
+    __name(this, "GoogleSpreadsheetCellErrorValue");
+  }
+  /**
+   * type of the error
+   * @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/other#ErrorType
+   * */
+  type;
+  /** A message with more information about the error (in the spreadsheet's locale) */
+  message;
+  constructor(rawError) {
+    this.type = rawError.type;
+    this.message = rawError.message;
+  }
+};
+
+// src/lib/GoogleSpreadsheetCell.ts
+var GoogleSpreadsheetCell = class {
+  constructor(_sheet, _rowIndex, _columnIndex, rawCellData) {
+    this._sheet = _sheet;
+    this._rowIndex = _rowIndex;
+    this._columnIndex = _columnIndex;
+    this._updateRawData(rawCellData);
+    this._rawData = rawCellData;
+  }
+  static {
+    __name(this, "GoogleSpreadsheetCell");
+  }
+  _rawData;
+  _draftData = {};
+  _error;
+  // TODO: figure out how to deal with empty rawData
+  // newData can be undefined/null if the cell is totally empty and unformatted
+  /**
+   * update cell using raw CellData coming back from sheets API
+   * @internal
+   */
+  _updateRawData(newData) {
+    this._rawData = newData;
+    this._draftData = {};
+    if (this._rawData?.effectiveValue && "errorValue" in this._rawData.effectiveValue) {
+      this._error = new GoogleSpreadsheetCellErrorValue(this._rawData.effectiveValue.errorValue);
+    } else {
+      this._error = void 0;
+    }
+  }
+  // CELL LOCATION/ADDRESS /////////////////////////////////////////////////////////////////////////
+  get rowIndex() {
+    return this._rowIndex;
+  }
+  get columnIndex() {
+    return this._columnIndex;
+  }
+  get a1Column() {
+    return columnToLetter(this._columnIndex + 1);
+  }
+  get a1Row() {
+    return this._rowIndex + 1;
+  }
+  // a1 row numbers start at 1 instead of 0
+  get a1Address() {
+    return `${this.a1Column}${this.a1Row}`;
+  }
+  // CELL CONTENTS - VALUE/FORMULA/NOTES ///////////////////////////////////////////////////////////
+  get value() {
+    if (this._draftData.value !== void 0) throw new Error("Value has been changed");
+    if (this._error) return this._error;
+    if (!this._rawData?.effectiveValue) return null;
+    return values(this._rawData.effectiveValue)[0];
+  }
+  set value(newValue) {
+    if (newValue instanceof GoogleSpreadsheetCellErrorValue) {
+      throw new Error("You can't manually set a value to an error");
+    }
+    if (isBoolean(newValue)) {
+      this._draftData.valueType = "boolValue";
+    } else if (isString(newValue)) {
+      if (newValue.substring(0, 1) === "=") this._draftData.valueType = "formulaValue";
+      else this._draftData.valueType = "stringValue";
+    } else if (isFinite(newValue)) {
+      this._draftData.valueType = "numberValue";
+    } else if (isNil(newValue)) {
+      this._draftData.valueType = "stringValue";
+      newValue = "";
+    } else {
+      throw new Error("Set value to boolean, string, or number");
+    }
+    this._draftData.value = newValue;
+  }
+  get valueType() {
+    if (this._error) return "errorValue";
+    if (!this._rawData?.effectiveValue) return null;
+    return keys(this._rawData.effectiveValue)[0];
+  }
+  /** The formatted value of the cell - this is the value as it's shown to the user */
+  get formattedValue() {
+    return this._rawData?.formattedValue || null;
+  }
+  get formula() {
+    return get(this._rawData, "userEnteredValue.formulaValue", null);
+  }
+  set formula(newValue) {
+    if (!newValue) throw new Error("To clear a formula, set `cell.value = null`");
+    if (newValue.substring(0, 1) !== "=") throw new Error('formula must begin with "="');
+    this.value = newValue;
+  }
+  /**
+   * @deprecated use `cell.errorValue` instead
+   */
+  get formulaError() {
+    return this._error;
+  }
+  /**
+   * error contained in the cell, which can happen with a bad formula (maybe some other weird cases?)
+   */
+  get errorValue() {
+    return this._error;
+  }
+  get numberValue() {
+    if (this.valueType !== "numberValue") return void 0;
+    return this.value;
+  }
+  set numberValue(val) {
+    this.value = val;
+  }
+  get boolValue() {
+    if (this.valueType !== "boolValue") return void 0;
+    return this.value;
+  }
+  set boolValue(val) {
+    this.value = val;
+  }
+  get stringValue() {
+    if (this.valueType !== "stringValue") return void 0;
+    return this.value;
+  }
+  set stringValue(val) {
+    if (val?.startsWith("=")) {
+      throw new Error("Use cell.formula to set formula values");
+    }
+    this.value = val;
+  }
+  /**
+   * Hyperlink contained within the cell.
+   *
+   * To modify, do not set directly. Instead set cell.formula, for example `cell.formula = \'=HYPERLINK("http://google.com", "Google")\'`
+   */
+  get hyperlink() {
+    if (this._draftData.value) throw new Error("Save cell to be able to read hyperlink");
+    return this._rawData?.hyperlink;
+  }
+  /** a note attached to the cell */
+  get note() {
+    return this._draftData.note !== void 0 ? this._draftData.note : this._rawData?.note || "";
+  }
+  set note(newVal) {
+    if (newVal === null || newVal === void 0 || newVal === false) newVal = "";
+    if (!isString(newVal)) throw new Error("Note must be a string");
+    if (newVal === this._rawData?.note) delete this._draftData.note;
+    else this._draftData.note = newVal;
+  }
+  // CELL FORMATTING ///////////////////////////////////////////////////////////////////////////////
+  get userEnteredFormat() {
+    return Object.freeze(this._rawData?.userEnteredFormat);
+  }
+  get effectiveFormat() {
+    return Object.freeze(this._rawData?.effectiveFormat);
+  }
+  _getFormatParam(param) {
+    if (get(this._draftData, `userEnteredFormat.${param}`)) {
+      throw new Error("User format is unsaved - save the cell to be able to read it again");
+    }
+    return Object.freeze(this._rawData.userEnteredFormat[param]);
+  }
+  _setFormatParam(param, newVal) {
+    if (isEqual(newVal, get(this._rawData, `userEnteredFormat.${param}`))) {
+      unset(this._draftData, `userEnteredFormat.${param}`);
+    } else {
+      set(this._draftData, `userEnteredFormat.${param}`, newVal);
+      this._draftData.clearFormat = false;
+    }
+  }
+  // format getters
+  get numberFormat() {
+    return this._getFormatParam("numberFormat");
+  }
+  get backgroundColor() {
+    return this._getFormatParam("backgroundColor");
+  }
+  get backgroundColorStyle() {
+    return this._getFormatParam("backgroundColorStyle");
+  }
+  get borders() {
+    return this._getFormatParam("borders");
+  }
+  get padding() {
+    return this._getFormatParam("padding");
+  }
+  get horizontalAlignment() {
+    return this._getFormatParam("horizontalAlignment");
+  }
+  get verticalAlignment() {
+    return this._getFormatParam("verticalAlignment");
+  }
+  get wrapStrategy() {
+    return this._getFormatParam("wrapStrategy");
+  }
+  get textDirection() {
+    return this._getFormatParam("textDirection");
+  }
+  get textFormat() {
+    return this._getFormatParam("textFormat");
+  }
+  get hyperlinkDisplayType() {
+    return this._getFormatParam("hyperlinkDisplayType");
+  }
+  get textRotation() {
+    return this._getFormatParam("textRotation");
+  }
+  // format setters
+  set numberFormat(newVal) {
+    this._setFormatParam("numberFormat", newVal);
+  }
+  set backgroundColor(newVal) {
+    this._setFormatParam("backgroundColor", newVal);
+  }
+  set backgroundColorStyle(newVal) {
+    this._setFormatParam("backgroundColorStyle", newVal);
+  }
+  set borders(newVal) {
+    this._setFormatParam("borders", newVal);
+  }
+  set padding(newVal) {
+    this._setFormatParam("padding", newVal);
+  }
+  set horizontalAlignment(newVal) {
+    this._setFormatParam("horizontalAlignment", newVal);
+  }
+  set verticalAlignment(newVal) {
+    this._setFormatParam("verticalAlignment", newVal);
+  }
+  set wrapStrategy(newVal) {
+    this._setFormatParam("wrapStrategy", newVal);
+  }
+  set textDirection(newVal) {
+    this._setFormatParam("textDirection", newVal);
+  }
+  set textFormat(newVal) {
+    this._setFormatParam("textFormat", newVal);
+  }
+  set hyperlinkDisplayType(newVal) {
+    this._setFormatParam("hyperlinkDisplayType", newVal);
+  }
+  set textRotation(newVal) {
+    this._setFormatParam("textRotation", newVal);
+  }
+  clearAllFormatting() {
+    this._draftData.clearFormat = true;
+    delete this._draftData.userEnteredFormat;
+  }
+  // SAVING + UTILS ////////////////////////////////////////////////////////////////////////////////
+  // returns true if there are any updates that have not been saved yet
+  get _isDirty() {
+    if (this._draftData.note !== void 0) return true;
+    if (keys(this._draftData.userEnteredFormat).length) return true;
+    if (this._draftData.clearFormat) return true;
+    if (this._draftData.value !== void 0) return true;
+    return false;
+  }
+  discardUnsavedChanges() {
+    this._draftData = {};
+  }
+  /**
+   * saves updates for single cell
+   * usually it's better to make changes and call sheet.saveUpdatedCells
+   * */
+  async save() {
+    await this._sheet.saveCells([this]);
+  }
+  /**
+   * used by worksheet when saving cells
+   * returns an individual batchUpdate request to update the cell
+   * @internal
+   */
+  _getUpdateRequest() {
+    const isValueUpdated = this._draftData.value !== void 0;
+    const isNoteUpdated = this._draftData.note !== void 0;
+    const isFormatUpdated = !!keys(this._draftData.userEnteredFormat || {}).length;
+    const isFormatCleared = this._draftData.clearFormat;
+    if (!some([isValueUpdated, isNoteUpdated, isFormatUpdated, isFormatCleared])) {
+      return null;
+    }
+    const format = {
+      // have to pass the whole object or it will clear existing properties
+      ...this._rawData?.userEnteredFormat,
+      ...this._draftData.userEnteredFormat
+    };
+    if (get(this._draftData, "userEnteredFormat.backgroundColor")) {
+      delete format.backgroundColorStyle;
+    }
+    return {
+      updateCells: {
+        rows: [{
+          values: [{
+            ...isValueUpdated && {
+              userEnteredValue: { [this._draftData.valueType]: this._draftData.value }
+            },
+            ...isNoteUpdated && {
+              note: this._draftData.note
+            },
+            ...isFormatUpdated && {
+              userEnteredFormat: format
+            },
+            ...isFormatCleared && {
+              userEnteredFormat: {}
+            }
+          }]
+        }],
+        // turns into a string of which fields to update ex "note,userEnteredFormat"
+        fields: keys(pickBy({
+          userEnteredValue: isValueUpdated,
+          note: isNoteUpdated,
+          userEnteredFormat: isFormatUpdated || isFormatCleared
+        })).join(","),
+        start: {
+          sheetId: this._sheet.sheetId,
+          rowIndex: this.rowIndex,
+          columnIndex: this.columnIndex
+        }
+      }
+    };
+  }
+};
+
+// src/lib/GoogleSpreadsheetWorksheet.ts
+var GoogleSpreadsheetWorksheet = class {
+  constructor(_spreadsheet, rawProperties, rawCellData) {
+    this._spreadsheet = _spreadsheet;
+    this._headerRowIndex = 1;
+    this._rawProperties = rawProperties;
+    this._cells = [];
+    this._rowMetadata = [];
+    this._columnMetadata = [];
+    if (rawCellData) this._fillCellData(rawCellData);
+  }
+  static {
+    __name(this, "GoogleSpreadsheetWorksheet");
+  }
+  // assume "header row" (for row-based calls) is in first row, can be adjusted later
+  _headerRowIndex = 1;
+  _rawProperties = null;
+  _cells = [];
+  _rowMetadata = [];
+  _columnMetadata = [];
+  _headerValues;
+  get headerValues() {
+    if (!this._headerValues) {
+      throw new Error("Header values are not yet loaded");
+    }
+    return this._headerValues;
+  }
+  // INTERNAL UTILITY FUNCTIONS ////////////////////////////////////////////////////////////////////
+  updateRawData(properties, rawCellData) {
+    this._rawProperties = properties;
+    this._fillCellData(rawCellData);
+  }
+  async _makeSingleUpdateRequest(requestType, requestParams) {
+    return this._spreadsheet._makeSingleUpdateRequest(requestType, {
+      ...requestParams
+    });
+  }
+  _ensureInfoLoaded() {
+    if (!this._rawProperties) {
+      throw new Error("You must call `doc.loadInfo()` again before accessing this property");
+    }
+  }
+  /** clear local cache of sheet data/properties */
+  resetLocalCache(dataOnly) {
+    if (!dataOnly) this._rawProperties = null;
+    this._headerValues = void 0;
+    this._headerRowIndex = 1;
+    this._cells = [];
+  }
+  _fillCellData(dataRanges) {
+    forEach(dataRanges, (range2) => {
+      const startRow = range2.startRow || 0;
+      const startColumn = range2.startColumn || 0;
+      const numRows = range2.rowMetadata.length;
+      const numColumns = range2.columnMetadata.length;
+      for (let i = 0; i < numRows; i++) {
+        const actualRow = startRow + i;
+        for (let j = 0; j < numColumns; j++) {
+          const actualColumn = startColumn + j;
+          if (!this._cells[actualRow]) this._cells[actualRow] = [];
+          const cellData = get(range2, `rowData[${i}].values[${j}]`);
+          if (this._cells[actualRow][actualColumn]) {
+            this._cells[actualRow][actualColumn]._updateRawData(cellData);
+          } else {
+            this._cells[actualRow][actualColumn] = new GoogleSpreadsheetCell(
+              this,
+              actualRow,
+              actualColumn,
+              cellData
+            );
+          }
+        }
+      }
+      for (let i = 0; i < range2.rowMetadata.length; i++) {
+        this._rowMetadata[startRow + i] = range2.rowMetadata[i];
+      }
+      for (let i = 0; i < range2.columnMetadata.length; i++) {
+        this._columnMetadata[startColumn + i] = range2.columnMetadata[i];
+      }
+    });
+  }
+  // TODO: make this handle A1 ranges as well?
+  _addSheetIdToRange(range2) {
+    if (range2.sheetId && range2.sheetId !== this.sheetId) {
+      throw new Error("Leave sheet ID blank or set to matching ID of this sheet");
+    }
+    return {
+      ...range2,
+      sheetId: this.sheetId
+    };
+  }
+  // PROPERTY GETTERS //////////////////////////////////////////////////////////////////////////////
+  _getProp(param) {
+    this._ensureInfoLoaded();
+    return this._rawProperties[param];
+  }
+  // eslint-disable-line no-unused-vars
+  _setProp(_param, _newVal) {
+    throw new Error("Do not update directly - use `updateProperties()`");
+  }
+  get sheetId() {
+    return this._getProp("sheetId");
+  }
+  get title() {
+    return this._getProp("title");
+  }
+  get index() {
+    return this._getProp("index");
+  }
+  get sheetType() {
+    return this._getProp("sheetType");
+  }
+  get gridProperties() {
+    return this._getProp("gridProperties");
+  }
+  get hidden() {
+    return this._getProp("hidden");
+  }
+  get tabColor() {
+    return this._getProp("tabColor");
+  }
+  get rightToLeft() {
+    return this._getProp("rightToLeft");
+  }
+  get _headerRange() {
+    return `A${this._headerRowIndex}:${this.lastColumnLetter}${this._headerRowIndex}`;
+  }
+  set sheetId(newVal) {
+    this._setProp("sheetId", newVal);
+  }
+  set title(newVal) {
+    this._setProp("title", newVal);
+  }
+  set index(newVal) {
+    this._setProp("index", newVal);
+  }
+  set sheetType(newVal) {
+    this._setProp("sheetType", newVal);
+  }
+  set gridProperties(newVal) {
+    this._setProp("gridProperties", newVal);
+  }
+  set hidden(newVal) {
+    this._setProp("hidden", newVal);
+  }
+  set tabColor(newVal) {
+    this._setProp("tabColor", newVal);
+  }
+  set rightToLeft(newVal) {
+    this._setProp("rightToLeft", newVal);
+  }
+  get rowCount() {
+    this._ensureInfoLoaded();
+    return this.gridProperties.rowCount;
+  }
+  get columnCount() {
+    this._ensureInfoLoaded();
+    return this.gridProperties.columnCount;
+  }
+  get a1SheetName() {
+    return `'${this.title.replace(/'/g, "''")}'`;
+  }
+  get encodedA1SheetName() {
+    return encodeURIComponent(this.a1SheetName);
+  }
+  get lastColumnLetter() {
+    return this.columnCount ? columnToLetter(this.columnCount) : "";
+  }
+  // CELLS-BASED INTERACTIONS //////////////////////////////////////////////////////////////////////
+  get cellStats() {
+    let allCells = flatten2(this._cells);
+    allCells = compact2(allCells);
+    return {
+      nonEmpty: filter(allCells, (c) => c.value).length,
+      loaded: allCells.length,
+      total: this.rowCount * this.columnCount
+    };
+  }
+  getCellByA1(a1Address) {
+    const split = a1Address.match(/([A-Z]+)([0-9]+)/);
+    if (!split) throw new Error(`Cell address "${a1Address}" not valid`);
+    const columnIndex = letterToColumn(split[1]);
+    const rowIndex = parseInt(split[2]);
+    return this.getCell(rowIndex - 1, columnIndex - 1);
+  }
+  getCell(rowIndex, columnIndex) {
+    if (rowIndex < 0 || columnIndex < 0) throw new Error("Min coordinate is 0, 0");
+    if (rowIndex >= this.rowCount || columnIndex >= this.columnCount) {
+      throw new Error(`Out of bounds, sheet is ${this.rowCount} by ${this.columnCount}`);
+    }
+    if (!get(this._cells, `[${rowIndex}][${columnIndex}]`)) {
+      throw new Error("This cell has not been loaded yet");
+    }
+    return this._cells[rowIndex][columnIndex];
+  }
+  async loadCells(sheetFilters) {
+    if (!sheetFilters) return this._spreadsheet.loadCells(this.a1SheetName);
+    const filtersArray = isArray(sheetFilters) ? sheetFilters : [sheetFilters];
+    const filtersArrayWithSheetId = map(filtersArray, (filter2) => {
+      if (isString(filter2)) {
+        if (filter2.startsWith(this.a1SheetName)) return filter2;
+        return `${this.a1SheetName}!${filter2}`;
+      }
+      if (isObject2(filter2)) {
+        const filterAny = filter2;
+        if (filterAny.sheetId && filterAny.sheetId !== this.sheetId) {
+          throw new Error("Leave sheet ID blank or set to matching ID of this sheet");
+        }
+        return { sheetId: this.sheetId, ...filter2 };
+      }
+      throw new Error("Each filter must be a A1 range string or gridrange object");
+    });
+    return this._spreadsheet.loadCells(filtersArrayWithSheetId);
+  }
+  async saveUpdatedCells() {
+    const cellsToSave = filter(flatten2(this._cells), { _isDirty: true });
+    if (cellsToSave.length) {
+      await this.saveCells(cellsToSave);
+    }
+  }
+  async saveCells(cellsToUpdate) {
+    const requests = map(cellsToUpdate, (cell) => cell._getUpdateRequest());
+    const responseRanges = map(cellsToUpdate, (c) => `${this.a1SheetName}!${c.a1Address}`);
+    if (!compact2(requests).length) {
+      throw new Error("At least one cell must have something to update");
+    }
+    await this._spreadsheet._makeBatchUpdateRequest(requests, responseRanges);
+  }
+  // SAVING THIS FOR FUTURE USE
+  // puts the cells that need updating into batches
+  // async updateCellsByBatches() {
+  //   // saving this code, but it's problematic because each group must have the same update fields
+  //   const cellsByRow = _.groupBy(cellsToUpdate, 'rowIndex');
+  //   const groupsToSave = [];
+  //   _.each(cellsByRow, (cells, rowIndex) => {
+  //     let cellGroup = [];
+  //     _.each(cells, (c) => {
+  //       if (!cellGroup.length) {
+  //         cellGroup.push(c);
+  //       } else if (
+  //         cellGroup[cellGroup.length - 1].columnIndex ===
+  //         c.columnIndex - 1
+  //       ) {
+  //         cellGroup.push(c);
+  //       } else {
+  //         groupsToSave.push(cellGroup);
+  //         cellGroup = [];
+  //       }
+  //     });
+  //     groupsToSave.push(cellGroup);
+  //   });
+  //   const requests = _.map(groupsToSave, (cellGroup) => ({
+  //     updateCells: {
+  //       rows: [
+  //         {
+  //           values: _.map(cellGroup, (cell) => ({
+  //             ...cell._draftData.value && {
+  //               userEnteredValue: { [cell._draftData.valueType]: cell._draftData.value },
+  //             },
+  //             ...cell._draftData.note !== undefined && {
+  //               note: cell._draftData.note ,
+  //             },
+  //             ...cell._draftData.userEnteredFormat && {
+  //               userEnteredValue: cell._draftData.userEnteredFormat,
+  //             },
+  //           })),
+  //         },
+  //       ],
+  //       fields: 'userEnteredValue,note,userEnteredFormat',
+  //       start: {
+  //         sheetId: this.sheetId,
+  //         rowIndex: cellGroup[0].rowIndex,
+  //         columnIndex: cellGroup[0].columnIndex,
+  //       },
+  //     },
+  //   }));
+  //   const responseRanges = _.map(groupsToSave, (cellGroup) => {
+  //     let a1Range = cellGroup[0].a1Address;
+  //     if (cellGroup.length > 1)
+  //       a1Range += `:${cellGroup[cellGroup.length - 1].a1Address}`;
+  //     return `${cellGroup[0]._sheet.a1SheetName}!${a1Range}`;
+  //   });
+  // }
+  // ROW BASED FUNCTIONS ///////////////////////////////////////////////////////////////////////////
+  async _ensureHeaderRowLoaded() {
+    if (!this._headerValues) {
+      await this.loadHeaderRow();
+    }
+  }
+  async loadHeaderRow(headerRowIndex) {
+    if (headerRowIndex !== void 0) this._headerRowIndex = headerRowIndex;
+    const rows = await this.getCellsInRange(this._headerRange);
+    this._processHeaderRow(rows);
+  }
+  _processHeaderRow(rows) {
+    if (!rows) {
+      throw new Error("No values in the header row - fill the first row with header values before trying to interact with rows");
+    }
+    this._headerValues = map(rows[0], (header) => header?.trim());
+    if (!compact2(this.headerValues).length) {
+      throw new Error("All your header cells are blank - fill the first row with header values before trying to interact with rows");
+    }
+    checkForDuplicateHeaders(this.headerValues);
+  }
+  async setHeaderRow(headerValues, headerRowIndex) {
+    if (!headerValues) return;
+    if (headerValues.length > this.columnCount) {
+      throw new Error(`Sheet is not large enough to fit ${headerValues.length} columns. Resize the sheet first.`);
+    }
+    const trimmedHeaderValues = map(headerValues, (h) => h?.trim());
+    checkForDuplicateHeaders(trimmedHeaderValues);
+    if (!compact2(trimmedHeaderValues).length) {
+      throw new Error("All your header cells are blank -");
+    }
+    if (headerRowIndex) this._headerRowIndex = headerRowIndex;
+    const response = await this._spreadsheet.sheetsApi.put(
+      `values/${this.encodedA1SheetName}!${this._headerRowIndex}:${this._headerRowIndex}`,
+      {
+        searchParams: {
+          valueInputOption: "USER_ENTERED",
+          // other option is RAW
+          includeValuesInResponse: true
+        },
+        json: {
+          range: `${this.a1SheetName}!${this._headerRowIndex}:${this._headerRowIndex}`,
+          majorDimension: "ROWS",
+          values: [[
+            ...trimmedHeaderValues,
+            // pad the rest of the row with empty values to clear them all out
+            ...times(this.columnCount - trimmedHeaderValues.length, () => "")
+          ]]
+        }
+      }
+    );
+    const data = await response.json();
+    this._headerValues = data.updatedData.values[0];
+  }
+  // TODO: look at these types
+  async addRows(rows, options = {}) {
+    if (this.title.includes(":")) {
+      throw new Error('Please remove the ":" from your sheet title. There is a bug with the google API which breaks appending rows if any colons are in the sheet title.');
+    }
+    if (!isArray(rows)) throw new Error("You must pass in an array of row values to append");
+    await this._ensureHeaderRowLoaded();
+    const rowsAsArrays = [];
+    forEach(rows, (row) => {
+      let rowAsArray;
+      if (isArray(row)) {
+        rowAsArray = row;
+      } else if (isObject2(row)) {
+        rowAsArray = [];
+        for (let i = 0; i < this.headerValues.length; i++) {
+          const propName = this.headerValues[i];
+          rowAsArray[i] = row[propName];
+        }
+      } else {
+        throw new Error("Each row must be an object or an array");
+      }
+      rowsAsArrays.push(rowAsArray);
+    });
+    const response = await this._spreadsheet.sheetsApi.post(
+      `values/${this.encodedA1SheetName}!A${this._headerRowIndex}:append`,
+      {
+        searchParams: {
+          valueInputOption: options.raw ? "RAW" : "USER_ENTERED",
+          insertDataOption: options.insert ? "INSERT_ROWS" : "OVERWRITE",
+          includeValuesInResponse: true
+        },
+        json: {
+          values: rowsAsArrays
+        }
+      }
+    );
+    const data = await response.json();
+    const { updatedRange } = data.updates;
+    let rowNumber = updatedRange.match(/![A-Z]+([0-9]+):?/)[1];
+    rowNumber = parseInt(rowNumber);
+    this._ensureInfoLoaded();
+    if (options.insert) {
+      this._rawProperties.gridProperties.rowCount += rows.length;
+    } else if (rowNumber + rows.length > this.rowCount) {
+      this._rawProperties.gridProperties.rowCount = rowNumber + rows.length - 1;
+    }
+    return map(data.updates.updatedData.values, (rowValues) => {
+      const row = new GoogleSpreadsheetRow(this, rowNumber++, rowValues);
+      return row;
+    });
+  }
+  /** add a single row - see addRows for more info */
+  async addRow(rowValues, options) {
+    const rows = await this.addRows([rowValues], options);
+    return rows[0];
+  }
+  _rowCache = [];
+  async getRows(options) {
+    const offset = options?.offset || 0;
+    const limit = options?.limit || this.rowCount - 1;
+    const firstRow = 1 + this._headerRowIndex + offset;
+    const lastRow = firstRow + limit - 1;
+    let rawRows;
+    if (this._headerValues) {
+      const lastColumn = columnToLetter(this.headerValues.length);
+      rawRows = await this.getCellsInRange(
+        `A${firstRow}:${lastColumn}${lastRow}`
+      );
+    } else {
+      const result = await this.batchGetCellsInRange([
+        this._headerRange,
+        `A${firstRow}:${this.lastColumnLetter}${lastRow}`
+      ]);
+      this._processHeaderRow(result[0]);
+      rawRows = result[1];
+    }
+    if (!rawRows) return [];
+    const rows = [];
+    let rowNum = firstRow;
+    for (let i = 0; i < rawRows.length; i++) {
+      const row = new GoogleSpreadsheetRow(this, rowNum++, rawRows[i]);
+      this._rowCache[row.rowNumber] = row;
+      rows.push(row);
+    }
+    return rows;
+  }
+  /**
+   * @internal
+   * Used internally to update row numbers after deleting rows.
+   * Should not be called directly.
+   * */
+  _shiftRowCache(deletedRowNumber) {
+    delete this._rowCache[deletedRowNumber];
+    this._rowCache.forEach((row) => {
+      if (row.rowNumber > deletedRowNumber) {
+        row._updateRowNumber(row.rowNumber - 1);
+      }
+    });
+  }
+  async clearRows(options) {
+    const startRowIndex = options?.start || this._headerRowIndex + 1;
+    const endRowIndex = options?.end || this.rowCount;
+    await this._spreadsheet.sheetsApi.post(`values/${this.encodedA1SheetName}!${startRowIndex}:${endRowIndex}:clear`);
+    this._rowCache.forEach((row) => {
+      if (row.rowNumber >= startRowIndex && row.rowNumber <= endRowIndex) row._clearRowData();
+    });
+  }
+  // BASIC PROPS ///////////////////////////////////////////////////////////////////////////////////
+  /** @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#UpdateSheetPropertiesRequest */
+  async updateProperties(properties) {
+    return this._makeSingleUpdateRequest("updateSheetProperties", {
+      properties: {
+        sheetId: this.sheetId,
+        ...properties
+      },
+      fields: getFieldMask(properties)
+    });
+  }
+  /**
+   * passes through the call to updateProperties to update only the gridProperties object
+   */
+  async updateGridProperties(gridProperties) {
+    return this.updateProperties({ gridProperties });
+  }
+  /** resize, internally just calls updateGridProperties */
+  async resize(gridProperties) {
+    return this.updateGridProperties(gridProperties);
+  }
+  /**
+   *
+   * @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#updatedimensionpropertiesrequest
+   */
+  async updateDimensionProperties(columnsOrRows, properties, bounds) {
+    return this._makeSingleUpdateRequest("updateDimensionProperties", {
+      range: {
+        sheetId: this.sheetId,
+        dimension: columnsOrRows,
+        ...bounds
+      },
+      properties,
+      fields: getFieldMask(properties)
+    });
+  }
+  // OTHER /////////////////////////////////////////////////////////////////////////////////////////
+  // this uses the "values" getter and does not give all the info about the cell contents
+  // it is used internally when loading header cells
+  async getCellsInRange(a1Range, options) {
+    const response = await this._spreadsheet.sheetsApi.get(`values/${this.encodedA1SheetName}!${a1Range}`, {
+      searchParams: options
+    });
+    const data = await response.json();
+    return data.values;
+  }
+  async batchGetCellsInRange(a1Ranges, options) {
+    const ranges = a1Ranges.map((r) => `ranges=${this.encodedA1SheetName}!${r}`).join("&");
+    const response = await this._spreadsheet.sheetsApi.get(`values:batchGet?${ranges}`, {
+      searchParams: options
+    });
+    const data = await response.json();
+    return data.valueRanges.map((r) => r.values);
+  }
+  async updateNamedRange() {
+  }
+  async addNamedRange() {
+  }
+  async deleteNamedRange() {
+  }
+  async repeatCell() {
+  }
+  async autoFill() {
+  }
+  async cutPaste() {
+  }
+  async copyPaste() {
+  }
+  // TODO: check types on these ranges
+  /**
+   * Merges all cells in the range
+   * @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#MergeCellsRequest
+   */
+  async mergeCells(range2, mergeType = "MERGE_ALL") {
+    await this._makeSingleUpdateRequest("mergeCells", {
+      mergeType,
+      range: this._addSheetIdToRange(range2)
+    });
+  }
+  /**
+   * Unmerges cells in the given range
+   * @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#UnmergeCellsRequest
+   */
+  async unmergeCells(range2) {
+    await this._makeSingleUpdateRequest("unmergeCells", {
+      range: this._addSheetIdToRange(range2)
+    });
+  }
+  async updateBorders() {
+  }
+  async addFilterView() {
+  }
+  async appendCells() {
+  }
+  async clearBasicFilter() {
+  }
+  async deleteDimension() {
+  }
+  async deleteEmbeddedObject() {
+  }
+  async deleteFilterView() {
+  }
+  async duplicateFilterView() {
+  }
+  /**
+   * Duplicate worksheet within the document
+   * @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#DuplicateSheetRequest
+   */
+  async duplicate(options) {
+    const response = await this._makeSingleUpdateRequest("duplicateSheet", {
+      sourceSheetId: this.sheetId,
+      ...options?.index !== void 0 && { insertSheetIndex: options.index },
+      ...options?.id && { newSheetId: options.id },
+      ...options?.title && { newSheetName: options.title }
+    });
+    const newSheetId = response.properties.sheetId;
+    return this._spreadsheet.sheetsById[newSheetId];
+  }
+  async findReplace() {
+  }
+  /**
+   * Inserts rows or columns at a particular index
+   * @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#InsertDimensionRequest
+   */
+  async insertDimension(columnsOrRows, rangeIndexes, inheritFromBefore) {
+    if (!columnsOrRows) throw new Error("You need to specify a dimension. i.e. COLUMNS|ROWS");
+    if (!isObject2(rangeIndexes)) throw new Error("`range` must be an object containing `startIndex` and `endIndex`");
+    if (!isInteger(rangeIndexes.startIndex) || rangeIndexes.startIndex < 0) throw new Error("range.startIndex must be an integer >=0");
+    if (!isInteger(rangeIndexes.endIndex) || rangeIndexes.endIndex < 0) throw new Error("range.endIndex must be an integer >=0");
+    if (rangeIndexes.endIndex <= rangeIndexes.startIndex) throw new Error("range.endIndex must be greater than range.startIndex");
+    if (inheritFromBefore === void 0) {
+      inheritFromBefore = rangeIndexes.startIndex > 0;
+    }
+    if (inheritFromBefore && rangeIndexes.startIndex === 0) {
+      throw new Error("Cannot set inheritFromBefore to true if inserting in first row/column");
+    }
+    return this._makeSingleUpdateRequest("insertDimension", {
+      range: {
+        sheetId: this.sheetId,
+        dimension: columnsOrRows,
+        startIndex: rangeIndexes.startIndex,
+        endIndex: rangeIndexes.endIndex
+      },
+      inheritFromBefore
+    });
+  }
+  async insertRange() {
+  }
+  async moveDimension() {
+  }
+  async updateEmbeddedObjectPosition() {
+  }
+  async pasteData() {
+  }
+  async textToColumns() {
+  }
+  async updateFilterView() {
+  }
+  async deleteRange() {
+  }
+  async appendDimension() {
+  }
+  async addConditionalFormatRule() {
+  }
+  async updateConditionalFormatRule() {
+  }
+  async deleteConditionalFormatRule() {
+  }
+  async sortRange() {
+  }
+  /**
+   * Sets (or unsets) a data validation rule to every cell in the range
+   * @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#SetDataValidationRequest
+   */
+  async setDataValidation(range2, rule) {
+    return this._makeSingleUpdateRequest("setDataValidation", {
+      range: {
+        sheetId: this.sheetId,
+        ...range2
+      },
+      ...rule && { rule }
+    });
+  }
+  async setBasicFilter() {
+  }
+  async addProtectedRange() {
+  }
+  async updateProtectedRange() {
+  }
+  async deleteProtectedRange() {
+  }
+  async autoResizeDimensions() {
+  }
+  async addChart() {
+  }
+  async updateChartSpec() {
+  }
+  async updateBanding() {
+  }
+  async addBanding() {
+  }
+  async deleteBanding() {
+  }
+  async createDeveloperMetadata() {
+  }
+  async updateDeveloperMetadata() {
+  }
+  async deleteDeveloperMetadata() {
+  }
+  async randomizeRange() {
+  }
+  async addDimensionGroup() {
+  }
+  async deleteDimensionGroup() {
+  }
+  async updateDimensionGroup() {
+  }
+  async trimWhitespace() {
+  }
+  async deleteDuplicates() {
+  }
+  async addSlicer() {
+  }
+  async updateSlicerSpec() {
+  }
+  /** delete this worksheet */
+  async delete() {
+    return this._spreadsheet.deleteSheet(this.sheetId);
+  }
+  /**
+   * copies this worksheet into another document/spreadsheet
+   * @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets.sheets/copyTo
+   * */
+  async copyToSpreadsheet(destinationSpreadsheetId) {
+    const req = this._spreadsheet.sheetsApi.post(`sheets/${this.sheetId}:copyTo`, {
+      json: {
+        destinationSpreadsheetId
+      }
+    });
+    const data = await req.json();
+    return data;
+  }
+  /** clear data in the sheet - either the entire sheet or a specific range */
+  async clear(a1Range) {
+    const range2 = a1Range ? `!${a1Range}` : "";
+    await this._spreadsheet.sheetsApi.post(`values/${this.encodedA1SheetName}${range2}:clear`);
+    this.resetLocalCache(true);
+  }
+  async downloadAsCSV(returnStreamInsteadOfBuffer = false) {
+    return this._spreadsheet._downloadAs("csv", this.sheetId, returnStreamInsteadOfBuffer);
+  }
+  async downloadAsTSV(returnStreamInsteadOfBuffer = false) {
+    return this._spreadsheet._downloadAs("tsv", this.sheetId, returnStreamInsteadOfBuffer);
+  }
+  async downloadAsPDF(returnStreamInsteadOfBuffer = false) {
+    return this._spreadsheet._downloadAs("pdf", this.sheetId, returnStreamInsteadOfBuffer);
+  }
+};
+
+// src/lib/GoogleSpreadsheet.ts
+var SHEETS_API_BASE_URL = "https://sheets.googleapis.com/v4/spreadsheets";
+var DRIVE_API_BASE_URL = "https://www.googleapis.com/drive/v3/files";
+var EXPORT_CONFIG = {
+  html: {},
+  zip: {},
+  xlsx: {},
+  ods: {},
+  csv: { singleWorksheet: true },
+  tsv: { singleWorksheet: true },
+  pdf: { singleWorksheet: true }
+};
+function getAuthMode(auth) {
+  if ("getRequestHeaders" in auth) return "google_auth" /* GOOGLE_AUTH_CLIENT */;
+  if ("token" in auth && auth.token) return "raw_access_token" /* RAW_ACCESS_TOKEN */;
+  if ("apiKey" in auth && auth.apiKey) return "api_key" /* API_KEY */;
+  throw new Error("Invalid auth");
+}
+__name(getAuthMode, "getAuthMode");
+async function getRequestAuthConfig(auth) {
+  if ("getRequestHeaders" in auth) {
+    const headers = await auth.getRequestHeaders();
+    if ("entries" in headers) {
+      return { headers: Object.fromEntries(headers.entries()) };
+    }
+    if (isObject2(headers)) {
+      return { headers };
+    }
+    throw new Error("unexpected headers returned from getRequestHeaders");
+  }
+  if ("apiKey" in auth && auth.apiKey) {
+    return { searchParams: { key: auth.apiKey } };
+  }
+  if ("token" in auth && auth.token) {
+    return { headers: { Authorization: `Bearer ${auth.token}` } };
+  }
+  throw new Error("Invalid auth");
+}
+__name(getRequestAuthConfig, "getRequestAuthConfig");
+var GoogleSpreadsheet = class _GoogleSpreadsheet {
+  static {
+    __name(this, "GoogleSpreadsheet");
+  }
+  spreadsheetId;
+  auth;
+  get authMode() {
+    return getAuthMode(this.auth);
+  }
+  _rawSheets;
+  _rawProperties = null;
+  _spreadsheetUrl = null;
+  _deleted = false;
+  /**
+   * Sheets API [ky](https://github.com/sindresorhus/ky?tab=readme-ov-file#kycreatedefaultoptions) instance
+   * authentication is automatically attached
+   * can be used if unsupported sheets calls need to be made
+   * @see https://developers.google.com/sheets/api/reference/rest
+   * */
+  sheetsApi;
+  /**
+   * Drive API [ky](https://github.com/sindresorhus/ky?tab=readme-ov-file#kycreatedefaultoptions) instance
+   * authentication automatically attached
+   * can be used if unsupported drive calls need to be made
+   * @topic permissions
+   * @see https://developers.google.com/drive/api/v3/reference
+   * */
+  driveApi;
+  /**
+   * initialize new GoogleSpreadsheet
+   * @category Initialization
+   * */
+  constructor(spreadsheetId, auth) {
+    this.spreadsheetId = spreadsheetId;
+    this.auth = auth;
+    this._rawSheets = {};
+    this._spreadsheetUrl = null;
+    this.sheetsApi = distribution_default.create({
+      prefixUrl: `${SHEETS_API_BASE_URL}/${spreadsheetId}`,
+      hooks: {
+        beforeRequest: [(r) => this._setAuthRequestHook(r)],
+        beforeError: [(e) => this._errorHook(e)]
+      }
+    });
+    this.driveApi = distribution_default.create({
+      prefixUrl: `${DRIVE_API_BASE_URL}/${spreadsheetId}`,
+      hooks: {
+        beforeRequest: [(r) => this._setAuthRequestHook(r)],
+        beforeError: [(e) => this._errorHook(e)]
+      }
+    });
+  }
+  // INTERNAL UTILITY FUNCTIONS ////////////////////////////////////////////////////////////////////
+  /** @internal */
+  async _setAuthRequestHook(req) {
+    const authConfig = await getRequestAuthConfig(this.auth);
+    if (authConfig.headers) {
+      Object.entries(authConfig.headers).forEach(([key, val]) => {
+        req.headers.set(key, String(val));
+      });
+    }
+    if (authConfig.searchParams) {
+      const url = new URL(req.url);
+      Object.entries(authConfig.searchParams).forEach(([key, val]) => {
+        url.searchParams.set(key, String(val));
+      });
+      return new Request(url, req);
+    }
+    return req;
+  }
+  /** @internal */
+  async _errorHook(error) {
+    const { response } = error;
+    const errorDataText = await response?.text();
+    let errorData;
+    try {
+      errorData = JSON.parse(errorDataText);
+    } catch (e) {
+    }
+    if (errorData) {
+      if (!errorData.error) return error;
+      const { code, message } = errorData.error;
+      error.message = `Google API error - [${code}] ${message}`;
+      return error;
+    }
+    if (get(error, "response.status") === 403) {
+      if ("apiKey" in this.auth) {
+        throw new Error("Sheet is private. Use authentication or make public. (see https://github.com/theoephraim/node-google-spreadsheet#a-note-on-authentication for details)");
+      }
+    }
+    return error;
+  }
+  /** @internal */
+  async _makeSingleUpdateRequest(requestType, requestParams) {
+    const response = await this.sheetsApi.post(":batchUpdate", {
+      json: {
+        requests: [{ [requestType]: requestParams }],
+        includeSpreadsheetInResponse: true
+        // responseRanges: [string]
+        // responseIncludeGridData: true
+      }
+    });
+    const data = await response.json();
+    this._updateRawProperties(data.updatedSpreadsheet.properties);
+    forEach(data.updatedSpreadsheet.sheets, (s) => this._updateOrCreateSheet(s));
+    return data.replies[0][requestType];
+  }
+  // TODO: review these types
+  // currently only used in batching cell updates
+  /** @internal */
+  async _makeBatchUpdateRequest(requests, responseRanges) {
+    const response = await this.sheetsApi.post(":batchUpdate", {
+      json: {
+        requests,
+        includeSpreadsheetInResponse: true,
+        ...responseRanges && {
+          responseIncludeGridData: true,
+          ...responseRanges !== "*" && { responseRanges }
+        }
+      }
+    });
+    const data = await response.json();
+    this._updateRawProperties(data.updatedSpreadsheet.properties);
+    forEach(data.updatedSpreadsheet.sheets, (s) => this._updateOrCreateSheet(s));
+  }
+  /** @internal */
+  _ensureInfoLoaded() {
+    if (!this._rawProperties) throw new Error("You must call `doc.loadInfo()` before accessing this property");
+  }
+  /** @internal */
+  _updateRawProperties(newProperties) {
+    this._rawProperties = newProperties;
+  }
+  /** @internal */
+  _updateOrCreateSheet(sheetInfo) {
+    const { properties, data } = sheetInfo;
+    const { sheetId } = properties;
+    if (!this._rawSheets[sheetId]) {
+      this._rawSheets[sheetId] = new GoogleSpreadsheetWorksheet(this, properties, data);
+    } else {
+      this._rawSheets[sheetId].updateRawData(properties, data);
+    }
+  }
+  // BASIC PROPS //////////////////////////////////////////////////////////////////////////////
+  _getProp(param) {
+    this._ensureInfoLoaded();
+    return this._rawProperties[param];
+  }
+  get title() {
+    return this._getProp("title");
+  }
+  get locale() {
+    return this._getProp("locale");
+  }
+  get timeZone() {
+    return this._getProp("timeZone");
+  }
+  get autoRecalc() {
+    return this._getProp("autoRecalc");
+  }
+  get defaultFormat() {
+    return this._getProp("defaultFormat");
+  }
+  get spreadsheetTheme() {
+    return this._getProp("spreadsheetTheme");
+  }
+  get iterativeCalculationSettings() {
+    return this._getProp("iterativeCalculationSettings");
+  }
+  /**
+   * update spreadsheet properties
+   * @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets#SpreadsheetProperties
+   * */
+  async updateProperties(properties) {
+    await this._makeSingleUpdateRequest("updateSpreadsheetProperties", {
+      properties,
+      fields: getFieldMask(properties)
+    });
+  }
+  // BASIC INFO ////////////////////////////////////////////////////////////////////////////////////
+  async loadInfo(includeCells = false) {
+    const response = await this.sheetsApi.get("", {
+      searchParams: {
+        ...includeCells && { includeGridData: true }
+      }
+    });
+    const data = await response.json();
+    this._spreadsheetUrl = data.spreadsheetUrl;
+    this._rawProperties = data.properties;
+    data.sheets?.forEach((s) => this._updateOrCreateSheet(s));
+  }
+  resetLocalCache() {
+    this._rawProperties = null;
+    this._rawSheets = {};
+  }
+  // WORKSHEETS ////////////////////////////////////////////////////////////////////////////////////
+  get sheetCount() {
+    this._ensureInfoLoaded();
+    return values(this._rawSheets).length;
+  }
+  get sheetsById() {
+    this._ensureInfoLoaded();
+    return this._rawSheets;
+  }
+  get sheetsByIndex() {
+    this._ensureInfoLoaded();
+    return sortBy(this._rawSheets, "index");
+  }
+  get sheetsByTitle() {
+    this._ensureInfoLoaded();
+    return keyBy(this._rawSheets, "title");
+  }
+  /**
+   * Add new worksheet to document
+   * @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#AddSheetRequest
+   * */
+  async addSheet(properties = {}) {
+    const response = await this._makeSingleUpdateRequest("addSheet", {
+      properties: omit(properties, "headerValues", "headerRowIndex")
+    });
+    const newSheetId = response.properties.sheetId;
+    const newSheet = this.sheetsById[newSheetId];
+    if (properties.headerValues) {
+      await newSheet.setHeaderRow(properties.headerValues, properties.headerRowIndex);
+    }
+    return newSheet;
+  }
+  /**
+   * delete a worksheet
+   * @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#DeleteSheetRequest
+   * */
+  async deleteSheet(sheetId) {
+    await this._makeSingleUpdateRequest("deleteSheet", { sheetId });
+    delete this._rawSheets[sheetId];
+  }
+  // NAMED RANGES //////////////////////////////////////////////////////////////////////////////////
+  /**
+   * create a new named range
+   * @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#AddNamedRangeRequest
+   */
+  async addNamedRange(name, range2, namedRangeId) {
+    return this._makeSingleUpdateRequest("addNamedRange", {
+      name,
+      namedRangeId,
+      range: range2
+    });
+  }
+  /**
+   * delete a named range
+   * @see https://developers.google.com/sheets/api/reference/rest/v4/spreadsheets/request#DeleteNamedRangeRequest
+   * */
+  async deleteNamedRange(namedRangeId) {
+    return this._makeSingleUpdateRequest("deleteNamedRange", { namedRangeId });
+  }
+  // LOADING CELLS /////////////////////////////////////////////////////////////////////////////////
+  /** fetch cell data into local cache */
+  async loadCells(filters) {
+    const readOnlyMode = this.authMode === "api_key" /* API_KEY */;
+    const filtersArray = isArray(filters) ? filters : [filters];
+    const dataFilters = map(filtersArray, (filter2) => {
+      if (isString(filter2)) {
+        return readOnlyMode ? filter2 : { a1Range: filter2 };
+      }
+      if (isObject2(filter2)) {
+        if (readOnlyMode) {
+          throw new Error("Only A1 ranges are supported when fetching cells with read-only access (using only an API key)");
+        }
+        return { gridRange: filter2 };
+      }
+      throw new Error("Each filter must be an A1 range string or a gridrange object");
+    });
+    let result;
+    if (this.authMode === "api_key" /* API_KEY */) {
+      const params = new URLSearchParams();
+      params.append("includeGridData", "true");
+      dataFilters.forEach((singleFilter) => {
+        if (!isString(singleFilter)) {
+          throw new Error("Only A1 ranges are supported when fetching cells with read-only access (using only an API key)");
+        }
+        params.append("ranges", singleFilter);
+      });
+      result = await this.sheetsApi.get("", {
+        searchParams: params
+      });
+    } else {
+      result = await this.sheetsApi.post(":getByDataFilter", {
+        json: {
+          includeGridData: true,
+          dataFilters
+        }
+      });
+    }
+    const data = await result?.json();
+    forEach(data.sheets, (sheet) => {
+      this._updateOrCreateSheet(sheet);
+    });
+  }
+  // EXPORTING /////////////////////////////////////////////////////////////
+  /**
+   * export/download helper, not meant to be called directly (use downloadAsX methods on spreadsheet and worksheet instead)
+   * @internal
+   */
+  async _downloadAs(fileType, worksheetId, returnStreamInsteadOfBuffer) {
+    if (!EXPORT_CONFIG[fileType]) throw new Error(`unsupported export fileType - ${fileType}`);
+    if (EXPORT_CONFIG[fileType].singleWorksheet) {
+      if (worksheetId === void 0) throw new Error(`Must specify worksheetId when exporting as ${fileType}`);
+    } else if (worksheetId) throw new Error(`Cannot specify worksheetId when exporting as ${fileType}`);
+    if (fileType === "html") fileType = "zip";
+    if (!this._spreadsheetUrl) throw new Error("Cannot export sheet that is not fully loaded");
+    const exportUrl = this._spreadsheetUrl.replace("edit", "export");
+    const response = await this.sheetsApi.get(exportUrl, {
+      prefixUrl: "",
+      // unset baseUrl since we're not hitting the normal sheets API
+      searchParams: {
+        id: this.spreadsheetId,
+        format: fileType,
+        // worksheetId can be 0
+        ...worksheetId !== void 0 && { gid: worksheetId }
+      }
+    });
+    if (returnStreamInsteadOfBuffer) {
+      return response.body;
+    }
+    return response.arrayBuffer();
+  }
+  async downloadAsZippedHTML(returnStreamInsteadOfBuffer) {
+    return this._downloadAs("html", void 0, returnStreamInsteadOfBuffer);
+  }
+  /**
+   * @deprecated
+   * use `doc.downloadAsZippedHTML()` instead
+   * */
+  async downloadAsHTML(returnStreamInsteadOfBuffer) {
+    return this._downloadAs("html", void 0, returnStreamInsteadOfBuffer);
+  }
+  async downloadAsXLSX(returnStreamInsteadOfBuffer = false) {
+    return this._downloadAs("xlsx", void 0, returnStreamInsteadOfBuffer);
+  }
+  async downloadAsODS(returnStreamInsteadOfBuffer = false) {
+    return this._downloadAs("ods", void 0, returnStreamInsteadOfBuffer);
+  }
+  async delete() {
+    await this.driveApi.delete("");
+    this._deleted = true;
+  }
+  // PERMISSIONS ///////////////////////////////////////////////////////////////////////////////////
+  /**
+   * list all permissions entries for doc
+   */
+  async listPermissions() {
+    const listReq = await this.driveApi.get("permissions", {
+      searchParams: {
+        fields: "permissions(id,type,emailAddress,domain,role,displayName,photoLink,deleted)"
+      }
+    });
+    const data = await listReq.json();
+    return data.permissions;
+  }
+  async setPublicAccessLevel(role) {
+    const permissions = await this.listPermissions();
+    const existingPublicPermission = find(permissions, (p) => p.type === "anyone");
+    if (role === false) {
+      if (!existingPublicPermission) {
+        return;
+      }
+      await this.driveApi.delete(`permissions/${existingPublicPermission.id}`);
+    } else {
+      await this.driveApi.post("permissions", {
+        json: {
+          role: role || "viewer",
+          type: "anyone"
+        }
+      });
+    }
+  }
+  /** share document to email or domain */
+  async share(emailAddressOrDomain, opts) {
+    let emailAddress;
+    let domain;
+    if (emailAddressOrDomain.includes("@")) {
+      emailAddress = emailAddressOrDomain;
+    } else {
+      domain = emailAddressOrDomain;
+    }
+    const shareReq = await this.driveApi.post("permissions", {
+      searchParams: {
+        ...opts?.emailMessage === false && { sendNotificationEmail: false },
+        ...isString(opts?.emailMessage) && { emailMessage: opts?.emailMessage },
+        ...opts?.role === "owner" && { transferOwnership: true }
+      },
+      json: {
+        role: opts?.role || "writer",
+        ...emailAddress && {
+          type: opts?.isGroup ? "group" : "user",
+          emailAddress
+        },
+        ...domain && {
+          type: "domain",
+          domain
+        }
+      }
+    });
+    return shareReq.json();
+  }
+  //
+  // CREATE NEW DOC ////////////////////////////////////////////////////////////////////////////////
+  static async createNewSpreadsheetDocument(auth, properties) {
+    if (getAuthMode(auth) === "api_key" /* API_KEY */) {
+      throw new Error("Cannot use api key only to create a new spreadsheet - it is only usable for read-only access of public docs");
+    }
+    const authConfig = await getRequestAuthConfig(auth);
+    const response = await distribution_default.post(SHEETS_API_BASE_URL, {
+      ...authConfig,
+      // has the auth header
+      json: {
+        properties
+      }
+    });
+    const data = await response.json();
+    const newSpreadsheet = new _GoogleSpreadsheet(data.spreadsheetId, auth);
+    newSpreadsheet._spreadsheetUrl = data.spreadsheetUrl;
+    newSpreadsheet._rawProperties = data.properties;
+    forEach(data.sheets, (s) => newSpreadsheet._updateOrCreateSheet(s));
+    return newSpreadsheet;
+  }
+};
+/*! Bundled license information:
+
+ky/distribution/index.js:
+  (*! MIT License © Sindre Sorhus *)
+*/
+
+export { GoogleSpreadsheet, GoogleSpreadsheetCell, GoogleSpreadsheetCellErrorValue, GoogleSpreadsheetRow, GoogleSpreadsheetWorksheet };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map