// ==UserScript==
// @name                贴吧 eztb 工具箱
// @name:zh-CN          贴吧 eztb 工具箱
// @author              Dan12elion
// @namespace           https://github.com/Dan12elion/tieba_extensions
// @version             1.11.0
// @description         在贴吧页面上给每个用户名加一个「查询」按钮，点开查看该用户的资料 / 关注的人 / 关注的吧 / 粉丝 / 发帖（只读）；还可以配置关键词规则（关注的吧与发帖内容），让命中的用户在用户名旁被标注出来。数据由脚本内置的 SDK 直连贴吧接口获取，不经过任何第三方服务；使用前需要自己粘贴 BDUSS。
// @description:zh-CN   在贴吧页面上给每个用户名加一个「查询」按钮，点开查看该用户的资料 / 关注的人 / 关注的吧 / 粉丝 / 发帖（只读）；还可以配置关键词规则（关注的吧与发帖内容），让命中的用户在用户名旁被标注出来。数据由脚本内置的 SDK 直连贴吧接口获取，不经过任何第三方服务；使用前需要自己粘贴 BDUSS。
// @match               *://tieba.baidu.com/*
// @match               *://*.tieba.baidu.com/*
// @run-at              document-idle
// @grant               GM_xmlhttpRequest
// @grant               GM_getValue
// @grant               GM_setValue
// @grant               GM_registerMenuCommand
// @connect             tiebac.baidu.com
// @connect             tieba.baidu.com
// @compatible          chrome
// @compatible          edge
// @incompatible        firefox
// @license             MIT
// @supportURL          https://github.com/Dan12elion/tieba_extensions/issues
// ==/UserScript==

// ---------------------------------------------------------------------------
// 本文件是构建产物，请不要直接在这里改代码（下次构建会覆盖）。
// 源码与构建脚本：scripts/ 与 src/ 目录，构建命令 node build.mjs
// 产物里打包了第三方代码，清单与许可见文件末尾的 NOTICE。
// 本脚本只做只读查询，所有数据由脚本直连 tiebac.baidu.com。
// ---------------------------------------------------------------------------

/* eslint-disable */
// 全局 Buffer 垫片：整个 SDK 只有 core/http.ts 用了一次 Buffer.from()，
// 浏览器里退化成原样返回即可。
(() => {
	const g = typeof globalThis !== "undefined" ? globalThis : self;
	if (!g.Buffer) {
		g.Buffer = { from: (value) => value };
	}
})();

"use strict";
(() => {
  var __defProp = Object.defineProperty;
  var __typeError = (msg) => {
    throw TypeError(msg);
  };
  var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
  var __export = (target, all5) => {
    for (var name in all5)
      __defProp(target, name, { get: all5[name], enumerable: true });
  };
  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
  var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
  var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
  var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
  var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);

  // src/core/log.ts
  var ORDER = {
    debug: 10,
    info: 20,
    warn: 30,
    error: 40
  };
  var RING_MAX = 200;
  var MAX_ARG_CHARS = 300;
  var threshold = "info";
  var ring = [];
  function recentLogs() {
    return ring.slice();
  }
  function mask(value) {
    if (value.length <= 8) return value;
    return `${value.slice(0, 4)}…${value.slice(-2)}`;
  }
  function format(value) {
    let text;
    if (typeof value === "string") text = value;
    else if (value instanceof Error) text = `${value.name}: ${value.message}`;
    else if (value === void 0) text = "undefined";
    else {
      try {
        text = JSON.stringify(value);
      } catch {
        text = String(value);
      }
    }
    if (text === void 0) text = String(value);
    return text.length > MAX_ARG_CHARS ? `${text.slice(0, MAX_ARG_CHARS)}…` : text;
  }
  function emit(level, args2) {
    if (ORDER[level] < ORDER[threshold]) return;
    const body = args2.map(format).join(" ");
    ring.push(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${level}: ${body}`);
    if (ring.length > RING_MAX) ring.splice(0, ring.length - RING_MAX);
    const out = `[eztb] ${body}`;
    if (level === "error") console.error(out);
    else if (level === "warn") console.warn(out);
    else console.log(out);
  }
  var log = {
    debug: (...args2) => emit("debug", args2),
    info: (...args2) => emit("info", args2),
    warn: (...args2) => emit("warn", args2),
    error: (...args2) => emit("error", args2)
  };
  function describeUser(user) {
    if (!user) return "未识别";
    const parts2 = [];
    if (user.userId) parts2.push(`id=${user.userId}`);
    if (user.uid) parts2.push(`uid=${mask(String(user.uid))}`);
    if (user.un) parts2.push(`un=${user.un}`);
    if (user.portrait) parts2.push(`portrait=${mask(String(user.portrait))}`);
    return parts2.join(" ") || "无标识";
  }

  // src/core/kvCache.ts
  var issues = [];
  function getStorageIssues() {
    return issues.slice();
  }
  function noteStorageIssue(storageKey, error) {
    const message = error instanceof Error ? error.message : String(error);
    if (issues.some(
      (issue) => issue.storageKey === storageKey && issue.message === message
    )) {
      return;
    }
    issues.push({ storageKey, message, at: Date.now() });
    log.warn(
      `写入油猴存储失败（${storageKey}）：${message}。通常是存储配额已满，本次结果可能不会保留。`
    );
  }
  function createKvCache(options) {
    const { storageKey, max: max6 } = options;
    const memory = /* @__PURE__ */ new Map();
    let disk = null;
    const load = () => {
      if (disk) return disk;
      try {
        const stored = GM_getValue(storageKey, {});
        disk = stored && typeof stored === "object" ? stored : {};
      } catch {
        disk = {};
      }
      return disk;
    };
    const ttlMs2 = () => {
      const raw = typeof options.ttlMs === "function" ? options.ttlMs() : options.ttlMs;
      return typeof raw === "number" && Number.isFinite(raw) && raw > 0 ? raw : 0;
    };
    const isUsable = (entry) => {
      if (!entry || typeof entry !== "object") return false;
      const limit = ttlMs2();
      if (limit > 0 && Date.now() - (entry.ts ?? 0) > limit) return false;
      if (options.validate && !options.validate(entry)) return false;
      return true;
    };
    const drop3 = (key) => {
      memory.delete(key);
      const store = load();
      if (key in store) delete store[key];
    };
    const persist2 = (store) => {
      try {
        GM_setValue(storageKey, store);
        return true;
      } catch (error) {
        noteStorageIssue(storageKey, error);
        return false;
      }
    };
    const trim = (store, limit) => {
      const keys5 = Object.keys(store);
      if (keys5.length <= limit) return;
      keys5.sort((a, b) => (store[a]?.ts ?? 0) - (store[b]?.ts ?? 0));
      for (const stale of keys5.slice(0, keys5.length - limit)) {
        delete store[stale];
      }
    };
    return {
      read(key) {
        const hit = memory.get(key) ?? load()[key];
        if (!hit) return null;
        if (!isUsable(hit)) {
          drop3(key);
          return null;
        }
        memory.set(key, hit);
        return hit;
      },
      write(key, value) {
        const entry = { ...value, ts: Date.now() };
        const store = load();
        memory.set(key, entry);
        store[key] = entry;
        trim(store, max6);
        if (!persist2(store)) {
          trim(store, Math.max(1, Math.floor(max6 / 2)));
          persist2(store);
        }
        return entry;
      },
      delete(key) {
        drop3(key);
      },
      clear() {
        memory.clear();
        disk = {};
        persist2({});
      },
      clearMemory() {
        memory.clear();
      },
      count() {
        return Object.keys(load()).length;
      }
    };
  }

  // src/core/cached.ts
  var CACHE_KEY = "tbEztbToolboxProfileCacheV1";
  var CACHE_TTL = 7 * 24 * 60 * 60 * 1e3;
  var CACHE_MAX = 500;
  var cache = createKvCache({
    storageKey: CACHE_KEY,
    max: CACHE_MAX,
    ttlMs: CACHE_TTL
  });
  function stripQuery(value) {
    return value.split("?")[0];
  }
  function profileCacheKey(ref) {
    if (ref.portrait) return `p:${stripQuery(ref.portrait)}`;
    if (ref.userId) return `u:${ref.userId}`;
    if (ref.un) return `n:${ref.un}`;
    return null;
  }
  function readProfileCache(key) {
    if (!key) return null;
    return cache.read(key);
  }
  function writeProfileCache(key, value) {
    if (!key) return;
    cache.write(key, value);
  }
  function clearProfileCache() {
    cache.clear();
  }

  // src/core/gmhttp.ts
  var GmHttpError = class extends Error {
    constructor(kind, message) {
      super(message);
      this.name = "GmHttpError";
      this.kind = kind;
    }
  };
  var DEFAULT_TIMEOUT = 3e4;
  var inFlight = /* @__PURE__ */ new Set();
  function inFlightCount() {
    return inFlight.size;
  }
  function abortAllInFlight() {
    const count3 = inFlight.size;
    for (const handle of Array.from(inFlight)) {
      try {
        handle.abort();
      } catch {
      }
    }
    inFlight.clear();
    return count3;
  }
  function gmRequestHandle(options) {
    let handle = null;
    let settled = false;
    const done7 = () => {
      settled = true;
      if (handle) inFlight.delete(handle);
    };
    const promise3 = new Promise((resolve, reject) => {
      if (typeof GM_xmlhttpRequest !== "function") {
        reject(
          new GmHttpError(
            "unavailable",
            "当前环境不支持 GM_xmlhttpRequest，请检查脚本管理器"
          )
        );
        return;
      }
      try {
        handle = GM_xmlhttpRequest({
          method: options.method ?? "GET",
          url: options.url,
          headers: options.headers,
          data: options.data ?? void 0,
          responseType: options.responseType ?? "text",
          timeout: options.timeout ?? DEFAULT_TIMEOUT,
          onload: (response) => {
            done7();
            resolve(response);
          },
          onerror: () => {
            done7();
            reject(new GmHttpError("network", "网络错误：无法连接贴吧接口"));
          },
          ontimeout: () => {
            done7();
            reject(new GmHttpError("timeout", "请求超时，请稍后重试"));
          },
          onabort: () => {
            done7();
            reject(new GmHttpError("abort", "请求已取消"));
          }
        });
        if (handle && !settled) inFlight.add(handle);
      } catch (error) {
        done7();
        reject(
          new GmHttpError(
            "unavailable",
            `发起请求失败：${error instanceof Error ? error.message : String(error)}`
          )
        );
      }
    });
    return {
      promise: promise3,
      abort: () => {
        if (settled) return;
        try {
          handle?.abort();
        } catch {
        }
        done7();
      }
    };
  }
  function gmRequest(options) {
    return gmRequestHandle(options).promise;
  }

  // src/core/queue.ts
  var SerialQueue = class {
    constructor(minIntervalMs) {
      this.minIntervalMs = minIntervalMs;
      this.tail = Promise.resolve();
      this.lastFinishedAt = 0;
    }
    setMinInterval(ms) {
      this.minIntervalMs = ms;
    }
    run(task) {
      const result = this.tail.then(async () => {
        const wait = this.lastFinishedAt + this.minIntervalMs - Date.now();
        if (wait > 0) {
          await new Promise((resolve) => setTimeout(resolve, wait));
        }
        try {
          return await task();
        } finally {
          this.lastFinishedAt = Date.now();
        }
      });
      this.tail = result.then(
        () => void 0,
        () => void 0
      );
      return result;
    }
  };
  var requestQueue = new SerialQueue(400);

  // src/core/panelTabs.ts
  var PANEL_TABS = [
    { id: "profile", label: "资料" },
    { id: "composition", label: "成分" },
    { id: "follow", label: "关注的人" },
    { id: "mutual", label: "共同关注" },
    { id: "forums", label: "关注的吧" },
    { id: "fans", label: "粉丝" },
    { id: "posts", label: "发帖" }
  ];
  var DEFAULT_PANEL_TAB = "profile";
  function normalizePanelTabId(value) {
    return PANEL_TABS.some((tab) => tab.id === value) ? value : DEFAULT_PANEL_TAB;
  }

  // src/core/settings.ts
  var SETTINGS_SCHEMA_VERSION = 2;
  var STORAGE_KEY = "tbEztbToolboxSettingsV1";
  var DEFAULT_SETTINGS = {
    bduss: "",
    bdussHelpUrl: "https://bduss.nest.moe/",
    minIntervalMs: 400,
    maxPagesPerList: 50,
    compositionRules: "",
    compositionAuto: true,
    compositionMaxPerPage: 20,
    compositionPages: 1,
    compositionKeywordMatch: "contains",
    compositionCacheDays: 3,
    signInLevelThreshold: 6,
    defaultTab: DEFAULT_PANEL_TAB,
    rememberLastTab: false,
    selfIdentity: ""
  };
  var cache2 = null;
  function clampNumber(value, fallback, min4, max6 = Number.POSITIVE_INFINITY) {
    const num = typeof value === "number" ? value : Number(value);
    if (!Number.isFinite(num) || num < min4) return fallback;
    return Math.min(num, max6);
  }
  function readString(value, fallback) {
    return typeof value === "string" ? value : fallback;
  }
  function normalizeSettings(input) {
    const raw = input && typeof input === "object" ? input : {};
    return {
      bduss: readString(raw.bduss, DEFAULT_SETTINGS.bduss).trim(),
      bdussHelpUrl: readString(raw.bdussHelpUrl, DEFAULT_SETTINGS.bdussHelpUrl),
      minIntervalMs: clampNumber(
        raw.minIntervalMs,
        DEFAULT_SETTINGS.minIntervalMs,
        0
      ),
      maxPagesPerList: clampNumber(
        raw.maxPagesPerList,
        DEFAULT_SETTINGS.maxPagesPerList,
        1
      ),
      compositionRules: readString(
        raw.compositionRules,
        DEFAULT_SETTINGS.compositionRules
      ),
      compositionAuto: raw.compositionAuto !== false,
      compositionMaxPerPage: clampNumber(
        raw.compositionMaxPerPage,
        DEFAULT_SETTINGS.compositionMaxPerPage,
        1,
        200
      ),
      compositionPages: clampNumber(
        raw.compositionPages,
        DEFAULT_SETTINGS.compositionPages,
        1,
        10
      ),
      compositionKeywordMatch: raw.compositionKeywordMatch === "exact" ? "exact" : "contains",
      compositionCacheDays: clampNumber(
        raw.compositionCacheDays,
        DEFAULT_SETTINGS.compositionCacheDays,
        1,
        365
      ),
      signInLevelThreshold: clampNumber(
        raw.signInLevelThreshold,
        DEFAULT_SETTINGS.signInLevelThreshold,
        1,
        18
      ),
      defaultTab: normalizePanelTabId(raw.defaultTab),
      rememberLastTab: raw.rememberLastTab === true,
      selfIdentity: readString(raw.selfIdentity, DEFAULT_SETTINGS.selfIdentity).trim()
    };
  }
  var MIGRATIONS = {
    1: (raw) => raw
  };
  function readRaw() {
    try {
      const stored = GM_getValue(STORAGE_KEY, {});
      return stored && typeof stored === "object" ? stored : {};
    } catch {
      return {};
    }
  }
  function migrate(raw) {
    const startVersion = typeof raw.schemaVersion === "number" && raw.schemaVersion >= 1 ? raw.schemaVersion : 1;
    let current = raw;
    let version = startVersion;
    while (version < SETTINGS_SCHEMA_VERSION) {
      const step4 = MIGRATIONS[version];
      current = step4 ? step4(current) : current;
      version += 1;
    }
    return {
      settings: normalizeSettings(current),
      /*
       * 只有「从旧版本升上来」才回写存储。
       *
       * 反过来（存储里的版本比本脚本新，比如用户装过更新的版本又退回旧版）**不能**回写：
       * 回写会把这一版不认识的字段（`normalizeSettings` 会丢掉未知键）从存储里抹掉，
       * 等用户再升回去时，那些设置就永久没了。不加 `changed` 时读一次就覆盖一次。
       */
      changed: startVersion < SETTINGS_SCHEMA_VERSION
    };
  }
  function persist(settings) {
    try {
      GM_setValue(STORAGE_KEY, {
        ...settings,
        schemaVersion: SETTINGS_SCHEMA_VERSION
      });
    } catch (error) {
      log.warn("设置写入油猴存储失败：", error);
    }
  }
  function getSettings() {
    if (!cache2) {
      const { settings, changed } = migrate(readRaw());
      cache2 = settings;
      if (changed) persist(settings);
    }
    return cache2;
  }
  function updateSettings(patch9) {
    const next4 = normalizeSettings({ ...getSettings(), ...patch9 });
    cache2 = next4;
    persist(next4);
    return next4;
  }
  function hasBduss() {
    return getSettings().bduss.trim().length > 0;
  }
  var SETTINGS_EXPORT_FORMAT = "eztb-toolbox-settings";
  function toPortable(settings) {
    const { bduss: _bduss, ...rest } = settings;
    return rest;
  }
  function exportSettingsJson(now = /* @__PURE__ */ new Date()) {
    const payload = {
      _format: SETTINGS_EXPORT_FORMAT,
      schemaVersion: SETTINGS_SCHEMA_VERSION,
      exportedAt: now.toISOString(),
      settings: toPortable(getSettings())
    };
    return JSON.stringify(payload, null, 2);
  }
  function importSettingsJson(text) {
    const trimmed = text.trim();
    if (!trimmed) return { ok: false, reason: "内容是空的" };
    let parsed;
    try {
      parsed = JSON.parse(trimmed);
    } catch (error) {
      return {
        ok: false,
        reason: `不是合法的 JSON：${error instanceof Error ? error.message : String(error)}`
      };
    }
    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
      return { ok: false, reason: "顶层必须是一个对象" };
    }
    const holder = parsed;
    const format5 = holder._format;
    if (typeof format5 === "string" && format5 !== SETTINGS_EXPORT_FORMAT) {
      return { ok: false, reason: `不是本脚本导出的设置（_format = ${format5}）` };
    }
    if ("settings" in holder && holder.settings !== void 0) {
      if (!holder.settings || typeof holder.settings !== "object" || Array.isArray(holder.settings)) {
        return { ok: false, reason: "settings 字段必须是一个对象" };
      }
    }
    const body = holder.settings ? holder.settings : holder;
    const { bduss: _ignored, ...safe } = body;
    const merged = normalizeSettings({ ...getSettings(), ...safe });
    merged.bduss = getSettings().bduss;
    cache2 = merged;
    persist(merged);
    return { ok: true, settings: merged };
  }

  // src/core/util.ts
  function escapeHtml(value) {
    return String(value ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
  }
  function cleanText(el) {
    return el?.textContent ? el.textContent.replace(/\s+/g, " ").trim() : "";
  }
  function decodeUserName(value) {
    const str = String(value ?? "").trim();
    if (!str || !/%[0-9A-F]{2}/i.test(str)) return str;
    try {
      return decodeURIComponent(str);
    } catch {
      try {
        const decoder = new TextDecoder("gbk");
        return str.replace(
          /(?:%[0-9A-F]{2})+/gi,
          (segment) => decoder.decode(
            new Uint8Array(
              segment.slice(1).split("%").map((hex) => Number.parseInt(hex, 16))
            )
          )
        );
      } catch {
        return str;
      }
    }
  }
  function stripPortraitQuery(portrait) {
    return String(portrait ?? "").split("?")[0];
  }
  function portraitUrl(portrait) {
    const clean = stripPortraitQuery(portrait);
    if (!clean) return "";
    return `https://gss0.bdstatic.com/6LZ1dD3d1sgCo2Kml5_Y_D3/sys/portrait/item/${clean}`;
  }
  function formatTimestamp(unixSeconds) {
    const value = Number(unixSeconds);
    if (!Number.isFinite(value) || value <= 0) return "";
    const date = new Date(value * 1e3);
    const pad = (n) => String(n).padStart(2, "0");
    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}`;
  }
  function forumUrl(name) {
    return `https://tieba.baidu.com/f?kw=${encodeURIComponent(name)}`;
  }
  function threadUrl(threadId) {
    return `https://tieba.baidu.com/p/${threadId}`;
  }
  function toNumber(value) {
    const parsed = Number(value);
    return Number.isFinite(parsed) ? parsed : 0;
  }

  // src/core/composition.ts
  var LIST_SEPARATOR = /[,，;；]+/;
  var KEYWORD_MATCH_MODES = [
    { id: "contains", label: "包含匹配（默认）" },
    { id: "exact", label: "完全匹配" }
  ];
  var EXACT_PREFIX = "=";
  function isExactKeyword(token) {
    return String(token ?? "").startsWith(EXACT_PREFIX);
  }
  function keywordText(token) {
    return isExactKeyword(token) ? String(token).slice(EXACT_PREFIX.length).trim() : String(token ?? "");
  }
  function isRiskyShortKeyword(token) {
    const text = keywordText(token);
    if (isExactKeyword(token)) return false;
    return /^[A-Za-z0-9_]+$/.test(text) && text.length <= 2;
  }
  var WORD_CHAR = /[A-Za-z0-9_]/;
  function containsAsWord(text, keyword) {
    if (!keyword) return false;
    const haystack = text.toLowerCase();
    const needle = keyword.toLowerCase();
    if (/^[^A-Za-z0-9_]+$/.test(needle)) return haystack.includes(needle);
    let index = haystack.indexOf(needle);
    while (index >= 0) {
      const before2 = index > 0 ? haystack[index - 1] : "";
      const after3 = haystack[index + needle.length] ?? "";
      const leftOk = !before2 || !WORD_CHAR.test(before2);
      const rightOk = !after3 || !WORD_CHAR.test(after3);
      if (leftOk && rightOk) return true;
      index = haystack.indexOf(needle, index + 1);
    }
    return false;
  }
  function normalizeForumName(value) {
    return String(value ?? "").trim().replace(/吧$/, "").toLowerCase();
  }
  function keywordMatchesText(text, token, mode) {
    const keyword = keywordText(token);
    if (!keyword) return false;
    if (isExactKeyword(token) || mode === "exact") {
      return containsAsWord(text, keyword);
    }
    return String(text ?? "").toLowerCase().includes(keyword.toLowerCase());
  }
  function keywordMatchesForum(forumName, token, mode) {
    const keyword = keywordText(token);
    if (!keyword) return false;
    if (isExactKeyword(token) || mode === "exact") {
      return normalizeForumName(forumName) === normalizeForumName(keyword);
    }
    return String(forumName ?? "").toLowerCase().includes(keyword.toLowerCase());
  }
  var RULE_FORMAT_HINT = "每行一条：名称 | 发帖关键词 | 关注的吧关键词 | 排除关键词(可省) | 直接命中名单(可省) | 发帖所在吧关键词(可省)；关键词用逗号分隔，`#` 开头是注释；单个词前面加 `=` 表示这个词要完全匹配（例如 `=V` 只命中吧名就是 V 的，不会命中 zerosievert）。";
  var EXAMPLE_RULES = [
    "# 名称 | 发帖关键词 | 关注的关键词 | 排除关键词(可省) | 直接命中名单(可省) | 发帖所在关键词(可省)",
    "米||米哈游, 米游社, mihoyo, 反米哈游, 米哈游笑话,源初之结, 源初之结内鬼,Varsapura, varsapura内鬼,flyme2themoon,星布谷地, 星布谷地内鬼,崩坏因缘精灵, 崩坏因缘精灵内鬼, 崩坏因缘精灵爆料|||米哈游, 米游社, mihoyo, 反米哈游, 米哈游笑话,源初之结, 源初之结内鬼,Varsapura, varsapura内鬼,flyme2themoon,星布谷地, 星布谷地内鬼,崩坏因缘精灵, 崩坏因缘精灵内鬼, 崩坏因缘精灵爆料",
    "原||原神, 原神玩家, 原神2, 原神爆料,原神内鬼, 原神天堂内鬼, 原神内容讨论,原神爆料|||原神, 原神玩家, 原神2, 原神爆料,原神内鬼, 原神天堂内鬼, 原神内容讨论,原神爆料",
    "崩坏||崩坏3rd, 崩坏三, 崩坏三日服, 反崩坏3, 崩坏3交易,崩坏学园2, 崩坏学园|||崩坏3rd, 崩坏三, 崩坏三日服, 反崩坏3, 崩坏3交易,崩坏学园2, 崩坏学园",
    "崩轨||崩坏星穹铁道, 星穹铁道内鬼, 崩坏星穹铁道内鬼, 崩坏星穹铁道交易账号, 崩坏星穹铁道萌新|||崩坏星穹铁道, 星穹铁道内鬼, 崩坏星穹铁道内鬼, 崩坏星穹铁道交易账号, 崩坏星穹铁道萌新",
    "绝||绝区零,绝区零内鬼,绝区零ml,绝区零内鬼爆料,绝区零, 绝区零内鬼, 绝区零虚拟偶像, 绝区零福瑞|||绝区零,绝区零内鬼,绝区零ml,绝区零内鬼爆料,绝区零, 绝区零内鬼, 绝区零虚拟偶像, 绝区零福瑞",
    "未定||未定事件簿, 未定事件薄|||未定事件簿, 未定事件薄",
    "舟||明日方舟, 明日方舟内鬼, 明日方舟终末地, 反明日方舟, 明日方舟脚臭, 明日方舟配种, 明日方舟论战, 明日方舟豆苗,半壁江山雪之下,明日方舟pl,明日方舟dl,快乐雪花,危机合约|||明日方舟, 明日方舟内鬼, 明日方舟终末地, 反明日方舟, 明日方舟脚臭, 明日方舟配种, 明日方舟论战, 明日方舟豆苗,半壁江山雪之下,明日方舟pl,明日方舟dl,快乐雪花,危机合约",
    "舰B||碧蓝航线, 新碧蓝航线, 碧蓝航线国服, 碧蓝航线r, 碧蓝航线初月, 碧蓝航线不挠, 碧蓝航线光辉, 碧蓝航线可畏, 碧蓝航线怨仇, 碧蓝航线胜利, 碧蓝航线俾斯麦, 碧蓝航线柴郡,异色格,赤色中轴|||碧蓝航线, 新碧蓝航线, 碧蓝航线国服, 碧蓝航线r, 碧蓝航线初月, 碧蓝航线不挠, 碧蓝航线光辉, 碧蓝航线可畏, 碧蓝航线怨仇, 碧蓝航线胜利, 碧蓝航线俾斯麦, 碧蓝航线柴郡,异色格,赤色中轴",
    "旅谣||蓝色星原旅谣|||蓝色星原旅谣",
    "少前||少女前线, 少女前线r, 少女前线2, 少前2,少前r追放,少前2内鬼|||少女前线, 少女前线r, 少女前线2, 少前2,少前r追放,少前2内鬼",
    "档案||碧蓝档案, 蔚蓝档案, 蔚蓝档案国服, 蔚蓝档案社区, 反蔚蓝档案, 碧蓝档案垃圾桶,碧蓝档案吐槽|||碧蓝档案, 蔚蓝档案, 蔚蓝档案国服, 蔚蓝档案社区, 反蔚蓝档案, 碧蓝档案垃圾桶,碧蓝档案吐槽",
    "fgo||fgo, 命运冠位指定, fgo日服, fgo晒卡, 命运冠位指定交易|||fgo, 命运冠位指定, fgo日服, fgo晒卡, 命运冠位指定交易",
    "Nikke||nikke, nikke胜利女神, nikke方舟人口, nikke伊甸园, nikke外缘区, 胜利女神, 胜利女神妮姬, 尼姬胜利女神|||nikke, nikke胜利女神, nikke方舟人口, nikke伊甸园, nikke外缘区, 胜利女神, 胜利女神妮姬, 尼姬胜利女神",
    "尘白||尘白禁区, 尘白禁区埃达, 尘白禁区后勤, 尘白禁区鸣濑晴, 尘白禁区百合, 尘白禁区串子配种, 尘白禁区内鬼, 尘白禁区睡觉, 尘白禁区观光区|||尘白禁区, 尘白禁区埃达, 尘白禁区后勤, 尘白禁区鸣濑晴, 尘白禁区百合, 尘白禁区串子配种, 尘白禁区内鬼, 尘白禁区睡觉, 尘白禁区观光区",
    "无期||反无期迷途, 无期迷途交易, 无期迷途内鬼|||反无期迷途, 无期迷途交易, 无期迷途内鬼",
    "1999||重返未来1999, 重返未来1999内鬼, 重返未来1999节奏, 重返未来1999配种|||重返未来1999, 重返未来1999内鬼, 重返未来1999节奏, 重返未来1999配种",
    "鸣潮||鸣潮, 鸣潮内鬼, 鸣潮爆料, 鸣潮天堂内鬼, 鸣潮包容,旧鸣潮内鬼,新鸣潮内鬼,北落野|||鸣潮, 鸣潮内鬼, 鸣潮爆料, 鸣潮天堂内鬼, 鸣潮包容,旧鸣潮内鬼,新鸣潮内鬼,北落野",
    "战双||战双帕弥什, 战双, 升格网络|||战双帕弥什, 战双, 升格网络",
    "偷玩||有男偷玩|||有男偷玩",
    "辣仙||有男不玩ml|||有男不玩ml",
    "红烧天堂||heavenburnsred|||heavenburnsred",
    "二笑||二游笑话|||二游笑话",
    "笑话||dinner笑话,伪史笑话,皇汉笑话,galgame笑话|||dinner笑话,伪史笑话,皇汉笑话,galgame笑话",
    "异环||异环, 异环内鬼, 异环人口, 异环爆料, 异环交易, 异环买卖, 异环代练, 幻塔异环, 异环手游, 异环终极内鬼|||异环, 异环内鬼, 异环人口, 异环爆料, 异环交易, 异环买卖, 异环代练, 幻塔异环, 异环手游, 异环终极内鬼",
    "百合||偶像大师,学园偶像大师,偶像大师闪耀色彩,东方,东方幻想魔录,隔壁东方,东方口袋战争,反百破,百合,新百合,魔法少女的魔女裁判,光之美少女,萌战|||偶像大师,学园偶像大师,偶像大师闪耀色彩,东方,东方幻想魔录,隔壁东方,东方口袋战争,反百破,百合,新百合,魔法少女的魔女裁判,光之美少女,萌战",
    "边狱||边狱公司|||边狱公司",
    "圆规||原神内鬼,原神内鬼避风港|||原神内鬼,原神内鬼避风港",
    "V||asoul,=V|||asoul,=V",
    "bang||bangdream,bangdream国服,邦多利声优,笔记紫,梦想紫,avemujica|||bangdream,bangdream国服,邦多利声优,笔记紫,梦想紫,avemujica",
    "⭕️||反激女|||反激女",
    "同||燕淋十六声,淋神,王者淋耀,欧美后花园,lol淋价,淋日方舟,淋,极地大乱斗,新极地大乱斗|||燕淋十六声,淋神,王者淋耀,欧美后花园,lol淋价,淋日方舟,淋,极地大乱斗,新极地大乱斗",
    "鉴证||航空母舰,中国人口,椎名立希吐槽,小王避难所,朴正熙,印度|||航空母舰,中国人口,椎名立希吐槽,小王避难所,朴正熙,印度"
  ].join("\n");
  function splitList(value) {
    if (!value) return [];
    const seen = /* @__PURE__ */ new Set();
    const out = [];
    for (const item of value.split(LIST_SEPARATOR)) {
      const token = item.trim();
      if (!token) continue;
      const key = token.toLowerCase();
      if (seen.has(key)) continue;
      seen.add(key);
      out.push(token);
    }
    return out;
  }
  function parseRulesDetailed(text) {
    const rules = [];
    const issues2 = [];
    const seen = /* @__PURE__ */ new Map();
    const lines = String(text ?? "").split(/\r?\n/);
    lines.forEach((rawLine, index) => {
      const lineNumber = index + 1;
      const line = rawLine.trim();
      if (!line || line.startsWith("#")) return;
      const brief = line.length > 60 ? `${line.slice(0, 60)}…` : line;
      const parts2 = line.split("|").map((part) => part.trim());
      const name = parts2[0];
      if (!name) {
        issues2.push({
          line: lineNumber,
          text: brief,
          level: "error",
          message: "这一行没有名称（`|` 前面是空的），整行被忽略。"
        });
        return;
      }
      if (parts2.length > 6) {
        issues2.push({
          line: lineNumber,
          text: brief,
          level: "warn",
          message: `这一行有 ${parts2.length} 段，第 7 段起会被忽略（格式只有 6 段）。`
        });
      }
      const rule = {
        name,
        postKeywords: splitList(parts2[1]),
        forumKeywords: splitList(parts2[2]),
        excludes: splitList(parts2[3]),
        uids: splitList(parts2[4]),
        postForumKeywords: splitList(parts2[5])
      };
      for (const [field, values3] of [
        ["发帖关键词", rule.postKeywords],
        ["关注的吧关键词", rule.forumKeywords],
        ["排除关键词", rule.excludes],
        ["发帖所在吧关键词", rule.postForumKeywords]
      ]) {
        const spaced3 = values3.find((value) => /\s/.test(value));
        if (spaced3) {
          issues2.push({
            line: lineNumber,
            text: brief,
            level: "warn",
            message: `${field}里的「${spaced3}」带空格。脚本**不按空格切分**关键词，它会被当成一个整词；如果那是两个词，请用逗号分开。`
          });
        }
      }
      for (const [field, values3] of [
        ["发帖关键词", rule.postKeywords],
        ["关注的吧关键词", rule.forumKeywords],
        ["排除关键词", rule.excludes],
        ["发帖所在吧关键词", rule.postForumKeywords]
      ]) {
        const risky = values3.find((value) => isRiskyShortKeyword(value));
        if (risky) {
          issues2.push({
            line: lineNumber,
            text: brief,
            level: "warn",
            message: `${field}里的「${keywordText(risky)}」很短，用包含匹配会命中无关内容（实测：关键词 V 命中了「zerosievert吧」）。要精确匹配就写成 =${keywordText(risky)}。`
          });
        }
      }
      const overlap = rule.postKeywords.filter(
        (keyword) => rule.excludes.some((item) => item.toLowerCase() === keyword.toLowerCase())
      );
      if (overlap.length) {
        issues2.push({
          line: lineNumber,
          text: brief,
          level: "warn",
          message: `「${overlap.join("、")}」同时出现在发帖关键词与排除关键词里，这条证据永远会被自己否决。`
        });
      }
      if (!rule.postKeywords.length && !rule.forumKeywords.length && !rule.postForumKeywords.length && !rule.uids.length) {
        issues2.push({
          line: lineNumber,
          text: brief,
          level: "warn",
          message: "这一行只有名称，没有任何条件，被忽略了（至少要有发帖关键词 / 关注的吧 / 名单 / 发帖所在吧 之一）。"
        });
        return;
      }
      const key = name.toLowerCase();
      const firstLine = seen.get(key);
      if (firstLine !== void 0) {
        issues2.push({
          line: lineNumber,
          text: brief,
          level: "warn",
          message: `与第 ${firstLine} 行的规则同名，只保留第一条。`
        });
        return;
      }
      seen.set(key, lineNumber);
      rules.push(rule);
    });
    return { rules, issues: issues2 };
  }
  function parseRules(text) {
    return parseRulesDetailed(text).rules;
  }
  function hashRules(text) {
    const normalized = JSON.stringify(parseRules(text));
    let hash2 = 5381;
    for (let index = 0; index < normalized.length; index += 1) {
      hash2 = (hash2 << 5) + hash2 + normalized.charCodeAt(index) | 0;
    }
    return (hash2 >>> 0).toString(36);
  }
  var POST_KIND_TEXT = {
    topic: "主题帖",
    reply: "回复",
    sub: "楼中楼"
  };
  function evidencePost(post) {
    return {
      kind: post.kind,
      forumName: String(post.forumName ?? "").trim(),
      title: post.title ?? "",
      preview: post.preview ?? "",
      createTime: post.createTime,
      threadId: post.threadId,
      postId: post.postId,
      replyTo: post.replyTo
    };
  }
  function firstKeywordText(text, keywords, mode) {
    for (const keyword of keywords) {
      if (keywordMatchesText(text, keyword, mode)) return keywordText(keyword);
    }
    return "";
  }
  function firstKeywordForum(forumName, keywords, mode) {
    for (const keyword of keywords) {
      if (keywordMatchesForum(forumName, keyword, mode)) {
        return keywordText(keyword);
      }
    }
    return "";
  }
  function isExcluded(text, excludes, mode) {
    return excludes.some((word) => keywordMatchesText(text, word, mode));
  }
  function excerptAround(text, keyword, width = 40) {
    const source = String(text ?? "").replace(/\s+/g, " ").trim();
    if (!source) return "";
    const index = source.toLowerCase().indexOf(keyword.toLowerCase());
    if (index < 0) return source.slice(0, width * 2);
    const start3 = Math.max(0, index - width);
    const end3 = Math.min(source.length, index + keyword.length + width);
    return (start3 > 0 ? "…" : "") + source.slice(start3, end3) + (end3 < source.length ? "…" : "");
  }
  function sortEvidencesByRecency(evidences) {
    return evidences.map((evidence, index) => ({ evidence, index })).sort((a, b) => {
      const left3 = Number(a.evidence.at ?? 0);
      const right3 = Number(b.evidence.at ?? 0);
      if (left3 !== right3) return right3 - left3;
      return a.index - b.index;
    }).map((item) => item.evidence);
  }
  function newestEvidenceAt(hit) {
    let newest = 0;
    for (const evidence of hit.evidences) {
      const at = Number(evidence.at ?? 0);
      if (at > newest) newest = at;
    }
    return newest;
  }
  function sortHitsByRecency(hits) {
    return hits.map((hit, index) => ({
      hit: { ...hit, evidences: sortEvidencesByRecency(hit.evidences) },
      index,
      newest: newestEvidenceAt(hit)
    })).sort((a, b) => {
      if (a.newest !== b.newest) return b.newest - a.newest;
      return a.index - b.index;
    }).map((item) => item.hit);
  }
  function matchComposition(input, rules, options = {}) {
    const mode = options.mode ?? "contains";
    const hits = [];
    const ids3 = [input.uid, input.userId ? String(input.userId) : ""].map((value) => String(value ?? "").trim()).filter(Boolean);
    for (const rule of rules) {
      const evidences = [];
      const matchedUid = rule.uids.find((uid) => ids3.includes(uid.trim()));
      if (matchedUid) {
        evidences.push({
          source: "uid",
          keyword: matchedUid,
          reason: "在名单里",
          excerpt: "",
          sure: true
        });
      }
      for (const forum of input.forums) {
        if (isExcluded(forum, rule.excludes, mode)) continue;
        const keyword = firstKeywordForum(forum, rule.forumKeywords, mode);
        if (!keyword) continue;
        evidences.push({
          source: "forum",
          keyword,
          reason: `关注了「${forum}」`,
          excerpt: "",
          sure: true
        });
        break;
      }
      let postForumEvidence = null;
      for (const post of input.posts) {
        const name = String(post.forumName ?? "").trim();
        if (!name || isExcluded(name, rule.excludes, mode)) continue;
        const keyword = firstKeywordForum(name, rule.postForumKeywords, mode);
        if (!keyword) continue;
        const evidence = {
          source: "postForum",
          keyword,
          reason: `在「${name}」发过帖`,
          excerpt: [post.title, post.preview].filter(Boolean).join(" ").slice(0, 60),
          sure: post.kind === "topic",
          at: post.createTime,
          post: evidencePost(post)
        };
        postForumEvidence = evidence;
        if (evidence.sure) break;
      }
      if (postForumEvidence) evidences.push(postForumEvidence);
      let postEvidence = null;
      for (const post of input.posts) {
        const text = [post.title, post.preview].filter(Boolean).join(" ");
        if (!text || isExcluded(text, rule.excludes, mode)) continue;
        const keyword = firstKeywordText(text, rule.postKeywords, mode);
        if (!keyword) continue;
        const evidence = {
          source: "post",
          keyword,
          reason: `${POST_KIND_TEXT[post.kind]}命中`,
          excerpt: excerptAround(text, keyword),
          sure: post.kind === "topic",
          at: post.createTime,
          post: evidencePost(post)
        };
        postEvidence = evidence;
        if (evidence.sure) break;
      }
      if (postEvidence) evidences.push(postEvidence);
      if (!evidences.length) continue;
      hits.push({
        rule,
        evidences,
        sure: evidences.some((evidence) => evidence.sure),
        summary: evidences.map(
          (evidence) => evidence.source === "post" ? `${evidence.reason}「${evidence.keyword}」` : evidence.reason
        ).join("；")
      });
    }
    return sortHitsByRecency(hits);
  }
  function compositionVerdict(input) {
    if (input.hits > 0) return { insufficient: false, note: "" };
    const reasons = [];
    if (input.failed.length) {
      reasons.push(
        `有 ${input.failed.length} 路数据没取到（${input.failed.map((item) => item.split("：")[0]).join("、")}）`
      );
    }
    if (input.hidden) reasons.push("对方把发帖记录设为私密");
    if (input.needPosts && !input.hidden && input.failed.length === 0 && input.posts === 0) {
      reasons.push("一条发帖记录都没读到");
    }
    if (input.needForums && input.failed.length === 0 && input.forums === 0) {
      reasons.push("关注贴吧列表是空的（对方可能隐藏了它）");
    }
    if (!reasons.length) return { insufficient: false, note: "" };
    return {
      insufficient: true,
      note: `证据不足：${reasons.join("；")}。这不等于「没有命中」。`
    };
  }
  function highlightKeywords(text, keywords) {
    const source = String(text ?? "");
    const keys5 = keywords.map((keyword) => String(keyword ?? "").trim()).filter(Boolean);
    if (!source || !keys5.length) return escapeHtml(source);
    const lower = source.toLowerCase();
    const ranges = [];
    for (const key of keys5) {
      const needle = key.toLowerCase();
      let from = lower.indexOf(needle);
      while (from >= 0) {
        ranges.push([from, from + needle.length]);
        from = lower.indexOf(needle, from + needle.length);
      }
    }
    if (!ranges.length) return escapeHtml(source);
    ranges.sort((a, b) => a[0] - b[0]);
    const merged = [];
    for (const range of ranges) {
      const last3 = merged[merged.length - 1];
      if (last3 && range[0] <= last3[1]) {
        last3[1] = Math.max(last3[1], range[1]);
      } else {
        merged.push([range[0], range[1]]);
      }
    }
    let out = "";
    let cursor = 0;
    for (const [start3, end3] of merged) {
      out += escapeHtml(source.slice(cursor, start3));
      out += `<mark class="tb-eztb-mark">${escapeHtml(source.slice(start3, end3))}</mark>`;
      cursor = end3;
    }
    out += escapeHtml(source.slice(cursor));
    return out;
  }
  function badgeHue(name) {
    let hash2 = 0;
    for (let index = 0; index < name.length; index += 1) {
      hash2 = hash2 * 31 + name.charCodeAt(index) | 0;
    }
    return Math.abs(hash2) % 360;
  }

  // src/core/compositionCache.ts
  var CACHE_KEY2 = "tbEztbToolboxCompositionCacheV1";
  var CACHE_MAX2 = 300;
  var CACHE_SCHEMA = 2;
  function ttlMs() {
    const days2 = Number(getSettings().compositionCacheDays);
    const safe = Number.isFinite(days2) && days2 > 0 ? days2 : 3;
    return safe * 24 * 60 * 60 * 1e3;
  }
  var cache3 = createKvCache({
    storageKey: CACHE_KEY2,
    max: CACHE_MAX2,
    ttlMs
  });
  function compositionCacheKey(ref) {
    return profileCacheKey(ref);
  }
  function readCompositionCache(key, rulesHash2) {
    if (!key) return null;
    const hit = cache3.read(key);
    if (!hit || hit.rulesHash !== rulesHash2) {
      if (hit) cache3.delete(key);
      return null;
    }
    if (hit.schema !== CACHE_SCHEMA) {
      cache3.delete(key);
      return null;
    }
    return hit;
  }
  function writeCompositionCache(key, entry) {
    if (!key) return;
    cache3.write(key, { ...entry, schema: CACHE_SCHEMA });
  }
  function dropCompositionMemory() {
    cache3.clearMemory();
  }
  function clearCompositionCache() {
    cache3.clear();
  }

  // <eztb>/node_modules/effect/dist/esm/Function.js
  var isFunction = (input) => typeof input === "function";
  var dual = function(arity, body) {
    if (typeof arity === "function") {
      return function() {
        if (arity(arguments)) {
          return body.apply(this, arguments);
        }
        return (self) => body(self, ...arguments);
      };
    }
    switch (arity) {
      case 0:
      case 1:
        throw new RangeError(`Invalid arity ${arity}`);
      case 2:
        return function(a, b) {
          if (arguments.length >= 2) {
            return body(a, b);
          }
          return function(self) {
            return body(self, a);
          };
        };
      case 3:
        return function(a, b, c) {
          if (arguments.length >= 3) {
            return body(a, b, c);
          }
          return function(self) {
            return body(self, a, b);
          };
        };
      case 4:
        return function(a, b, c, d) {
          if (arguments.length >= 4) {
            return body(a, b, c, d);
          }
          return function(self) {
            return body(self, a, b, c);
          };
        };
      case 5:
        return function(a, b, c, d, e) {
          if (arguments.length >= 5) {
            return body(a, b, c, d, e);
          }
          return function(self) {
            return body(self, a, b, c, d);
          };
        };
      default:
        return function() {
          if (arguments.length >= arity) {
            return body.apply(this, arguments);
          }
          const args2 = arguments;
          return function(self) {
            return body(self, ...args2);
          };
        };
    }
  };
  var identity = (a) => a;
  var constant = (value) => () => value;
  var constTrue = /* @__PURE__ */ constant(true);
  var constFalse = /* @__PURE__ */ constant(false);
  var constNull = /* @__PURE__ */ constant(null);
  var constUndefined = /* @__PURE__ */ constant(void 0);
  var constVoid = constUndefined;
  function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
    switch (arguments.length) {
      case 1:
        return a;
      case 2:
        return ab(a);
      case 3:
        return bc(ab(a));
      case 4:
        return cd(bc(ab(a)));
      case 5:
        return de(cd(bc(ab(a))));
      case 6:
        return ef(de(cd(bc(ab(a)))));
      case 7:
        return fg(ef(de(cd(bc(ab(a))))));
      case 8:
        return gh(fg(ef(de(cd(bc(ab(a)))))));
      case 9:
        return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
      default: {
        let ret = arguments[0];
        for (let i = 1; i < arguments.length; i++) {
          ret = arguments[i](ret);
        }
        return ret;
      }
    }
  }

  // <eztb>/node_modules/effect/dist/esm/Either.js
  var Either_exports = {};
  __export(Either_exports, {
    Do: () => Do,
    TypeId: () => TypeId3,
    all: () => all,
    andThen: () => andThen,
    ap: () => ap,
    bind: () => bind2,
    bindTo: () => bindTo2,
    filterOrLeft: () => filterOrLeft,
    flatMap: () => flatMap,
    flip: () => flip,
    fromNullable: () => fromNullable,
    fromOption: () => fromOption2,
    gen: () => gen,
    getEquivalence: () => getEquivalence,
    getLeft: () => getLeft2,
    getOrElse: () => getOrElse,
    getOrNull: () => getOrNull,
    getOrThrow: () => getOrThrow,
    getOrThrowWith: () => getOrThrowWith,
    getOrUndefined: () => getOrUndefined,
    getRight: () => getRight2,
    isEither: () => isEither2,
    isLeft: () => isLeft2,
    isRight: () => isRight2,
    left: () => left2,
    let: () => let_2,
    liftPredicate: () => liftPredicate,
    map: () => map,
    mapBoth: () => mapBoth,
    mapLeft: () => mapLeft,
    match: () => match,
    merge: () => merge,
    orElse: () => orElse,
    right: () => right2,
    transposeMapOption: () => transposeMapOption,
    transposeOption: () => transposeOption,
    try: () => try_,
    void: () => void_,
    zipWith: () => zipWith
  });

  // <eztb>/node_modules/effect/dist/esm/Equivalence.js
  var make = (isEquivalent) => (self, that) => self === that || isEquivalent(self, that);
  var isStrictEquivalent = (x, y) => x === y;
  var strict = () => isStrictEquivalent;
  var number = /* @__PURE__ */ strict();
  var mapInput = /* @__PURE__ */ dual(2, (self, f) => make((x, y) => self(f(x), f(y))));
  var array = (item) => make((self, that) => {
    if (self.length !== that.length) {
      return false;
    }
    for (let i = 0; i < self.length; i++) {
      const isEq = item(self[i], that[i]);
      if (!isEq) {
        return false;
      }
    }
    return true;
  });

  // <eztb>/node_modules/effect/dist/esm/internal/doNotation.js
  var let_ = (map14) => dual(3, (self, name, f) => map14(self, (a) => ({
    ...a,
    [name]: f(a)
  })));
  var bindTo = (map14) => dual(2, (self, name) => map14(self, (a) => ({
    [name]: a
  })));
  var bind = (map14, flatMap11) => dual(3, (self, name, f) => flatMap11(self, (a) => map14(f(a), (b) => ({
    ...a,
    [name]: b
  }))));

  // <eztb>/node_modules/effect/dist/esm/GlobalValue.js
  var globalStoreId = `effect/GlobalValue`;
  var globalStore;
  var globalValue = (id, compute) => {
    if (!globalStore) {
      globalThis[globalStoreId] ?? (globalThis[globalStoreId] = /* @__PURE__ */ new Map());
      globalStore = globalThis[globalStoreId];
    }
    if (!globalStore.has(id)) {
      globalStore.set(id, compute());
    }
    return globalStore.get(id);
  };

  // <eztb>/node_modules/effect/dist/esm/Predicate.js
  var isString = (input) => typeof input === "string";
  var isNumber = (input) => typeof input === "number";
  var isBigInt = (input) => typeof input === "bigint";
  var isFunction2 = isFunction;
  var isRecordOrArray = (input) => typeof input === "object" && input !== null;
  var isObject = (input) => isRecordOrArray(input) || isFunction2(input);
  var hasProperty = /* @__PURE__ */ dual(2, (self, property) => isObject(self) && property in self);
  var isTagged = /* @__PURE__ */ dual(2, (self, tag) => hasProperty(self, "_tag") && self["_tag"] === tag);
  var isNullable = (input) => input === null || input === void 0;
  var isIterable = (input) => typeof input === "string" || hasProperty(input, Symbol.iterator);
  var isPromiseLike = (input) => hasProperty(input, "then") && isFunction2(input.then);

  // <eztb>/node_modules/effect/dist/esm/internal/errors.js
  var getBugErrorMessage = (message) => `BUG: ${message} - please report an issue at https://github.com/Effect-TS/effect/issues`;

  // <eztb>/node_modules/effect/dist/esm/Utils.js
  var GenKindTypeId = /* @__PURE__ */ Symbol.for("effect/Gen/GenKind");
  var isGenKind = (u) => isObject(u) && GenKindTypeId in u;
  var _a;
  var GenKindImpl = class {
    constructor(value) {
      __publicField(this, "value");
      /**
       * @since 2.0.0
       */
      __publicField(this, _a, GenKindTypeId);
      this.value = value;
    }
    /**
     * @since 2.0.0
     */
    get _F() {
      return identity;
    }
    /**
     * @since 2.0.0
     */
    get _R() {
      return (_) => _;
    }
    /**
     * @since 2.0.0
     */
    get _O() {
      return (_) => _;
    }
    /**
     * @since 2.0.0
     */
    get _E() {
      return (_) => _;
    }
    /**
     * @since 2.0.0
     */
    [(_a = GenKindTypeId, Symbol.iterator)]() {
      return new SingleShotGen(this);
    }
  };
  var SingleShotGen = class _SingleShotGen {
    constructor(self) {
      __publicField(this, "self");
      __publicField(this, "called", false);
      this.self = self;
    }
    /**
     * @since 2.0.0
     */
    next(a) {
      return this.called ? {
        value: a,
        done: true
      } : (this.called = true, {
        value: this.self,
        done: false
      });
    }
    /**
     * @since 2.0.0
     */
    return(a) {
      return {
        value: a,
        done: true
      };
    }
    /**
     * @since 2.0.0
     */
    throw(e) {
      throw e;
    }
    /**
     * @since 2.0.0
     */
    [Symbol.iterator]() {
      return new _SingleShotGen(this.self);
    }
  };
  var adapter = () => function() {
    let x = arguments[0];
    for (let i = 1; i < arguments.length; i++) {
      x = arguments[i](x);
    }
    return new GenKindImpl(x);
  };
  var defaultIncHi = 335903614;
  var defaultIncLo = 4150755663;
  var MUL_HI = 1481765933 >>> 0;
  var MUL_LO = 1284865837 >>> 0;
  var BIT_53 = 9007199254740992;
  var BIT_27 = 134217728;
  var PCGRandom = class {
    constructor(seedHi, seedLo, incHi, incLo) {
      __publicField(this, "_state");
      if (isNullable(seedLo) && isNullable(seedHi)) {
        seedLo = Math.random() * 4294967295 >>> 0;
        seedHi = 0;
      } else if (isNullable(seedLo)) {
        seedLo = seedHi;
        seedHi = 0;
      }
      if (isNullable(incLo) && isNullable(incHi)) {
        incLo = this._state ? this._state[3] : defaultIncLo;
        incHi = this._state ? this._state[2] : defaultIncHi;
      } else if (isNullable(incLo)) {
        incLo = incHi;
        incHi = 0;
      }
      this._state = new Int32Array([0, 0, incHi >>> 0, ((incLo || 0) | 1) >>> 0]);
      this._next();
      add64(this._state, this._state[0], this._state[1], seedHi >>> 0, seedLo >>> 0);
      this._next();
      return this;
    }
    /**
     * Returns a copy of the internal state of this random number generator as a
     * JavaScript Array.
     *
     * @category getters
     * @since 2.0.0
     */
    getState() {
      return [this._state[0], this._state[1], this._state[2], this._state[3]];
    }
    /**
     * Restore state previously retrieved using `getState()`.
     *
     * @since 2.0.0
     */
    setState(state) {
      this._state[0] = state[0];
      this._state[1] = state[1];
      this._state[2] = state[2];
      this._state[3] = state[3] | 1;
    }
    /**
     * Get a uniformly distributed 32 bit integer between [0, max).
     *
     * @category getter
     * @since 2.0.0
     */
    integer(max6) {
      return Math.round(this.number() * Number.MAX_SAFE_INTEGER) % max6;
    }
    /**
     * Get a uniformly distributed IEEE-754 double between 0.0 and 1.0, with
     * 53 bits of precision (every bit of the mantissa is randomized).
     *
     * @category getters
     * @since 2.0.0
     */
    number() {
      const hi = (this._next() & 67108863) * 1;
      const lo = (this._next() & 134217727) * 1;
      return (hi * BIT_27 + lo) / BIT_53;
    }
    /** @internal */
    _next() {
      const oldHi = this._state[0] >>> 0;
      const oldLo = this._state[1] >>> 0;
      mul64(this._state, oldHi, oldLo, MUL_HI, MUL_LO);
      add64(this._state, this._state[0], this._state[1], this._state[2], this._state[3]);
      let xsHi = oldHi >>> 18;
      let xsLo = (oldLo >>> 18 | oldHi << 14) >>> 0;
      xsHi = (xsHi ^ oldHi) >>> 0;
      xsLo = (xsLo ^ oldLo) >>> 0;
      const xorshifted = (xsLo >>> 27 | xsHi << 5) >>> 0;
      const rot = oldHi >>> 27;
      const rot2 = (-rot >>> 0 & 31) >>> 0;
      return (xorshifted >>> rot | xorshifted << rot2) >>> 0;
    }
  };
  function mul64(out, aHi, aLo, bHi, bLo) {
    let c1 = (aLo >>> 16) * (bLo & 65535) >>> 0;
    let c0 = (aLo & 65535) * (bLo >>> 16) >>> 0;
    let lo = (aLo & 65535) * (bLo & 65535) >>> 0;
    let hi = (aLo >>> 16) * (bLo >>> 16) + ((c0 >>> 16) + (c1 >>> 16)) >>> 0;
    c0 = c0 << 16 >>> 0;
    lo = lo + c0 >>> 0;
    if (lo >>> 0 < c0 >>> 0) {
      hi = hi + 1 >>> 0;
    }
    c1 = c1 << 16 >>> 0;
    lo = lo + c1 >>> 0;
    if (lo >>> 0 < c1 >>> 0) {
      hi = hi + 1 >>> 0;
    }
    hi = hi + Math.imul(aLo, bHi) >>> 0;
    hi = hi + Math.imul(aHi, bLo) >>> 0;
    out[0] = hi;
    out[1] = lo;
  }
  function add64(out, aHi, aLo, bHi, bLo) {
    let hi = aHi + bHi >>> 0;
    const lo = aLo + bLo >>> 0;
    if (lo >>> 0 < aLo >>> 0) {
      hi = hi + 1 | 0;
    }
    out[0] = hi;
    out[1] = lo;
  }
  var YieldWrapTypeId = /* @__PURE__ */ Symbol.for("effect/Utils/YieldWrap");
  var _value;
  var YieldWrap = class {
    constructor(value) {
      /**
       * @since 3.0.6
       */
      __privateAdd(this, _value);
      __privateSet(this, _value, value);
    }
    /**
     * @since 3.0.6
     */
    [YieldWrapTypeId]() {
      return __privateGet(this, _value);
    }
  };
  _value = new WeakMap();
  function yieldWrapGet(self) {
    if (typeof self === "object" && self !== null && YieldWrapTypeId in self) {
      return self[YieldWrapTypeId]();
    }
    throw new Error(getBugErrorMessage("yieldWrapGet"));
  }
  var structuralRegionState = /* @__PURE__ */ globalValue("effect/Utils/isStructuralRegion", () => ({
    enabled: false,
    tester: void 0
  }));
  var standard = {
    effect_internal_function: (body) => {
      return body();
    }
  };
  var forced = {
    effect_internal_function: (body) => {
      try {
        return body();
      } finally {
      }
    }
  };
  var isNotOptimizedAway = /* @__PURE__ */ standard.effect_internal_function(() => new Error().stack)?.includes("effect_internal_function") === true;
  var internalCall = isNotOptimizedAway ? standard.effect_internal_function : forced.effect_internal_function;
  var genConstructor = function* () {
  }.constructor;
  var isGeneratorFunction = (u) => isObject(u) && u.constructor === genConstructor;

  // <eztb>/node_modules/effect/dist/esm/Hash.js
  var randomHashCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Hash/randomHashCache"), () => /* @__PURE__ */ new WeakMap());
  var symbol = /* @__PURE__ */ Symbol.for("effect/Hash");
  var hash = (self) => {
    if (structuralRegionState.enabled === true) {
      return 0;
    }
    switch (typeof self) {
      case "number":
        return number2(self);
      case "bigint":
        return string(self.toString(10));
      case "boolean":
        return string(String(self));
      case "symbol":
        return string(String(self));
      case "string":
        return string(self);
      case "undefined":
        return string("undefined");
      case "function":
      case "object": {
        if (self === null) {
          return string("null");
        } else if (self instanceof Date) {
          if (Number.isNaN(self.getTime())) {
            return string("Invalid Date");
          }
          return hash(self.toISOString());
        } else if (self instanceof URL) {
          return hash(self.href);
        } else if (isHash(self)) {
          return self[symbol]();
        } else {
          return random(self);
        }
      }
      default:
        throw new Error(`BUG: unhandled typeof ${typeof self} - please report an issue at https://github.com/Effect-TS/effect/issues`);
    }
  };
  var random = (self) => {
    if (!randomHashCache.has(self)) {
      randomHashCache.set(self, number2(Math.floor(Math.random() * Number.MAX_SAFE_INTEGER)));
    }
    return randomHashCache.get(self);
  };
  var combine = (b) => (self) => self * 53 ^ b;
  var optimize = (n) => n & 3221225471 | n >>> 1 & 1073741824;
  var isHash = (u) => hasProperty(u, symbol);
  var number2 = (n) => {
    if (n !== n || n === Infinity) {
      return 0;
    }
    let h = n | 0;
    if (h !== n) {
      h ^= n * 4294967295;
    }
    while (n > 4294967295) {
      h ^= n /= 4294967295;
    }
    return optimize(h);
  };
  var string = (str) => {
    let h = 5381, i = str.length;
    while (i) {
      h = h * 33 ^ str.charCodeAt(--i);
    }
    return optimize(h);
  };
  var structureKeys = (o, keys5) => {
    let h = 12289;
    for (let i = 0; i < keys5.length; i++) {
      h ^= pipe(string(keys5[i]), combine(hash(o[keys5[i]])));
    }
    return optimize(h);
  };
  var structure = (o) => structureKeys(o, Object.keys(o));
  var array2 = (arr) => {
    let h = 6151;
    for (let i = 0; i < arr.length; i++) {
      h = pipe(h, combine(hash(arr[i])));
    }
    return optimize(h);
  };
  var cached = function() {
    if (arguments.length === 1) {
      const self2 = arguments[0];
      return function(hash3) {
        Object.defineProperty(self2, symbol, {
          value() {
            return hash3;
          },
          enumerable: false
        });
        return hash3;
      };
    }
    const self = arguments[0];
    const hash2 = arguments[1];
    Object.defineProperty(self, symbol, {
      value() {
        return hash2;
      },
      enumerable: false
    });
    return hash2;
  };

  // <eztb>/node_modules/effect/dist/esm/Equal.js
  var symbol2 = /* @__PURE__ */ Symbol.for("effect/Equal");
  function equals() {
    if (arguments.length === 1) {
      return (self) => compareBoth(self, arguments[0]);
    }
    return compareBoth(arguments[0], arguments[1]);
  }
  function compareBoth(self, that) {
    if (self === that) {
      return true;
    }
    const selfType = typeof self;
    if (selfType !== typeof that) {
      return false;
    }
    if (selfType === "object" || selfType === "function") {
      if (self !== null && that !== null) {
        if (isEqual(self) && isEqual(that)) {
          if (hash(self) === hash(that) && self[symbol2](that)) {
            return true;
          } else {
            return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
          }
        } else if (self instanceof Date && that instanceof Date) {
          const t1 = self.getTime();
          const t2 = that.getTime();
          return t1 === t2 || Number.isNaN(t1) && Number.isNaN(t2);
        } else if (self instanceof URL && that instanceof URL) {
          return self.href === that.href;
        }
      }
      if (structuralRegionState.enabled) {
        if (Array.isArray(self) && Array.isArray(that)) {
          return self.length === that.length && self.every((v, i) => compareBoth(v, that[i]));
        }
        if (Object.getPrototypeOf(self) === Object.prototype && Object.getPrototypeOf(that) === Object.prototype) {
          const keysSelf = Object.keys(self);
          const keysThat = Object.keys(that);
          if (keysSelf.length === keysThat.length) {
            for (const key of keysSelf) {
              if (!(key in that && compareBoth(self[key], that[key]))) {
                return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
              }
            }
            return true;
          }
        }
        return structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
      }
    }
    return structuralRegionState.enabled && structuralRegionState.tester ? structuralRegionState.tester(self, that) : false;
  }
  var isEqual = (u) => hasProperty(u, symbol2);
  var equivalence = () => equals;

  // <eztb>/node_modules/effect/dist/esm/Inspectable.js
  var NodeInspectSymbol = /* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom");
  var toJSON = (x) => {
    try {
      if (hasProperty(x, "toJSON") && isFunction2(x["toJSON"]) && x["toJSON"].length === 0) {
        return x.toJSON();
      } else if (Array.isArray(x)) {
        return x.map(toJSON);
      }
    } catch {
      return {};
    }
    return redact(x);
  };
  var format2 = (x) => JSON.stringify(x, null, 2);
  var BaseProto = {
    toJSON() {
      return toJSON(this);
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    toString() {
      return format2(this.toJSON());
    }
  };
  var Class = class {
    /**
     * @since 2.0.0
     */
    [NodeInspectSymbol]() {
      return this.toJSON();
    }
    /**
     * @since 2.0.0
     */
    toString() {
      return format2(this.toJSON());
    }
  };
  var toStringUnknown = (u, whitespace = 2) => {
    if (typeof u === "string") {
      return u;
    }
    try {
      return typeof u === "object" ? stringifyCircular(u, whitespace) : String(u);
    } catch {
      return String(u);
    }
  };
  var stringifyCircular = (obj, whitespace) => {
    let cache7 = [];
    const retVal = JSON.stringify(obj, (_key, value) => typeof value === "object" && value !== null ? cache7.includes(value) ? void 0 : cache7.push(value) && (redactableState.fiberRefs !== void 0 && isRedactable(value) ? value[symbolRedactable](redactableState.fiberRefs) : value) : value, whitespace);
    cache7 = void 0;
    return retVal;
  };
  var symbolRedactable = /* @__PURE__ */ Symbol.for("effect/Inspectable/Redactable");
  var isRedactable = (u) => typeof u === "object" && u !== null && symbolRedactable in u;
  var redactableState = /* @__PURE__ */ globalValue("effect/Inspectable/redactableState", () => ({
    fiberRefs: void 0
  }));
  var withRedactableContext = (context4, f) => {
    const prev = redactableState.fiberRefs;
    redactableState.fiberRefs = context4;
    try {
      return f();
    } finally {
      redactableState.fiberRefs = prev;
    }
  };
  var redact = (u) => {
    if (isRedactable(u) && redactableState.fiberRefs !== void 0) {
      return u[symbolRedactable](redactableState.fiberRefs);
    }
    return u;
  };

  // <eztb>/node_modules/effect/dist/esm/Pipeable.js
  var pipeArguments = (self, args2) => {
    switch (args2.length) {
      case 0:
        return self;
      case 1:
        return args2[0](self);
      case 2:
        return args2[1](args2[0](self));
      case 3:
        return args2[2](args2[1](args2[0](self)));
      case 4:
        return args2[3](args2[2](args2[1](args2[0](self))));
      case 5:
        return args2[4](args2[3](args2[2](args2[1](args2[0](self)))));
      case 6:
        return args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self))))));
      case 7:
        return args2[6](args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self)))))));
      case 8:
        return args2[7](args2[6](args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self))))))));
      case 9:
        return args2[8](args2[7](args2[6](args2[5](args2[4](args2[3](args2[2](args2[1](args2[0](self)))))))));
      default: {
        let ret = self;
        for (let i = 0, len = args2.length; i < len; i++) {
          ret = args2[i](ret);
        }
        return ret;
      }
    }
  };

  // <eztb>/node_modules/effect/dist/esm/internal/opCodes/effect.js
  var OP_ASYNC = "Async";
  var OP_COMMIT = "Commit";
  var OP_FAILURE = "Failure";
  var OP_ON_FAILURE = "OnFailure";
  var OP_ON_SUCCESS = "OnSuccess";
  var OP_ON_SUCCESS_AND_FAILURE = "OnSuccessAndFailure";
  var OP_SUCCESS = "Success";
  var OP_SYNC = "Sync";
  var OP_TAG = "Tag";
  var OP_UPDATE_RUNTIME_FLAGS = "UpdateRuntimeFlags";
  var OP_WHILE = "While";
  var OP_ITERATOR = "Iterator";
  var OP_WITH_RUNTIME = "WithRuntime";
  var OP_YIELD = "Yield";
  var OP_REVERT_FLAGS = "RevertFlags";

  // <eztb>/node_modules/effect/dist/esm/internal/version.js
  var moduleVersion = "3.19.18";
  var getCurrentVersion = () => moduleVersion;

  // <eztb>/node_modules/effect/dist/esm/internal/effectable.js
  var EffectTypeId = /* @__PURE__ */ Symbol.for("effect/Effect");
  var StreamTypeId = /* @__PURE__ */ Symbol.for("effect/Stream");
  var SinkTypeId = /* @__PURE__ */ Symbol.for("effect/Sink");
  var ChannelTypeId = /* @__PURE__ */ Symbol.for("effect/Channel");
  var effectVariance = {
    /* c8 ignore next */
    _R: (_) => _,
    /* c8 ignore next */
    _E: (_) => _,
    /* c8 ignore next */
    _A: (_) => _,
    _V: /* @__PURE__ */ getCurrentVersion()
  };
  var sinkVariance = {
    /* c8 ignore next */
    _A: (_) => _,
    /* c8 ignore next */
    _In: (_) => _,
    /* c8 ignore next */
    _L: (_) => _,
    /* c8 ignore next */
    _E: (_) => _,
    /* c8 ignore next */
    _R: (_) => _
  };
  var channelVariance = {
    /* c8 ignore next */
    _Env: (_) => _,
    /* c8 ignore next */
    _InErr: (_) => _,
    /* c8 ignore next */
    _InElem: (_) => _,
    /* c8 ignore next */
    _InDone: (_) => _,
    /* c8 ignore next */
    _OutErr: (_) => _,
    /* c8 ignore next */
    _OutElem: (_) => _,
    /* c8 ignore next */
    _OutDone: (_) => _
  };
  var EffectPrototype = {
    [EffectTypeId]: effectVariance,
    [StreamTypeId]: effectVariance,
    [SinkTypeId]: sinkVariance,
    [ChannelTypeId]: channelVariance,
    [symbol2](that) {
      return this === that;
    },
    [symbol]() {
      return cached(this, random(this));
    },
    [Symbol.iterator]() {
      return new SingleShotGen(new YieldWrap(this));
    },
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var StructuralPrototype = {
    [symbol]() {
      return cached(this, structure(this));
    },
    [symbol2](that) {
      const selfKeys = Object.keys(this);
      const thatKeys = Object.keys(that);
      if (selfKeys.length !== thatKeys.length) {
        return false;
      }
      for (const key of selfKeys) {
        if (!(key in that && equals(this[key], that[key]))) {
          return false;
        }
      }
      return true;
    }
  };
  var CommitPrototype = {
    ...EffectPrototype,
    _op: OP_COMMIT
  };
  var StructuralCommitPrototype = {
    ...CommitPrototype,
    ...StructuralPrototype
  };
  var Base = /* @__PURE__ */ (function() {
    function Base3() {
    }
    Base3.prototype = CommitPrototype;
    return Base3;
  })();

  // <eztb>/node_modules/effect/dist/esm/internal/option.js
  var TypeId = /* @__PURE__ */ Symbol.for("effect/Option");
  var CommonProto = {
    ...EffectPrototype,
    [TypeId]: {
      _A: (_) => _
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    toString() {
      return format2(this.toJSON());
    }
  };
  var SomeProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto), {
    _tag: "Some",
    _op: "Some",
    [symbol2](that) {
      return isOption(that) && isSome(that) && equals(this.value, that.value);
    },
    [symbol]() {
      return cached(this, combine(hash(this._tag))(hash(this.value)));
    },
    toJSON() {
      return {
        _id: "Option",
        _tag: this._tag,
        value: toJSON(this.value)
      };
    }
  });
  var NoneHash = /* @__PURE__ */ hash("None");
  var NoneProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto), {
    _tag: "None",
    _op: "None",
    [symbol2](that) {
      return isOption(that) && isNone(that);
    },
    [symbol]() {
      return NoneHash;
    },
    toJSON() {
      return {
        _id: "Option",
        _tag: this._tag
      };
    }
  });
  var isOption = (input) => hasProperty(input, TypeId);
  var isNone = (fa) => fa._tag === "None";
  var isSome = (fa) => fa._tag === "Some";
  var none = /* @__PURE__ */ Object.create(NoneProto);
  var some = (value) => {
    const a = Object.create(SomeProto);
    a.value = value;
    return a;
  };

  // <eztb>/node_modules/effect/dist/esm/internal/either.js
  var TypeId2 = /* @__PURE__ */ Symbol.for("effect/Either");
  var CommonProto2 = {
    ...EffectPrototype,
    [TypeId2]: {
      _R: (_) => _
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    toString() {
      return format2(this.toJSON());
    }
  };
  var RightProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto2), {
    _tag: "Right",
    _op: "Right",
    [symbol2](that) {
      return isEither(that) && isRight(that) && equals(this.right, that.right);
    },
    [symbol]() {
      return combine(hash(this._tag))(hash(this.right));
    },
    toJSON() {
      return {
        _id: "Either",
        _tag: this._tag,
        right: toJSON(this.right)
      };
    }
  });
  var LeftProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(CommonProto2), {
    _tag: "Left",
    _op: "Left",
    [symbol2](that) {
      return isEither(that) && isLeft(that) && equals(this.left, that.left);
    },
    [symbol]() {
      return combine(hash(this._tag))(hash(this.left));
    },
    toJSON() {
      return {
        _id: "Either",
        _tag: this._tag,
        left: toJSON(this.left)
      };
    }
  });
  var isEither = (input) => hasProperty(input, TypeId2);
  var isLeft = (ma) => ma._tag === "Left";
  var isRight = (ma) => ma._tag === "Right";
  var left = (left3) => {
    const a = Object.create(LeftProto);
    a.left = left3;
    return a;
  };
  var right = (right3) => {
    const a = Object.create(RightProto);
    a.right = right3;
    return a;
  };
  var getLeft = (self) => isRight(self) ? none : some(self.left);
  var getRight = (self) => isLeft(self) ? none : some(self.right);
  var fromOption = /* @__PURE__ */ dual(2, (self, onNone) => isNone(self) ? left(onNone()) : right(self.value));

  // <eztb>/node_modules/effect/dist/esm/Either.js
  var TypeId3 = TypeId2;
  var right2 = right;
  var void_ = /* @__PURE__ */ right2(void 0);
  var left2 = left;
  var fromNullable = /* @__PURE__ */ dual(2, (self, onNullable) => self == null ? left2(onNullable(self)) : right2(self));
  var fromOption2 = fromOption;
  var try_ = (evaluate2) => {
    if (isFunction2(evaluate2)) {
      try {
        return right2(evaluate2());
      } catch (e) {
        return left2(e);
      }
    } else {
      try {
        return right2(evaluate2.try());
      } catch (e) {
        return left2(evaluate2.catch(e));
      }
    }
  };
  var isEither2 = isEither;
  var isLeft2 = isLeft;
  var isRight2 = isRight;
  var getRight2 = getRight;
  var getLeft2 = getLeft;
  var getEquivalence = ({
    left: left3,
    right: right3
  }) => make((x, y) => isLeft2(x) ? isLeft2(y) && left3(x.left, y.left) : isRight2(y) && right3(x.right, y.right));
  var mapBoth = /* @__PURE__ */ dual(2, (self, {
    onLeft,
    onRight
  }) => isLeft2(self) ? left2(onLeft(self.left)) : right2(onRight(self.right)));
  var mapLeft = /* @__PURE__ */ dual(2, (self, f) => isLeft2(self) ? left2(f(self.left)) : right2(self.right));
  var map = /* @__PURE__ */ dual(2, (self, f) => isRight2(self) ? right2(f(self.right)) : left2(self.left));
  var match = /* @__PURE__ */ dual(2, (self, {
    onLeft,
    onRight
  }) => isLeft2(self) ? onLeft(self.left) : onRight(self.right));
  var liftPredicate = /* @__PURE__ */ dual(3, (a, predicate, orLeftWith) => predicate(a) ? right2(a) : left2(orLeftWith(a)));
  var filterOrLeft = /* @__PURE__ */ dual(3, (self, predicate, orLeftWith) => flatMap(self, (r) => predicate(r) ? right2(r) : left2(orLeftWith(r))));
  var merge = /* @__PURE__ */ match({
    onLeft: identity,
    onRight: identity
  });
  var getOrElse = /* @__PURE__ */ dual(2, (self, onLeft) => isLeft2(self) ? onLeft(self.left) : self.right);
  var getOrNull = /* @__PURE__ */ getOrElse(constNull);
  var getOrUndefined = /* @__PURE__ */ getOrElse(constUndefined);
  var getOrThrowWith = /* @__PURE__ */ dual(2, (self, onLeft) => {
    if (isRight2(self)) {
      return self.right;
    }
    throw onLeft(self.left);
  });
  var getOrThrow = /* @__PURE__ */ getOrThrowWith(() => new Error("getOrThrow called on a Left"));
  var orElse = /* @__PURE__ */ dual(2, (self, that) => isLeft2(self) ? that(self.left) : right2(self.right));
  var flatMap = /* @__PURE__ */ dual(2, (self, f) => isLeft2(self) ? left2(self.left) : f(self.right));
  var andThen = /* @__PURE__ */ dual(2, (self, f) => flatMap(self, (a) => {
    const b = isFunction2(f) ? f(a) : f;
    return isEither2(b) ? b : right2(b);
  }));
  var zipWith = /* @__PURE__ */ dual(3, (self, that, f) => flatMap(self, (r) => map(that, (r2) => f(r, r2))));
  var ap = /* @__PURE__ */ dual(2, (self, that) => zipWith(self, that, (f, a) => f(a)));
  var all = (input) => {
    if (Symbol.iterator in input) {
      const out2 = [];
      for (const e of input) {
        if (isLeft2(e)) {
          return e;
        }
        out2.push(e.right);
      }
      return right2(out2);
    }
    const out = {};
    for (const key of Object.keys(input)) {
      const e = input[key];
      if (isLeft2(e)) {
        return e;
      }
      out[key] = e.right;
    }
    return right2(out);
  };
  var flip = (self) => isLeft2(self) ? right2(self.left) : left2(self.right);
  var adapter2 = /* @__PURE__ */ adapter();
  var gen = (...args2) => {
    const f = args2.length === 1 ? args2[0] : args2[1].bind(args2[0]);
    const iterator = f(adapter2);
    let state = iterator.next();
    while (!state.done) {
      const current = isGenKind(state.value) ? state.value.value : yieldWrapGet(state.value);
      if (isLeft2(current)) {
        return current;
      }
      state = iterator.next(current.right);
    }
    return right2(state.value);
  };
  var Do = /* @__PURE__ */ right2({});
  var bind2 = /* @__PURE__ */ bind(map, flatMap);
  var bindTo2 = /* @__PURE__ */ bindTo(map);
  var let_2 = /* @__PURE__ */ let_(map);
  var transposeOption = (self) => {
    return isNone(self) ? right2(none) : map(self.value, some);
  };
  var transposeMapOption = /* @__PURE__ */ dual(2, (self, f) => isNone(self) ? right2(none) : map(f(self.value), some));

  // <eztb>/node_modules/effect/dist/esm/internal/array.js
  var isNonEmptyArray = (self) => self.length > 0;

  // <eztb>/node_modules/effect/dist/esm/Order.js
  var make2 = (compare) => (self, that) => self === that ? 0 : compare(self, that);
  var number3 = /* @__PURE__ */ make2((self, that) => self < that ? -1 : 1);
  var mapInput2 = /* @__PURE__ */ dual(2, (self, f) => make2((b1, b2) => self(f(b1), f(b2))));
  var lessThan = (O) => dual(2, (self, that) => O(self, that) === -1);
  var greaterThan = (O) => dual(2, (self, that) => O(self, that) === 1);
  var min = (O) => dual(2, (self, that) => self === that || O(self, that) < 1 ? self : that);
  var max = (O) => dual(2, (self, that) => self === that || O(self, that) > -1 ? self : that);
  var clamp = (O) => dual(2, (self, options) => min(O)(options.maximum, max(O)(options.minimum, self)));
  var between = (O) => dual(2, (self, options) => !lessThan(O)(self, options.minimum) && !greaterThan(O)(self, options.maximum));

  // <eztb>/node_modules/effect/dist/esm/Option.js
  var none2 = () => none;
  var some2 = some;
  var isNone2 = isNone;
  var isSome2 = isSome;
  var match2 = /* @__PURE__ */ dual(2, (self, {
    onNone,
    onSome
  }) => isNone2(self) ? onNone() : onSome(self.value));
  var getOrElse2 = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? onNone() : self.value);
  var orElseSome = /* @__PURE__ */ dual(2, (self, onNone) => isNone2(self) ? some2(onNone()) : self);
  var fromNullable2 = (nullableValue) => nullableValue == null ? none2() : some2(nullableValue);
  var getOrUndefined2 = /* @__PURE__ */ getOrElse2(constUndefined);
  var liftThrowable = (f) => (...a) => {
    try {
      return some2(f(...a));
    } catch {
      return none2();
    }
  };
  var getOrThrowWith2 = /* @__PURE__ */ dual(2, (self, onNone) => {
    if (isSome2(self)) {
      return self.value;
    }
    throw onNone();
  });
  var getOrThrow2 = /* @__PURE__ */ getOrThrowWith2(() => new Error("getOrThrow called on a None"));
  var map2 = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : some2(f(self.value)));
  var flatMap2 = /* @__PURE__ */ dual(2, (self, f) => isNone2(self) ? none2() : f(self.value));
  var containsWith = (isEquivalent) => dual(2, (self, a) => isNone2(self) ? false : isEquivalent(self.value, a));
  var _equivalence = /* @__PURE__ */ equivalence();
  var contains = /* @__PURE__ */ containsWith(_equivalence);
  var mergeWith = (f) => (o1, o2) => {
    if (isNone2(o1)) {
      return o2;
    } else if (isNone2(o2)) {
      return o1;
    }
    return some2(f(o1.value, o2.value));
  };

  // <eztb>/node_modules/effect/dist/esm/Tuple.js
  var make3 = (...elements) => elements;

  // <eztb>/node_modules/effect/dist/esm/Array.js
  var allocate = (n) => new Array(n);
  var makeBy = /* @__PURE__ */ dual(2, (n, f) => {
    const max6 = Math.max(1, Math.floor(n));
    const out = new Array(max6);
    for (let i = 0; i < max6; i++) {
      out[i] = f(i);
    }
    return out;
  });
  var fromIterable = (collection) => Array.isArray(collection) ? collection : Array.from(collection);
  var ensure = (self) => Array.isArray(self) ? self : [self];
  var prepend = /* @__PURE__ */ dual(2, (self, head5) => [head5, ...self]);
  var append = /* @__PURE__ */ dual(2, (self, last3) => [...self, last3]);
  var appendAll = /* @__PURE__ */ dual(2, (self, that) => fromIterable(self).concat(fromIterable(that)));
  var isEmptyArray = (self) => self.length === 0;
  var isEmptyReadonlyArray = isEmptyArray;
  var isNonEmptyArray2 = isNonEmptyArray;
  var isNonEmptyReadonlyArray = isNonEmptyArray;
  var isOutOfBounds = (i, as6) => i < 0 || i >= as6.length;
  var clamp2 = (i, as6) => Math.floor(Math.min(Math.max(0, i), as6.length));
  var get = /* @__PURE__ */ dual(2, (self, index) => {
    const i = Math.floor(index);
    return isOutOfBounds(i, self) ? none2() : some2(self[i]);
  });
  var unsafeGet = /* @__PURE__ */ dual(2, (self, index) => {
    const i = Math.floor(index);
    if (isOutOfBounds(i, self)) {
      throw new Error(`Index ${i} out of bounds`);
    }
    return self[i];
  });
  var head = /* @__PURE__ */ get(0);
  var headNonEmpty = /* @__PURE__ */ unsafeGet(0);
  var last = (self) => isNonEmptyReadonlyArray(self) ? some2(lastNonEmpty(self)) : none2();
  var lastNonEmpty = (self) => self[self.length - 1];
  var tailNonEmpty = (self) => self.slice(1);
  var spanIndex = (self, predicate) => {
    let i = 0;
    for (const a of self) {
      if (!predicate(a, i)) {
        break;
      }
      i++;
    }
    return i;
  };
  var span = /* @__PURE__ */ dual(2, (self, predicate) => splitAt(self, spanIndex(self, predicate)));
  var drop = /* @__PURE__ */ dual(2, (self, n) => {
    const input = fromIterable(self);
    return input.slice(clamp2(n, input), input.length);
  });
  var reverse = (self) => Array.from(self).reverse();
  var sort = /* @__PURE__ */ dual(2, (self, O) => {
    const out = Array.from(self);
    out.sort(O);
    return out;
  });
  var zip = /* @__PURE__ */ dual(2, (self, that) => zipWith2(self, that, make3));
  var zipWith2 = /* @__PURE__ */ dual(3, (self, that, f) => {
    const as6 = fromIterable(self);
    const bs = fromIterable(that);
    if (isNonEmptyReadonlyArray(as6) && isNonEmptyReadonlyArray(bs)) {
      const out = [f(headNonEmpty(as6), headNonEmpty(bs))];
      const len = Math.min(as6.length, bs.length);
      for (let i = 1; i < len; i++) {
        out[i] = f(as6[i], bs[i]);
      }
      return out;
    }
    return [];
  });
  var _equivalence2 = /* @__PURE__ */ equivalence();
  var splitAt = /* @__PURE__ */ dual(2, (self, n) => {
    const input = Array.from(self);
    const _n = Math.floor(n);
    if (isNonEmptyReadonlyArray(input)) {
      if (_n >= 1) {
        return splitNonEmptyAt(input, _n);
      }
      return [[], input];
    }
    return [input, []];
  });
  var splitNonEmptyAt = /* @__PURE__ */ dual(2, (self, n) => {
    const _n = Math.max(1, Math.floor(n));
    return _n >= self.length ? [copy(self), []] : [prepend(self.slice(1, _n), headNonEmpty(self)), self.slice(_n)];
  });
  var copy = (self) => self.slice();
  var unionWith = /* @__PURE__ */ dual(3, (self, that, isEquivalent) => {
    const a = fromIterable(self);
    const b = fromIterable(that);
    if (isNonEmptyReadonlyArray(a)) {
      if (isNonEmptyReadonlyArray(b)) {
        const dedupe2 = dedupeWith(isEquivalent);
        return dedupe2(appendAll(a, b));
      }
      return a;
    }
    return b;
  });
  var union = /* @__PURE__ */ dual(2, (self, that) => unionWith(self, that, _equivalence2));
  var empty = () => [];
  var of = (a) => [a];
  var map3 = /* @__PURE__ */ dual(2, (self, f) => self.map(f));
  var flatMap3 = /* @__PURE__ */ dual(2, (self, f) => {
    if (isEmptyReadonlyArray(self)) {
      return [];
    }
    const out = [];
    for (let i = 0; i < self.length; i++) {
      const inner = f(self[i], i);
      for (let j = 0; j < inner.length; j++) {
        out.push(inner[j]);
      }
    }
    return out;
  });
  var flatten = /* @__PURE__ */ flatMap3(identity);
  var filterMap = /* @__PURE__ */ dual(2, (self, f) => {
    const as6 = fromIterable(self);
    const out = [];
    for (let i = 0; i < as6.length; i++) {
      const o = f(as6[i], i);
      if (isSome2(o)) {
        out.push(o.value);
      }
    }
    return out;
  });
  var partitionMap = /* @__PURE__ */ dual(2, (self, f) => {
    const left3 = [];
    const right3 = [];
    const as6 = fromIterable(self);
    for (let i = 0; i < as6.length; i++) {
      const e = f(as6[i], i);
      if (isLeft2(e)) {
        left3.push(e.left);
      } else {
        right3.push(e.right);
      }
    }
    return [left3, right3];
  });
  var getSomes = /* @__PURE__ */ filterMap(identity);
  var reduce = /* @__PURE__ */ dual(3, (self, b, f) => fromIterable(self).reduce((b2, a, i) => f(b2, a, i), b));
  var reduceRight = /* @__PURE__ */ dual(3, (self, b, f) => fromIterable(self).reduceRight((b2, a, i) => f(b2, a, i), b));
  var unfold = (b, f) => {
    const out = [];
    let next4 = b;
    let o;
    while (isSome2(o = f(next4))) {
      const [a, b2] = o.value;
      out.push(a);
      next4 = b2;
    }
    return out;
  };
  var getEquivalence2 = array;
  var dedupeWith = /* @__PURE__ */ dual(2, (self, isEquivalent) => {
    const input = fromIterable(self);
    if (isNonEmptyReadonlyArray(input)) {
      const out = [headNonEmpty(input)];
      const rest = tailNonEmpty(input);
      for (const r of rest) {
        if (out.every((a) => !isEquivalent(r, a))) {
          out.push(r);
        }
      }
      return out;
    }
    return [];
  });
  var dedupe = (self) => dedupeWith(self, equivalence());
  var join = /* @__PURE__ */ dual(2, (self, sep) => fromIterable(self).join(sep));

  // <eztb>/node_modules/effect/dist/esm/Number.js
  var Order = number3;

  // <eztb>/node_modules/effect/dist/esm/RegExp.js
  var escape = (string2) => string2.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&");

  // <eztb>/node_modules/effect/dist/esm/Boolean.js
  var not = (self) => !self;

  // <eztb>/node_modules/effect/dist/esm/Cache.js
  var Cache_exports = {};
  __export(Cache_exports, {
    CacheTypeId: () => CacheTypeId2,
    ConsumerCacheTypeId: () => ConsumerCacheTypeId2,
    make: () => make35,
    makeCacheStats: () => makeCacheStats2,
    makeEntryStats: () => makeEntryStats2,
    makeWith: () => makeWith2
  });

  // <eztb>/node_modules/effect/dist/esm/internal/context.js
  var TagTypeId = /* @__PURE__ */ Symbol.for("effect/Context/Tag");
  var ReferenceTypeId = /* @__PURE__ */ Symbol.for("effect/Context/Reference");
  var STMSymbolKey = "effect/STM";
  var STMTypeId = /* @__PURE__ */ Symbol.for(STMSymbolKey);
  var TagProto = {
    ...EffectPrototype,
    _op: "Tag",
    [STMTypeId]: effectVariance,
    [TagTypeId]: {
      _Service: (_) => _,
      _Identifier: (_) => _
    },
    toString() {
      return format2(this.toJSON());
    },
    toJSON() {
      return {
        _id: "Tag",
        key: this.key,
        stack: this.stack
      };
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    of(self) {
      return self;
    },
    context(self) {
      return make4(this, self);
    }
  };
  var ReferenceProto = {
    ...TagProto,
    [ReferenceTypeId]: ReferenceTypeId
  };
  var makeGenericTag = (key) => {
    const limit = Error.stackTraceLimit;
    Error.stackTraceLimit = 2;
    const creationError = new Error();
    Error.stackTraceLimit = limit;
    const tag = Object.create(TagProto);
    Object.defineProperty(tag, "stack", {
      get() {
        return creationError.stack;
      }
    });
    tag.key = key;
    return tag;
  };
  var Reference = () => (id, options) => {
    const limit = Error.stackTraceLimit;
    Error.stackTraceLimit = 2;
    const creationError = new Error();
    Error.stackTraceLimit = limit;
    function ReferenceClass() {
    }
    Object.setPrototypeOf(ReferenceClass, ReferenceProto);
    ReferenceClass.key = id;
    ReferenceClass.defaultValue = options.defaultValue;
    Object.defineProperty(ReferenceClass, "stack", {
      get() {
        return creationError.stack;
      }
    });
    return ReferenceClass;
  };
  var TypeId4 = /* @__PURE__ */ Symbol.for("effect/Context");
  var ContextProto = {
    [TypeId4]: {
      _Services: (_) => _
    },
    [symbol2](that) {
      if (isContext(that)) {
        if (this.unsafeMap.size === that.unsafeMap.size) {
          for (const k of this.unsafeMap.keys()) {
            if (!that.unsafeMap.has(k) || !equals(this.unsafeMap.get(k), that.unsafeMap.get(k))) {
              return false;
            }
          }
          return true;
        }
      }
      return false;
    },
    [symbol]() {
      return cached(this, number2(this.unsafeMap.size));
    },
    pipe() {
      return pipeArguments(this, arguments);
    },
    toString() {
      return format2(this.toJSON());
    },
    toJSON() {
      return {
        _id: "Context",
        services: Array.from(this.unsafeMap).map(toJSON)
      };
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    }
  };
  var makeContext = (unsafeMap) => {
    const context4 = Object.create(ContextProto);
    context4.unsafeMap = unsafeMap;
    return context4;
  };
  var serviceNotFoundError = (tag) => {
    const error = new Error(`Service not found${tag.key ? `: ${String(tag.key)}` : ""}`);
    if (tag.stack) {
      const lines = tag.stack.split("\n");
      if (lines.length > 2) {
        const afterAt = lines[2].match(/at (.*)/);
        if (afterAt) {
          error.message = error.message + ` (defined at ${afterAt[1]})`;
        }
      }
    }
    if (error.stack) {
      const lines = error.stack.split("\n");
      lines.splice(1, 3);
      error.stack = lines.join("\n");
    }
    return error;
  };
  var isContext = (u) => hasProperty(u, TypeId4);
  var isTag = (u) => hasProperty(u, TagTypeId);
  var isReference = (u) => hasProperty(u, ReferenceTypeId);
  var _empty = /* @__PURE__ */ makeContext(/* @__PURE__ */ new Map());
  var empty2 = () => _empty;
  var make4 = (tag, service) => makeContext(/* @__PURE__ */ new Map([[tag.key, service]]));
  var add = /* @__PURE__ */ dual(3, (self, tag, service) => {
    const map14 = new Map(self.unsafeMap);
    map14.set(tag.key, service);
    return makeContext(map14);
  });
  var defaultValueCache = /* @__PURE__ */ globalValue("effect/Context/defaultValueCache", () => /* @__PURE__ */ new Map());
  var getDefaultValue = (tag) => {
    if (defaultValueCache.has(tag.key)) {
      return defaultValueCache.get(tag.key);
    }
    const value = tag.defaultValue();
    defaultValueCache.set(tag.key, value);
    return value;
  };
  var unsafeGetReference = (self, tag) => {
    return self.unsafeMap.has(tag.key) ? self.unsafeMap.get(tag.key) : getDefaultValue(tag);
  };
  var unsafeGet2 = /* @__PURE__ */ dual(2, (self, tag) => {
    if (!self.unsafeMap.has(tag.key)) {
      if (ReferenceTypeId in tag) return getDefaultValue(tag);
      throw serviceNotFoundError(tag);
    }
    return self.unsafeMap.get(tag.key);
  });
  var get2 = unsafeGet2;
  var getOption = /* @__PURE__ */ dual(2, (self, tag) => {
    if (!self.unsafeMap.has(tag.key)) {
      return isReference(tag) ? some(getDefaultValue(tag)) : none;
    }
    return some(self.unsafeMap.get(tag.key));
  });
  var merge2 = /* @__PURE__ */ dual(2, (self, that) => {
    const map14 = new Map(self.unsafeMap);
    for (const [tag, s] of that.unsafeMap) {
      map14.set(tag, s);
    }
    return makeContext(map14);
  });
  var mergeAll = (...ctxs) => {
    const map14 = /* @__PURE__ */ new Map();
    for (let i = 0; i < ctxs.length; i++) {
      ctxs[i].unsafeMap.forEach((value, key) => {
        map14.set(key, value);
      });
    }
    return makeContext(map14);
  };

  // <eztb>/node_modules/effect/dist/esm/Context.js
  var GenericTag = makeGenericTag;
  var isContext2 = isContext;
  var isTag2 = isTag;
  var empty3 = empty2;
  var make5 = make4;
  var add2 = add;
  var get3 = get2;
  var unsafeGet3 = unsafeGet2;
  var getOption2 = getOption;
  var merge3 = merge2;
  var mergeAll2 = mergeAll;
  var Reference2 = Reference;

  // <eztb>/node_modules/effect/dist/esm/Chunk.js
  var TypeId5 = /* @__PURE__ */ Symbol.for("effect/Chunk");
  function copy2(src, srcPos, dest, destPos, len) {
    for (let i = srcPos; i < Math.min(src.length, srcPos + len); i++) {
      dest[destPos + i - srcPos] = src[i];
    }
    return dest;
  }
  var emptyArray = [];
  var getEquivalence3 = (isEquivalent) => make((self, that) => self.length === that.length && toReadonlyArray(self).every((value, i) => isEquivalent(value, unsafeGet4(that, i))));
  var _equivalence3 = /* @__PURE__ */ getEquivalence3(equals);
  var ChunkProto = {
    [TypeId5]: {
      _A: (_) => _
    },
    toString() {
      return format2(this.toJSON());
    },
    toJSON() {
      return {
        _id: "Chunk",
        values: toReadonlyArray(this).map(toJSON)
      };
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    [symbol2](that) {
      return isChunk(that) && _equivalence3(this, that);
    },
    [symbol]() {
      return cached(this, array2(toReadonlyArray(this)));
    },
    [Symbol.iterator]() {
      switch (this.backing._tag) {
        case "IArray": {
          return this.backing.array[Symbol.iterator]();
        }
        case "IEmpty": {
          return emptyArray[Symbol.iterator]();
        }
        default: {
          return toReadonlyArray(this)[Symbol.iterator]();
        }
      }
    },
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var makeChunk = (backing) => {
    const chunk2 = Object.create(ChunkProto);
    chunk2.backing = backing;
    switch (backing._tag) {
      case "IEmpty": {
        chunk2.length = 0;
        chunk2.depth = 0;
        chunk2.left = chunk2;
        chunk2.right = chunk2;
        break;
      }
      case "IConcat": {
        chunk2.length = backing.left.length + backing.right.length;
        chunk2.depth = 1 + Math.max(backing.left.depth, backing.right.depth);
        chunk2.left = backing.left;
        chunk2.right = backing.right;
        break;
      }
      case "IArray": {
        chunk2.length = backing.array.length;
        chunk2.depth = 0;
        chunk2.left = _empty2;
        chunk2.right = _empty2;
        break;
      }
      case "ISingleton": {
        chunk2.length = 1;
        chunk2.depth = 0;
        chunk2.left = _empty2;
        chunk2.right = _empty2;
        break;
      }
      case "ISlice": {
        chunk2.length = backing.length;
        chunk2.depth = backing.chunk.depth + 1;
        chunk2.left = _empty2;
        chunk2.right = _empty2;
        break;
      }
    }
    return chunk2;
  };
  var isChunk = (u) => hasProperty(u, TypeId5);
  var _empty2 = /* @__PURE__ */ makeChunk({
    _tag: "IEmpty"
  });
  var empty4 = () => _empty2;
  var make6 = (...as6) => unsafeFromNonEmptyArray(as6);
  var of2 = (a) => makeChunk({
    _tag: "ISingleton",
    a
  });
  var fromIterable2 = (self) => isChunk(self) ? self : unsafeFromArray(fromIterable(self));
  var copyToArray = (self, array3, initial) => {
    switch (self.backing._tag) {
      case "IArray": {
        copy2(self.backing.array, 0, array3, initial, self.length);
        break;
      }
      case "IConcat": {
        copyToArray(self.left, array3, initial);
        copyToArray(self.right, array3, initial + self.left.length);
        break;
      }
      case "ISingleton": {
        array3[initial] = self.backing.a;
        break;
      }
      case "ISlice": {
        let i = 0;
        let j = initial;
        while (i < self.length) {
          array3[j] = unsafeGet4(self, i);
          i += 1;
          j += 1;
        }
        break;
      }
    }
  };
  var toReadonlyArray_ = (self) => {
    switch (self.backing._tag) {
      case "IEmpty": {
        return emptyArray;
      }
      case "IArray": {
        return self.backing.array;
      }
      default: {
        const arr = new Array(self.length);
        copyToArray(self, arr, 0);
        self.backing = {
          _tag: "IArray",
          array: arr
        };
        self.left = _empty2;
        self.right = _empty2;
        self.depth = 0;
        return arr;
      }
    }
  };
  var toReadonlyArray = toReadonlyArray_;
  var reverseChunk = (self) => {
    switch (self.backing._tag) {
      case "IEmpty":
      case "ISingleton":
        return self;
      case "IArray": {
        return makeChunk({
          _tag: "IArray",
          array: reverse(self.backing.array)
        });
      }
      case "IConcat": {
        return makeChunk({
          _tag: "IConcat",
          left: reverse2(self.backing.right),
          right: reverse2(self.backing.left)
        });
      }
      case "ISlice":
        return unsafeFromArray(reverse(toReadonlyArray(self)));
    }
  };
  var reverse2 = reverseChunk;
  var get4 = /* @__PURE__ */ dual(2, (self, index) => index < 0 || index >= self.length ? none2() : some2(unsafeGet4(self, index)));
  var unsafeFromArray = (self) => self.length === 0 ? empty4() : self.length === 1 ? of2(self[0]) : makeChunk({
    _tag: "IArray",
    array: self
  });
  var unsafeFromNonEmptyArray = (self) => unsafeFromArray(self);
  var unsafeGet4 = /* @__PURE__ */ dual(2, (self, index) => {
    switch (self.backing._tag) {
      case "IEmpty": {
        throw new Error(`Index out of bounds`);
      }
      case "ISingleton": {
        if (index !== 0) {
          throw new Error(`Index out of bounds`);
        }
        return self.backing.a;
      }
      case "IArray": {
        if (index >= self.length || index < 0) {
          throw new Error(`Index out of bounds`);
        }
        return self.backing.array[index];
      }
      case "IConcat": {
        return index < self.left.length ? unsafeGet4(self.left, index) : unsafeGet4(self.right, index - self.left.length);
      }
      case "ISlice": {
        return unsafeGet4(self.backing.chunk, index + self.backing.offset);
      }
    }
  });
  var append2 = /* @__PURE__ */ dual(2, (self, a) => appendAll2(self, of2(a)));
  var prepend2 = /* @__PURE__ */ dual(2, (self, elem) => appendAll2(of2(elem), self));
  var drop2 = /* @__PURE__ */ dual(2, (self, n) => {
    if (n <= 0) {
      return self;
    } else if (n >= self.length) {
      return _empty2;
    } else {
      switch (self.backing._tag) {
        case "ISlice": {
          return makeChunk({
            _tag: "ISlice",
            chunk: self.backing.chunk,
            offset: self.backing.offset + n,
            length: self.backing.length - n
          });
        }
        case "IConcat": {
          if (n > self.left.length) {
            return drop2(self.right, n - self.left.length);
          }
          return makeChunk({
            _tag: "IConcat",
            left: drop2(self.left, n),
            right: self.right
          });
        }
        default: {
          return makeChunk({
            _tag: "ISlice",
            chunk: self,
            offset: n,
            length: self.length - n
          });
        }
      }
    }
  });
  var appendAll2 = /* @__PURE__ */ dual(2, (self, that) => {
    if (self.backing._tag === "IEmpty") {
      return that;
    }
    if (that.backing._tag === "IEmpty") {
      return self;
    }
    const diff8 = that.depth - self.depth;
    if (Math.abs(diff8) <= 1) {
      return makeChunk({
        _tag: "IConcat",
        left: self,
        right: that
      });
    } else if (diff8 < -1) {
      if (self.left.depth >= self.right.depth) {
        const nr = appendAll2(self.right, that);
        return makeChunk({
          _tag: "IConcat",
          left: self.left,
          right: nr
        });
      } else {
        const nrr = appendAll2(self.right.right, that);
        if (nrr.depth === self.depth - 3) {
          const nr = makeChunk({
            _tag: "IConcat",
            left: self.right.left,
            right: nrr
          });
          return makeChunk({
            _tag: "IConcat",
            left: self.left,
            right: nr
          });
        } else {
          const nl = makeChunk({
            _tag: "IConcat",
            left: self.left,
            right: self.right.left
          });
          return makeChunk({
            _tag: "IConcat",
            left: nl,
            right: nrr
          });
        }
      }
    } else {
      if (that.right.depth >= that.left.depth) {
        const nl = appendAll2(self, that.left);
        return makeChunk({
          _tag: "IConcat",
          left: nl,
          right: that.right
        });
      } else {
        const nll = appendAll2(self, that.left.left);
        if (nll.depth === that.depth - 3) {
          const nl = makeChunk({
            _tag: "IConcat",
            left: nll,
            right: that.left.right
          });
          return makeChunk({
            _tag: "IConcat",
            left: nl,
            right: that.right
          });
        } else {
          const nr = makeChunk({
            _tag: "IConcat",
            left: that.left.right,
            right: that.right
          });
          return makeChunk({
            _tag: "IConcat",
            left: nll,
            right: nr
          });
        }
      }
    }
  });
  var isEmpty = (self) => self.length === 0;
  var isNonEmpty = (self) => self.length > 0;
  var head2 = /* @__PURE__ */ get4(0);
  var unsafeHead = (self) => unsafeGet4(self, 0);
  var headNonEmpty2 = unsafeHead;
  var tailNonEmpty2 = (self) => drop2(self, 1);

  // <eztb>/node_modules/effect/dist/esm/Duration.js
  var Duration_exports = {};
  __export(Duration_exports, {
    Equivalence: () => Equivalence,
    Order: () => Order2,
    between: () => between2,
    clamp: () => clamp3,
    days: () => days,
    decode: () => decode,
    decodeUnknown: () => decodeUnknown,
    divide: () => divide,
    equals: () => equals2,
    format: () => format3,
    formatIso: () => formatIso,
    fromIso: () => fromIso,
    greaterThan: () => greaterThan2,
    greaterThanOrEqualTo: () => greaterThanOrEqualTo2,
    hours: () => hours,
    infinity: () => infinity,
    isDuration: () => isDuration,
    isFinite: () => isFinite,
    isZero: () => isZero,
    lessThan: () => lessThan2,
    lessThanOrEqualTo: () => lessThanOrEqualTo2,
    match: () => match3,
    matchWith: () => matchWith,
    max: () => max2,
    micros: () => micros,
    millis: () => millis,
    min: () => min2,
    minutes: () => minutes,
    nanos: () => nanos,
    parts: () => parts,
    seconds: () => seconds,
    subtract: () => subtract,
    sum: () => sum,
    times: () => times,
    toDays: () => toDays,
    toHours: () => toHours,
    toHrTime: () => toHrTime,
    toMillis: () => toMillis,
    toMinutes: () => toMinutes,
    toNanos: () => toNanos,
    toSeconds: () => toSeconds,
    toWeeks: () => toWeeks,
    unsafeDivide: () => unsafeDivide,
    unsafeFormatIso: () => unsafeFormatIso,
    unsafeToNanos: () => unsafeToNanos,
    weeks: () => weeks,
    zero: () => zero
  });
  var TypeId6 = /* @__PURE__ */ Symbol.for("effect/Duration");
  var bigint0 = /* @__PURE__ */ BigInt(0);
  var bigint24 = /* @__PURE__ */ BigInt(24);
  var bigint60 = /* @__PURE__ */ BigInt(60);
  var bigint1e3 = /* @__PURE__ */ BigInt(1e3);
  var bigint1e6 = /* @__PURE__ */ BigInt(1e6);
  var bigint1e9 = /* @__PURE__ */ BigInt(1e9);
  var DURATION_REGEX = /^(-?\d+(?:\.\d+)?)\s+(nanos?|micros?|millis?|seconds?|minutes?|hours?|days?|weeks?)$/;
  var decode = (input) => {
    if (isDuration(input)) {
      return input;
    } else if (isNumber(input)) {
      return millis(input);
    } else if (isBigInt(input)) {
      return nanos(input);
    } else if (Array.isArray(input) && input.length === 2 && input.every(isNumber)) {
      if (input[0] === -Infinity || input[1] === -Infinity || Number.isNaN(input[0]) || Number.isNaN(input[1])) {
        return zero;
      }
      if (input[0] === Infinity || input[1] === Infinity) {
        return infinity;
      }
      return nanos(BigInt(Math.round(input[0] * 1e9)) + BigInt(Math.round(input[1])));
    } else if (isString(input)) {
      const match11 = DURATION_REGEX.exec(input);
      if (match11) {
        const [_, valueStr, unit] = match11;
        const value = Number(valueStr);
        switch (unit) {
          case "nano":
          case "nanos":
            return nanos(BigInt(valueStr));
          case "micro":
          case "micros":
            return micros(BigInt(valueStr));
          case "milli":
          case "millis":
            return millis(value);
          case "second":
          case "seconds":
            return seconds(value);
          case "minute":
          case "minutes":
            return minutes(value);
          case "hour":
          case "hours":
            return hours(value);
          case "day":
          case "days":
            return days(value);
          case "week":
          case "weeks":
            return weeks(value);
        }
      }
    }
    throw new Error("Invalid DurationInput");
  };
  var decodeUnknown = /* @__PURE__ */ liftThrowable(decode);
  var zeroValue = {
    _tag: "Millis",
    millis: 0
  };
  var infinityValue = {
    _tag: "Infinity"
  };
  var DurationProto = {
    [TypeId6]: TypeId6,
    [symbol]() {
      return cached(this, structure(this.value));
    },
    [symbol2](that) {
      return isDuration(that) && equals2(this, that);
    },
    toString() {
      return `Duration(${format3(this)})`;
    },
    toJSON() {
      switch (this.value._tag) {
        case "Millis":
          return {
            _id: "Duration",
            _tag: "Millis",
            millis: this.value.millis
          };
        case "Nanos":
          return {
            _id: "Duration",
            _tag: "Nanos",
            hrtime: toHrTime(this)
          };
        case "Infinity":
          return {
            _id: "Duration",
            _tag: "Infinity"
          };
      }
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var make7 = (input) => {
    const duration3 = Object.create(DurationProto);
    if (isNumber(input)) {
      if (isNaN(input) || input <= 0) {
        duration3.value = zeroValue;
      } else if (!Number.isFinite(input)) {
        duration3.value = infinityValue;
      } else if (!Number.isInteger(input)) {
        duration3.value = {
          _tag: "Nanos",
          nanos: BigInt(Math.round(input * 1e6))
        };
      } else {
        duration3.value = {
          _tag: "Millis",
          millis: input
        };
      }
    } else if (input <= bigint0) {
      duration3.value = zeroValue;
    } else {
      duration3.value = {
        _tag: "Nanos",
        nanos: input
      };
    }
    return duration3;
  };
  var isDuration = (u) => hasProperty(u, TypeId6);
  var isFinite = (self) => self.value._tag !== "Infinity";
  var isZero = (self) => {
    switch (self.value._tag) {
      case "Millis": {
        return self.value.millis === 0;
      }
      case "Nanos": {
        return self.value.nanos === bigint0;
      }
      case "Infinity": {
        return false;
      }
    }
  };
  var zero = /* @__PURE__ */ make7(0);
  var infinity = /* @__PURE__ */ make7(Infinity);
  var nanos = (nanos2) => make7(nanos2);
  var micros = (micros2) => make7(micros2 * bigint1e3);
  var millis = (millis2) => make7(millis2);
  var seconds = (seconds2) => make7(seconds2 * 1e3);
  var minutes = (minutes2) => make7(minutes2 * 6e4);
  var hours = (hours2) => make7(hours2 * 36e5);
  var days = (days2) => make7(days2 * 864e5);
  var weeks = (weeks2) => make7(weeks2 * 6048e5);
  var toMillis = (self) => match3(self, {
    onMillis: (millis2) => millis2,
    onNanos: (nanos2) => Number(nanos2) / 1e6
  });
  var toSeconds = (self) => match3(self, {
    onMillis: (millis2) => millis2 / 1e3,
    onNanos: (nanos2) => Number(nanos2) / 1e9
  });
  var toMinutes = (self) => match3(self, {
    onMillis: (millis2) => millis2 / 6e4,
    onNanos: (nanos2) => Number(nanos2) / 6e10
  });
  var toHours = (self) => match3(self, {
    onMillis: (millis2) => millis2 / 36e5,
    onNanos: (nanos2) => Number(nanos2) / 36e11
  });
  var toDays = (self) => match3(self, {
    onMillis: (millis2) => millis2 / 864e5,
    onNanos: (nanos2) => Number(nanos2) / 864e11
  });
  var toWeeks = (self) => match3(self, {
    onMillis: (millis2) => millis2 / 6048e5,
    onNanos: (nanos2) => Number(nanos2) / 6048e11
  });
  var toNanos = (self) => {
    const _self = decode(self);
    switch (_self.value._tag) {
      case "Infinity":
        return none2();
      case "Nanos":
        return some2(_self.value.nanos);
      case "Millis":
        return some2(BigInt(Math.round(_self.value.millis * 1e6)));
    }
  };
  var unsafeToNanos = (self) => {
    const _self = decode(self);
    switch (_self.value._tag) {
      case "Infinity":
        throw new Error("Cannot convert infinite duration to nanos");
      case "Nanos":
        return _self.value.nanos;
      case "Millis":
        return BigInt(Math.round(_self.value.millis * 1e6));
    }
  };
  var toHrTime = (self) => {
    const _self = decode(self);
    switch (_self.value._tag) {
      case "Infinity":
        return [Infinity, 0];
      case "Nanos":
        return [Number(_self.value.nanos / bigint1e9), Number(_self.value.nanos % bigint1e9)];
      case "Millis":
        return [Math.floor(_self.value.millis / 1e3), Math.round(_self.value.millis % 1e3 * 1e6)];
    }
  };
  var match3 = /* @__PURE__ */ dual(2, (self, options) => {
    const _self = decode(self);
    switch (_self.value._tag) {
      case "Nanos":
        return options.onNanos(_self.value.nanos);
      case "Infinity":
        return options.onMillis(Infinity);
      case "Millis":
        return options.onMillis(_self.value.millis);
    }
  });
  var matchWith = /* @__PURE__ */ dual(3, (self, that, options) => {
    const _self = decode(self);
    const _that = decode(that);
    if (_self.value._tag === "Infinity" || _that.value._tag === "Infinity") {
      return options.onMillis(toMillis(_self), toMillis(_that));
    } else if (_self.value._tag === "Nanos" || _that.value._tag === "Nanos") {
      const selfNanos = _self.value._tag === "Nanos" ? _self.value.nanos : BigInt(Math.round(_self.value.millis * 1e6));
      const thatNanos = _that.value._tag === "Nanos" ? _that.value.nanos : BigInt(Math.round(_that.value.millis * 1e6));
      return options.onNanos(selfNanos, thatNanos);
    }
    return options.onMillis(_self.value.millis, _that.value.millis);
  });
  var Order2 = /* @__PURE__ */ make2((self, that) => matchWith(self, that, {
    onMillis: (self2, that2) => self2 < that2 ? -1 : self2 > that2 ? 1 : 0,
    onNanos: (self2, that2) => self2 < that2 ? -1 : self2 > that2 ? 1 : 0
  }));
  var between2 = /* @__PURE__ */ between(/* @__PURE__ */ mapInput2(Order2, decode));
  var Equivalence = (self, that) => matchWith(self, that, {
    onMillis: (self2, that2) => self2 === that2,
    onNanos: (self2, that2) => self2 === that2
  });
  var _min = /* @__PURE__ */ min(Order2);
  var min2 = /* @__PURE__ */ dual(2, (self, that) => _min(decode(self), decode(that)));
  var _max = /* @__PURE__ */ max(Order2);
  var max2 = /* @__PURE__ */ dual(2, (self, that) => _max(decode(self), decode(that)));
  var _clamp = /* @__PURE__ */ clamp(Order2);
  var clamp3 = /* @__PURE__ */ dual(2, (self, options) => _clamp(decode(self), {
    minimum: decode(options.minimum),
    maximum: decode(options.maximum)
  }));
  var divide = /* @__PURE__ */ dual(2, (self, by) => match3(self, {
    onMillis: (millis2) => {
      if (by === 0 || isNaN(by) || !Number.isFinite(by)) {
        return none2();
      }
      return some2(make7(millis2 / by));
    },
    onNanos: (nanos2) => {
      if (isNaN(by) || by <= 0 || !Number.isFinite(by)) {
        return none2();
      }
      try {
        return some2(make7(nanos2 / BigInt(by)));
      } catch {
        return none2();
      }
    }
  }));
  var unsafeDivide = /* @__PURE__ */ dual(2, (self, by) => match3(self, {
    onMillis: (millis2) => make7(millis2 / by),
    onNanos: (nanos2) => {
      if (isNaN(by) || by < 0 || Object.is(by, -0)) {
        return zero;
      } else if (Object.is(by, 0) || !Number.isFinite(by)) {
        return infinity;
      }
      return make7(nanos2 / BigInt(by));
    }
  }));
  var times = /* @__PURE__ */ dual(2, (self, times2) => match3(self, {
    onMillis: (millis2) => make7(millis2 * times2),
    onNanos: (nanos2) => make7(nanos2 * BigInt(times2))
  }));
  var subtract = /* @__PURE__ */ dual(2, (self, that) => matchWith(self, that, {
    onMillis: (self2, that2) => make7(self2 - that2),
    onNanos: (self2, that2) => make7(self2 - that2)
  }));
  var sum = /* @__PURE__ */ dual(2, (self, that) => matchWith(self, that, {
    onMillis: (self2, that2) => make7(self2 + that2),
    onNanos: (self2, that2) => make7(self2 + that2)
  }));
  var lessThan2 = /* @__PURE__ */ dual(2, (self, that) => matchWith(self, that, {
    onMillis: (self2, that2) => self2 < that2,
    onNanos: (self2, that2) => self2 < that2
  }));
  var lessThanOrEqualTo2 = /* @__PURE__ */ dual(2, (self, that) => matchWith(self, that, {
    onMillis: (self2, that2) => self2 <= that2,
    onNanos: (self2, that2) => self2 <= that2
  }));
  var greaterThan2 = /* @__PURE__ */ dual(2, (self, that) => matchWith(self, that, {
    onMillis: (self2, that2) => self2 > that2,
    onNanos: (self2, that2) => self2 > that2
  }));
  var greaterThanOrEqualTo2 = /* @__PURE__ */ dual(2, (self, that) => matchWith(self, that, {
    onMillis: (self2, that2) => self2 >= that2,
    onNanos: (self2, that2) => self2 >= that2
  }));
  var equals2 = /* @__PURE__ */ dual(2, (self, that) => Equivalence(decode(self), decode(that)));
  var parts = (self) => {
    const duration3 = decode(self);
    if (duration3.value._tag === "Infinity") {
      return {
        days: Infinity,
        hours: Infinity,
        minutes: Infinity,
        seconds: Infinity,
        millis: Infinity,
        nanos: Infinity
      };
    }
    const nanos2 = unsafeToNanos(duration3);
    const ms = nanos2 / bigint1e6;
    const sec = ms / bigint1e3;
    const min4 = sec / bigint60;
    const hr = min4 / bigint60;
    const days2 = hr / bigint24;
    return {
      days: Number(days2),
      hours: Number(hr % bigint24),
      minutes: Number(min4 % bigint60),
      seconds: Number(sec % bigint60),
      millis: Number(ms % bigint1e3),
      nanos: Number(nanos2 % bigint1e6)
    };
  };
  var format3 = (self) => {
    const duration3 = decode(self);
    if (duration3.value._tag === "Infinity") {
      return "Infinity";
    }
    if (isZero(duration3)) {
      return "0";
    }
    const fragments = parts(duration3);
    const pieces = [];
    if (fragments.days !== 0) {
      pieces.push(`${fragments.days}d`);
    }
    if (fragments.hours !== 0) {
      pieces.push(`${fragments.hours}h`);
    }
    if (fragments.minutes !== 0) {
      pieces.push(`${fragments.minutes}m`);
    }
    if (fragments.seconds !== 0) {
      pieces.push(`${fragments.seconds}s`);
    }
    if (fragments.millis !== 0) {
      pieces.push(`${fragments.millis}ms`);
    }
    if (fragments.nanos !== 0) {
      pieces.push(`${fragments.nanos}ns`);
    }
    return pieces.join(" ");
  };
  var unsafeFormatIso = (self) => {
    const duration3 = decode(self);
    if (!isFinite(duration3)) {
      throw new RangeError("Cannot format infinite duration");
    }
    const fragments = [];
    const {
      days: days2,
      hours: hours2,
      millis: millis2,
      minutes: minutes2,
      nanos: nanos2,
      seconds: seconds2
    } = parts(duration3);
    let rest = days2;
    if (rest >= 365) {
      const years = Math.floor(rest / 365);
      rest %= 365;
      fragments.push(`${years}Y`);
    }
    if (rest >= 30) {
      const months = Math.floor(rest / 30);
      rest %= 30;
      fragments.push(`${months}M`);
    }
    if (rest >= 7) {
      const weeks2 = Math.floor(rest / 7);
      rest %= 7;
      fragments.push(`${weeks2}W`);
    }
    if (rest > 0) {
      fragments.push(`${rest}D`);
    }
    if (hours2 !== 0 || minutes2 !== 0 || seconds2 !== 0 || millis2 !== 0 || nanos2 !== 0) {
      fragments.push("T");
      if (hours2 !== 0) {
        fragments.push(`${hours2}H`);
      }
      if (minutes2 !== 0) {
        fragments.push(`${minutes2}M`);
      }
      if (seconds2 !== 0 || millis2 !== 0 || nanos2 !== 0) {
        const total = BigInt(seconds2) * bigint1e9 + BigInt(millis2) * bigint1e6 + BigInt(nanos2);
        const str = (Number(total) / 1e9).toFixed(9).replace(/\.?0+$/, "");
        fragments.push(`${str}S`);
      }
    }
    return `P${fragments.join("") || "T0S"}`;
  };
  var formatIso = (self) => {
    const duration3 = decode(self);
    return isFinite(duration3) ? some2(unsafeFormatIso(duration3)) : none2();
  };
  var fromIso = (iso) => {
    const result = DURATION_ISO_REGEX.exec(iso);
    if (result == null) {
      return none2();
    }
    const [years, months, weeks2, days2, hours2, mins, secs] = result.slice(1, 8).map((_) => _ ? Number(_) : 0);
    const value = years * 365 * 24 * 60 * 60 + months * 30 * 24 * 60 * 60 + weeks2 * 7 * 24 * 60 * 60 + days2 * 24 * 60 * 60 + hours2 * 60 * 60 + mins * 60 + secs;
    return some2(seconds(value));
  };
  var DURATION_ISO_REGEX = /^P(?!$)(?:(\d+)Y)?(?:(\d+)M)?(?:(\d+)W)?(?:(\d+)D)?(?:T(?!$)(?:(\d+)H)?(?:(\d+)M)?(?:(\d+(?:\.\d+)?)S)?)?$/;

  // <eztb>/node_modules/effect/dist/esm/internal/hashMap/config.js
  var SIZE = 5;
  var BUCKET_SIZE = /* @__PURE__ */ Math.pow(2, SIZE);
  var MASK = BUCKET_SIZE - 1;
  var MAX_INDEX_NODE = BUCKET_SIZE / 2;
  var MIN_ARRAY_NODE = BUCKET_SIZE / 4;

  // <eztb>/node_modules/effect/dist/esm/internal/hashMap/bitwise.js
  function popcount(x) {
    x -= x >> 1 & 1431655765;
    x = (x & 858993459) + (x >> 2 & 858993459);
    x = x + (x >> 4) & 252645135;
    x += x >> 8;
    x += x >> 16;
    return x & 127;
  }
  function hashFragment(shift2, h) {
    return h >>> shift2 & MASK;
  }
  function toBitmap(x) {
    return 1 << x;
  }
  function fromBitmap(bitmap, bit) {
    return popcount(bitmap & bit - 1);
  }

  // <eztb>/node_modules/effect/dist/esm/internal/stack.js
  var make8 = (value, previous) => ({
    value,
    previous
  });

  // <eztb>/node_modules/effect/dist/esm/internal/hashMap/array.js
  function arrayUpdate(mutate5, at, v, arr) {
    let out = arr;
    if (!mutate5) {
      const len = arr.length;
      out = new Array(len);
      for (let i = 0; i < len; ++i) out[i] = arr[i];
    }
    out[at] = v;
    return out;
  }
  function arraySpliceOut(mutate5, at, arr) {
    const newLen = arr.length - 1;
    let i = 0;
    let g = 0;
    let out = arr;
    if (mutate5) {
      i = g = at;
    } else {
      out = new Array(newLen);
      while (i < at) out[g++] = arr[i++];
    }
    ++i;
    while (i <= newLen) out[g++] = arr[i++];
    if (mutate5) {
      out.length = newLen;
    }
    return out;
  }
  function arraySpliceIn(mutate5, at, v, arr) {
    const len = arr.length;
    if (mutate5) {
      let i2 = len;
      while (i2 >= at) arr[i2--] = arr[i2];
      arr[at] = v;
      return arr;
    }
    let i = 0, g = 0;
    const out = new Array(len + 1);
    while (i < at) out[g++] = arr[i++];
    out[at] = v;
    while (i < len) out[++g] = arr[i++];
    return out;
  }

  // <eztb>/node_modules/effect/dist/esm/internal/hashMap/node.js
  var EmptyNode = class _EmptyNode {
    constructor() {
      __publicField(this, "_tag", "EmptyNode");
    }
    modify(edit, _shift, f, hash2, key, size9) {
      const v = f(none2());
      if (isNone2(v)) return new _EmptyNode();
      ++size9.value;
      return new LeafNode(edit, hash2, key, v);
    }
  };
  function isEmptyNode(a) {
    return isTagged(a, "EmptyNode");
  }
  function isLeafNode(node) {
    return isEmptyNode(node) || node._tag === "LeafNode" || node._tag === "CollisionNode";
  }
  function canEditNode(node, edit) {
    return isEmptyNode(node) ? false : edit === node.edit;
  }
  var LeafNode = class _LeafNode {
    constructor(edit, hash2, key, value) {
      __publicField(this, "edit");
      __publicField(this, "hash");
      __publicField(this, "key");
      __publicField(this, "value");
      __publicField(this, "_tag", "LeafNode");
      this.edit = edit;
      this.hash = hash2;
      this.key = key;
      this.value = value;
    }
    modify(edit, shift2, f, hash2, key, size9) {
      if (equals(key, this.key)) {
        const v2 = f(this.value);
        if (v2 === this.value) return this;
        else if (isNone2(v2)) {
          --size9.value;
          return new EmptyNode();
        }
        if (canEditNode(this, edit)) {
          this.value = v2;
          return this;
        }
        return new _LeafNode(edit, hash2, key, v2);
      }
      const v = f(none2());
      if (isNone2(v)) return this;
      ++size9.value;
      return mergeLeaves(edit, shift2, this.hash, this, hash2, new _LeafNode(edit, hash2, key, v));
    }
  };
  var CollisionNode = class _CollisionNode {
    constructor(edit, hash2, children) {
      __publicField(this, "edit");
      __publicField(this, "hash");
      __publicField(this, "children");
      __publicField(this, "_tag", "CollisionNode");
      this.edit = edit;
      this.hash = hash2;
      this.children = children;
    }
    modify(edit, shift2, f, hash2, key, size9) {
      if (hash2 === this.hash) {
        const canEdit = canEditNode(this, edit);
        const list = this.updateCollisionList(canEdit, edit, this.hash, this.children, f, key, size9);
        if (list === this.children) return this;
        return list.length > 1 ? new _CollisionNode(edit, this.hash, list) : list[0];
      }
      const v = f(none2());
      if (isNone2(v)) return this;
      ++size9.value;
      return mergeLeaves(edit, shift2, this.hash, this, hash2, new LeafNode(edit, hash2, key, v));
    }
    updateCollisionList(mutate5, edit, hash2, list, f, key, size9) {
      const len = list.length;
      for (let i = 0; i < len; ++i) {
        const child = list[i];
        if ("key" in child && equals(key, child.key)) {
          const value = child.value;
          const newValue2 = f(value);
          if (newValue2 === value) return list;
          if (isNone2(newValue2)) {
            --size9.value;
            return arraySpliceOut(mutate5, i, list);
          }
          return arrayUpdate(mutate5, i, new LeafNode(edit, hash2, key, newValue2), list);
        }
      }
      const newValue = f(none2());
      if (isNone2(newValue)) return list;
      ++size9.value;
      return arrayUpdate(mutate5, len, new LeafNode(edit, hash2, key, newValue), list);
    }
  };
  var IndexedNode = class _IndexedNode {
    constructor(edit, mask2, children) {
      __publicField(this, "edit");
      __publicField(this, "mask");
      __publicField(this, "children");
      __publicField(this, "_tag", "IndexedNode");
      this.edit = edit;
      this.mask = mask2;
      this.children = children;
    }
    modify(edit, shift2, f, hash2, key, size9) {
      const mask2 = this.mask;
      const children = this.children;
      const frag = hashFragment(shift2, hash2);
      const bit = toBitmap(frag);
      const indx = fromBitmap(mask2, bit);
      const exists3 = mask2 & bit;
      const canEdit = canEditNode(this, edit);
      if (!exists3) {
        const _newChild = new EmptyNode().modify(edit, shift2 + SIZE, f, hash2, key, size9);
        if (!_newChild) return this;
        return children.length >= MAX_INDEX_NODE ? expand(edit, frag, _newChild, mask2, children) : new _IndexedNode(edit, mask2 | bit, arraySpliceIn(canEdit, indx, _newChild, children));
      }
      const current = children[indx];
      const child = current.modify(edit, shift2 + SIZE, f, hash2, key, size9);
      if (current === child) return this;
      let bitmap = mask2;
      let newChildren;
      if (isEmptyNode(child)) {
        bitmap &= ~bit;
        if (!bitmap) return new EmptyNode();
        if (children.length <= 2 && isLeafNode(children[indx ^ 1])) {
          return children[indx ^ 1];
        }
        newChildren = arraySpliceOut(canEdit, indx, children);
      } else {
        newChildren = arrayUpdate(canEdit, indx, child, children);
      }
      if (canEdit) {
        this.mask = bitmap;
        this.children = newChildren;
        return this;
      }
      return new _IndexedNode(edit, bitmap, newChildren);
    }
  };
  var ArrayNode = class _ArrayNode {
    constructor(edit, size9, children) {
      __publicField(this, "edit");
      __publicField(this, "size");
      __publicField(this, "children");
      __publicField(this, "_tag", "ArrayNode");
      this.edit = edit;
      this.size = size9;
      this.children = children;
    }
    modify(edit, shift2, f, hash2, key, size9) {
      let count3 = this.size;
      const children = this.children;
      const frag = hashFragment(shift2, hash2);
      const child = children[frag];
      const newChild = (child || new EmptyNode()).modify(edit, shift2 + SIZE, f, hash2, key, size9);
      if (child === newChild) return this;
      const canEdit = canEditNode(this, edit);
      let newChildren;
      if (isEmptyNode(child) && !isEmptyNode(newChild)) {
        ++count3;
        newChildren = arrayUpdate(canEdit, frag, newChild, children);
      } else if (!isEmptyNode(child) && isEmptyNode(newChild)) {
        --count3;
        if (count3 <= MIN_ARRAY_NODE) {
          return pack(edit, count3, frag, children);
        }
        newChildren = arrayUpdate(canEdit, frag, new EmptyNode(), children);
      } else {
        newChildren = arrayUpdate(canEdit, frag, newChild, children);
      }
      if (canEdit) {
        this.size = count3;
        this.children = newChildren;
        return this;
      }
      return new _ArrayNode(edit, count3, newChildren);
    }
  };
  function pack(edit, count3, removed, elements) {
    const children = new Array(count3 - 1);
    let g = 0;
    let bitmap = 0;
    for (let i = 0, len = elements.length; i < len; ++i) {
      if (i !== removed) {
        const elem = elements[i];
        if (elem && !isEmptyNode(elem)) {
          children[g++] = elem;
          bitmap |= 1 << i;
        }
      }
    }
    return new IndexedNode(edit, bitmap, children);
  }
  function expand(edit, frag, child, bitmap, subNodes) {
    const arr = [];
    let bit = bitmap;
    let count3 = 0;
    for (let i = 0; bit; ++i) {
      if (bit & 1) arr[i] = subNodes[count3++];
      bit >>>= 1;
    }
    arr[frag] = child;
    return new ArrayNode(edit, count3 + 1, arr);
  }
  function mergeLeavesInner(edit, shift2, h1, n1, h2, n2) {
    if (h1 === h2) return new CollisionNode(edit, h1, [n2, n1]);
    const subH1 = hashFragment(shift2, h1);
    const subH2 = hashFragment(shift2, h2);
    if (subH1 === subH2) {
      return (child) => new IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), [child]);
    } else {
      const children = subH1 < subH2 ? [n1, n2] : [n2, n1];
      return new IndexedNode(edit, toBitmap(subH1) | toBitmap(subH2), children);
    }
  }
  function mergeLeaves(edit, shift2, h1, n1, h2, n2) {
    let stack = void 0;
    let currentShift = shift2;
    while (true) {
      const res = mergeLeavesInner(edit, currentShift, h1, n1, h2, n2);
      if (typeof res === "function") {
        stack = make8(res, stack);
        currentShift = currentShift + SIZE;
      } else {
        let final = res;
        while (stack != null) {
          final = stack.value(final);
          stack = stack.previous;
        }
        return final;
      }
    }
  }

  // <eztb>/node_modules/effect/dist/esm/internal/hashMap.js
  var HashMapSymbolKey = "effect/HashMap";
  var HashMapTypeId = /* @__PURE__ */ Symbol.for(HashMapSymbolKey);
  var HashMapProto = {
    [HashMapTypeId]: HashMapTypeId,
    [Symbol.iterator]() {
      return new HashMapIterator(this, (k, v) => [k, v]);
    },
    [symbol]() {
      let hash2 = hash(HashMapSymbolKey);
      for (const item of this) {
        hash2 ^= pipe(hash(item[0]), combine(hash(item[1])));
      }
      return cached(this, hash2);
    },
    [symbol2](that) {
      if (isHashMap(that)) {
        if (that._size !== this._size) {
          return false;
        }
        for (const item of this) {
          const elem = pipe(that, getHash(item[0], hash(item[0])));
          if (isNone2(elem)) {
            return false;
          } else {
            if (!equals(item[1], elem.value)) {
              return false;
            }
          }
        }
        return true;
      }
      return false;
    },
    toString() {
      return format2(this.toJSON());
    },
    toJSON() {
      return {
        _id: "HashMap",
        values: Array.from(this).map(toJSON)
      };
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var makeImpl = (editable, edit, root, size9) => {
    const map14 = Object.create(HashMapProto);
    map14._editable = editable;
    map14._edit = edit;
    map14._root = root;
    map14._size = size9;
    return map14;
  };
  var HashMapIterator = class _HashMapIterator {
    constructor(map14, f) {
      __publicField(this, "map");
      __publicField(this, "f");
      __publicField(this, "v");
      this.map = map14;
      this.f = f;
      this.v = visitLazy(this.map._root, this.f, void 0);
    }
    next() {
      if (isNone2(this.v)) {
        return {
          done: true,
          value: void 0
        };
      }
      const v0 = this.v.value;
      this.v = applyCont(v0.cont);
      return {
        done: false,
        value: v0.value
      };
    }
    [Symbol.iterator]() {
      return new _HashMapIterator(this.map, this.f);
    }
  };
  var applyCont = (cont) => cont ? visitLazyChildren(cont[0], cont[1], cont[2], cont[3], cont[4]) : none2();
  var visitLazy = (node, f, cont = void 0) => {
    switch (node._tag) {
      case "LeafNode": {
        if (isSome2(node.value)) {
          return some2({
            value: f(node.key, node.value.value),
            cont
          });
        }
        return applyCont(cont);
      }
      case "CollisionNode":
      case "ArrayNode":
      case "IndexedNode": {
        const children = node.children;
        return visitLazyChildren(children.length, children, 0, f, cont);
      }
      default: {
        return applyCont(cont);
      }
    }
  };
  var visitLazyChildren = (len, children, i, f, cont) => {
    while (i < len) {
      const child = children[i++];
      if (child && !isEmptyNode(child)) {
        return visitLazy(child, f, [len, children, i, f, cont]);
      }
    }
    return applyCont(cont);
  };
  var _empty3 = /* @__PURE__ */ makeImpl(false, 0, /* @__PURE__ */ new EmptyNode(), 0);
  var empty5 = () => _empty3;
  var fromIterable3 = (entries2) => {
    const map14 = beginMutation(empty5());
    for (const entry of entries2) {
      set(map14, entry[0], entry[1]);
    }
    return endMutation(map14);
  };
  var isHashMap = (u) => hasProperty(u, HashMapTypeId);
  var isEmpty2 = (self) => self && isEmptyNode(self._root);
  var get5 = /* @__PURE__ */ dual(2, (self, key) => getHash(self, key, hash(key)));
  var getHash = /* @__PURE__ */ dual(3, (self, key, hash2) => {
    let node = self._root;
    let shift2 = 0;
    while (true) {
      switch (node._tag) {
        case "LeafNode": {
          return equals(key, node.key) ? node.value : none2();
        }
        case "CollisionNode": {
          if (hash2 === node.hash) {
            const children = node.children;
            for (let i = 0, len = children.length; i < len; ++i) {
              const child = children[i];
              if ("key" in child && equals(key, child.key)) {
                return child.value;
              }
            }
          }
          return none2();
        }
        case "IndexedNode": {
          const frag = hashFragment(shift2, hash2);
          const bit = toBitmap(frag);
          if (node.mask & bit) {
            node = node.children[fromBitmap(node.mask, bit)];
            shift2 += SIZE;
            break;
          }
          return none2();
        }
        case "ArrayNode": {
          node = node.children[hashFragment(shift2, hash2)];
          if (node) {
            shift2 += SIZE;
            break;
          }
          return none2();
        }
        default:
          return none2();
      }
    }
  });
  var has = /* @__PURE__ */ dual(2, (self, key) => isSome2(getHash(self, key, hash(key))));
  var set = /* @__PURE__ */ dual(3, (self, key, value) => modifyAt(self, key, () => some2(value)));
  var setTree = /* @__PURE__ */ dual(3, (self, newRoot, newSize) => {
    if (self._editable) {
      ;
      self._root = newRoot;
      self._size = newSize;
      return self;
    }
    return newRoot === self._root ? self : makeImpl(self._editable, self._edit, newRoot, newSize);
  });
  var keys = (self) => new HashMapIterator(self, (key) => key);
  var size = (self) => self._size;
  var beginMutation = (self) => makeImpl(true, self._edit + 1, self._root, self._size);
  var endMutation = (self) => {
    ;
    self._editable = false;
    return self;
  };
  var mutate = /* @__PURE__ */ dual(2, (self, f) => {
    const transient = beginMutation(self);
    f(transient);
    return endMutation(transient);
  });
  var modifyAt = /* @__PURE__ */ dual(3, (self, key, f) => modifyHash(self, key, hash(key), f));
  var modifyHash = /* @__PURE__ */ dual(4, (self, key, hash2, f) => {
    const size9 = {
      value: self._size
    };
    const newRoot = self._root.modify(self._editable ? self._edit : NaN, 0, f, hash2, key, size9);
    return pipe(self, setTree(newRoot, size9.value));
  });
  var remove2 = /* @__PURE__ */ dual(2, (self, key) => modifyAt(self, key, none2));
  var map4 = /* @__PURE__ */ dual(2, (self, f) => reduce2(self, empty5(), (map14, value, key) => set(map14, key, f(value, key))));
  var forEach = /* @__PURE__ */ dual(2, (self, f) => reduce2(self, void 0, (_, value, key) => f(value, key)));
  var reduce2 = /* @__PURE__ */ dual(3, (self, zero2, f) => {
    const root = self._root;
    if (root._tag === "LeafNode") {
      return isSome2(root.value) ? f(zero2, root.value.value, root.key) : zero2;
    }
    if (root._tag === "EmptyNode") {
      return zero2;
    }
    const toVisit = [root.children];
    let children;
    while (children = toVisit.pop()) {
      for (let i = 0, len = children.length; i < len; ) {
        const child = children[i++];
        if (child && !isEmptyNode(child)) {
          if (child._tag === "LeafNode") {
            if (isSome2(child.value)) {
              zero2 = f(zero2, child.value.value, child.key);
            }
          } else {
            toVisit.push(child.children);
          }
        }
      }
    }
    return zero2;
  });

  // <eztb>/node_modules/effect/dist/esm/internal/hashSet.js
  var HashSetSymbolKey = "effect/HashSet";
  var HashSetTypeId = /* @__PURE__ */ Symbol.for(HashSetSymbolKey);
  var HashSetProto = {
    [HashSetTypeId]: HashSetTypeId,
    [Symbol.iterator]() {
      return keys(this._keyMap);
    },
    [symbol]() {
      return cached(this, combine(hash(this._keyMap))(hash(HashSetSymbolKey)));
    },
    [symbol2](that) {
      if (isHashSet(that)) {
        return size(this._keyMap) === size(that._keyMap) && equals(this._keyMap, that._keyMap);
      }
      return false;
    },
    toString() {
      return format2(this.toJSON());
    },
    toJSON() {
      return {
        _id: "HashSet",
        values: Array.from(this).map(toJSON)
      };
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var makeImpl2 = (keyMap) => {
    const set6 = Object.create(HashSetProto);
    set6._keyMap = keyMap;
    return set6;
  };
  var isHashSet = (u) => hasProperty(u, HashSetTypeId);
  var _empty4 = /* @__PURE__ */ makeImpl2(/* @__PURE__ */ empty5());
  var empty6 = () => _empty4;
  var fromIterable4 = (elements) => {
    const set6 = beginMutation2(empty6());
    for (const value of elements) {
      add3(set6, value);
    }
    return endMutation2(set6);
  };
  var make9 = (...elements) => {
    const set6 = beginMutation2(empty6());
    for (const value of elements) {
      add3(set6, value);
    }
    return endMutation2(set6);
  };
  var has2 = /* @__PURE__ */ dual(2, (self, value) => has(self._keyMap, value));
  var size2 = (self) => size(self._keyMap);
  var beginMutation2 = (self) => makeImpl2(beginMutation(self._keyMap));
  var endMutation2 = (self) => {
    ;
    self._keyMap._editable = false;
    return self;
  };
  var mutate2 = /* @__PURE__ */ dual(2, (self, f) => {
    const transient = beginMutation2(self);
    f(transient);
    return endMutation2(transient);
  });
  var add3 = /* @__PURE__ */ dual(2, (self, value) => self._keyMap._editable ? (set(value, true)(self._keyMap), self) : makeImpl2(set(value, true)(self._keyMap)));
  var remove3 = /* @__PURE__ */ dual(2, (self, value) => self._keyMap._editable ? (remove2(value)(self._keyMap), self) : makeImpl2(remove2(value)(self._keyMap)));
  var difference2 = /* @__PURE__ */ dual(2, (self, that) => mutate2(self, (set6) => {
    for (const value of that) {
      remove3(set6, value);
    }
  }));
  var union2 = /* @__PURE__ */ dual(2, (self, that) => mutate2(empty6(), (set6) => {
    forEach2(self, (value) => add3(set6, value));
    for (const value of that) {
      add3(set6, value);
    }
  }));
  var forEach2 = /* @__PURE__ */ dual(2, (self, f) => forEach(self._keyMap, (_, k) => f(k)));
  var reduce3 = /* @__PURE__ */ dual(3, (self, zero2, f) => reduce2(self._keyMap, zero2, (z, _, a) => f(z, a)));

  // <eztb>/node_modules/effect/dist/esm/HashSet.js
  var empty7 = empty6;
  var fromIterable5 = fromIterable4;
  var make10 = make9;
  var has3 = has2;
  var size3 = size2;
  var add4 = add3;
  var remove4 = remove3;
  var difference3 = difference2;
  var union3 = union2;
  var reduce4 = reduce3;

  // <eztb>/node_modules/effect/dist/esm/MutableRef.js
  var TypeId7 = /* @__PURE__ */ Symbol.for("effect/MutableRef");
  var MutableRefProto = {
    [TypeId7]: TypeId7,
    toString() {
      return format2(this.toJSON());
    },
    toJSON() {
      return {
        _id: "MutableRef",
        current: toJSON(this.current)
      };
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var make11 = (value) => {
    const ref = Object.create(MutableRefProto);
    ref.current = value;
    return ref;
  };
  var compareAndSet = /* @__PURE__ */ dual(3, (self, oldValue, newValue) => {
    if (equals(oldValue, self.current)) {
      self.current = newValue;
      return true;
    }
    return false;
  });
  var get6 = (self) => self.current;
  var set2 = /* @__PURE__ */ dual(2, (self, value) => {
    self.current = value;
    return self;
  });

  // <eztb>/node_modules/effect/dist/esm/internal/fiberId.js
  var FiberIdSymbolKey = "effect/FiberId";
  var FiberIdTypeId = /* @__PURE__ */ Symbol.for(FiberIdSymbolKey);
  var OP_NONE = "None";
  var OP_RUNTIME = "Runtime";
  var OP_COMPOSITE = "Composite";
  var emptyHash = /* @__PURE__ */ string(`${FiberIdSymbolKey}-${OP_NONE}`);
  var _a2;
  var None = class {
    constructor() {
      __publicField(this, _a2, FiberIdTypeId);
      __publicField(this, "_tag", OP_NONE);
      __publicField(this, "id", -1);
      __publicField(this, "startTimeMillis", -1);
    }
    [(_a2 = FiberIdTypeId, symbol)]() {
      return emptyHash;
    }
    [symbol2](that) {
      return isFiberId(that) && that._tag === OP_NONE;
    }
    toString() {
      return format2(this.toJSON());
    }
    toJSON() {
      return {
        _id: "FiberId",
        _tag: this._tag
      };
    }
    [NodeInspectSymbol]() {
      return this.toJSON();
    }
  };
  var _a3;
  var Runtime = class {
    constructor(id, startTimeMillis) {
      __publicField(this, "id");
      __publicField(this, "startTimeMillis");
      __publicField(this, _a3, FiberIdTypeId);
      __publicField(this, "_tag", OP_RUNTIME);
      this.id = id;
      this.startTimeMillis = startTimeMillis;
    }
    [(_a3 = FiberIdTypeId, symbol)]() {
      return cached(this, string(`${FiberIdSymbolKey}-${this._tag}-${this.id}-${this.startTimeMillis}`));
    }
    [symbol2](that) {
      return isFiberId(that) && that._tag === OP_RUNTIME && this.id === that.id && this.startTimeMillis === that.startTimeMillis;
    }
    toString() {
      return format2(this.toJSON());
    }
    toJSON() {
      return {
        _id: "FiberId",
        _tag: this._tag,
        id: this.id,
        startTimeMillis: this.startTimeMillis
      };
    }
    [NodeInspectSymbol]() {
      return this.toJSON();
    }
  };
  var _a4;
  var Composite = class {
    constructor(left3, right3) {
      __publicField(this, "left");
      __publicField(this, "right");
      __publicField(this, _a4, FiberIdTypeId);
      __publicField(this, "_tag", OP_COMPOSITE);
      __publicField(this, "_hash");
      this.left = left3;
      this.right = right3;
    }
    [(_a4 = FiberIdTypeId, symbol)]() {
      return pipe(string(`${FiberIdSymbolKey}-${this._tag}`), combine(hash(this.left)), combine(hash(this.right)), cached(this));
    }
    [symbol2](that) {
      return isFiberId(that) && that._tag === OP_COMPOSITE && equals(this.left, that.left) && equals(this.right, that.right);
    }
    toString() {
      return format2(this.toJSON());
    }
    toJSON() {
      return {
        _id: "FiberId",
        _tag: this._tag,
        left: toJSON(this.left),
        right: toJSON(this.right)
      };
    }
    [NodeInspectSymbol]() {
      return this.toJSON();
    }
  };
  var none3 = /* @__PURE__ */ new None();
  var isFiberId = (self) => hasProperty(self, FiberIdTypeId);
  var combine2 = /* @__PURE__ */ dual(2, (self, that) => {
    if (self._tag === OP_NONE) {
      return that;
    }
    if (that._tag === OP_NONE) {
      return self;
    }
    return new Composite(self, that);
  });
  var ids = (self) => {
    switch (self._tag) {
      case OP_NONE: {
        return empty7();
      }
      case OP_RUNTIME: {
        return make10(self.id);
      }
      case OP_COMPOSITE: {
        return pipe(ids(self.left), union3(ids(self.right)));
      }
    }
  };
  var _fiberCounter = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Fiber/Id/_fiberCounter"), () => make11(0));
  var threadName = (self) => {
    const identifiers = Array.from(ids(self)).map((n) => `#${n}`).join(",");
    return identifiers;
  };
  var unsafeMake = () => {
    const id = get6(_fiberCounter);
    pipe(_fiberCounter, set2(id + 1));
    return new Runtime(id, Date.now());
  };

  // <eztb>/node_modules/effect/dist/esm/FiberId.js
  var none4 = none3;
  var combine3 = combine2;
  var threadName2 = threadName;
  var unsafeMake2 = unsafeMake;

  // <eztb>/node_modules/effect/dist/esm/HashMap.js
  var empty8 = empty5;
  var fromIterable6 = fromIterable3;
  var isEmpty3 = isEmpty2;
  var get7 = get5;
  var set3 = set;
  var keys2 = keys;
  var mutate3 = mutate;
  var modifyAt2 = modifyAt;
  var map6 = map4;
  var forEach3 = forEach;
  var reduce5 = reduce2;

  // <eztb>/node_modules/effect/dist/esm/List.js
  var TypeId8 = /* @__PURE__ */ Symbol.for("effect/List");
  var toArray2 = (self) => fromIterable(self);
  var getEquivalence4 = (isEquivalent) => mapInput(getEquivalence2(isEquivalent), toArray2);
  var _equivalence4 = /* @__PURE__ */ getEquivalence4(equals);
  var ConsProto = {
    [TypeId8]: TypeId8,
    _tag: "Cons",
    toString() {
      return format2(this.toJSON());
    },
    toJSON() {
      return {
        _id: "List",
        _tag: "Cons",
        values: toArray2(this).map(toJSON)
      };
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    [symbol2](that) {
      return isList(that) && this._tag === that._tag && _equivalence4(this, that);
    },
    [symbol]() {
      return cached(this, array2(toArray2(this)));
    },
    [Symbol.iterator]() {
      let done7 = false;
      let self = this;
      return {
        next() {
          if (done7) {
            return this.return();
          }
          if (self._tag === "Nil") {
            done7 = true;
            return this.return();
          }
          const value = self.head;
          self = self.tail;
          return {
            done: done7,
            value
          };
        },
        return(value) {
          if (!done7) {
            done7 = true;
          }
          return {
            done: true,
            value
          };
        }
      };
    },
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var makeCons = (head5, tail) => {
    const cons2 = Object.create(ConsProto);
    cons2.head = head5;
    cons2.tail = tail;
    return cons2;
  };
  var NilHash = /* @__PURE__ */ string("Nil");
  var NilProto = {
    [TypeId8]: TypeId8,
    _tag: "Nil",
    toString() {
      return format2(this.toJSON());
    },
    toJSON() {
      return {
        _id: "List",
        _tag: "Nil"
      };
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    [symbol]() {
      return NilHash;
    },
    [symbol2](that) {
      return isList(that) && this._tag === that._tag;
    },
    [Symbol.iterator]() {
      return {
        next() {
          return {
            done: true,
            value: void 0
          };
        }
      };
    },
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var _Nil = /* @__PURE__ */ Object.create(NilProto);
  var isList = (u) => hasProperty(u, TypeId8);
  var isNil = (self) => self._tag === "Nil";
  var isCons = (self) => self._tag === "Cons";
  var nil = () => _Nil;
  var cons = (head5, tail) => makeCons(head5, tail);
  var empty9 = nil;
  var of3 = (value) => makeCons(value, _Nil);
  var appendAll3 = /* @__PURE__ */ dual(2, (self, that) => prependAll(that, self));
  var prepend3 = /* @__PURE__ */ dual(2, (self, element) => cons(element, self));
  var prependAll = /* @__PURE__ */ dual(2, (self, prefix) => {
    if (isNil(self)) {
      return prefix;
    } else if (isNil(prefix)) {
      return self;
    } else {
      const result = makeCons(prefix.head, self);
      let curr = result;
      let that = prefix.tail;
      while (!isNil(that)) {
        const temp = makeCons(that.head, self);
        curr.tail = temp;
        curr = temp;
        that = that.tail;
      }
      return result;
    }
  });
  var reduce6 = /* @__PURE__ */ dual(3, (self, zero2, f) => {
    let acc = zero2;
    let these = self;
    while (!isNil(these)) {
      acc = f(acc, these.head);
      these = these.tail;
    }
    return acc;
  });
  var reverse3 = (self) => {
    let result = empty9();
    let these = self;
    while (!isNil(these)) {
      result = prepend3(result, these.head);
      these = these.tail;
    }
    return result;
  };

  // <eztb>/node_modules/effect/dist/esm/internal/data.js
  var ArrayProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(Array.prototype), {
    [symbol]() {
      return cached(this, array2(this));
    },
    [symbol2](that) {
      if (Array.isArray(that) && this.length === that.length) {
        return this.every((v, i) => equals(v, that[i]));
      } else {
        return false;
      }
    }
  });
  var Structural = /* @__PURE__ */ (function() {
    function Structural2(args2) {
      if (args2) {
        Object.assign(this, args2);
      }
    }
    Structural2.prototype = StructuralPrototype;
    return Structural2;
  })();
  var struct = (as6) => Object.assign(Object.create(StructuralPrototype), as6);

  // <eztb>/node_modules/effect/dist/esm/internal/differ/contextPatch.js
  var ContextPatchTypeId = /* @__PURE__ */ Symbol.for("effect/DifferContextPatch");
  function variance(a) {
    return a;
  }
  var PatchProto = {
    ...Structural.prototype,
    [ContextPatchTypeId]: {
      _Value: variance,
      _Patch: variance
    }
  };
  var EmptyProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(PatchProto), {
    _tag: "Empty"
  });
  var _empty5 = /* @__PURE__ */ Object.create(EmptyProto);
  var empty10 = () => _empty5;
  var AndThenProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(PatchProto), {
    _tag: "AndThen"
  });
  var makeAndThen = (first2, second) => {
    const o = Object.create(AndThenProto);
    o.first = first2;
    o.second = second;
    return o;
  };
  var AddServiceProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(PatchProto), {
    _tag: "AddService"
  });
  var makeAddService = (key, service) => {
    const o = Object.create(AddServiceProto);
    o.key = key;
    o.service = service;
    return o;
  };
  var RemoveServiceProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(PatchProto), {
    _tag: "RemoveService"
  });
  var makeRemoveService = (key) => {
    const o = Object.create(RemoveServiceProto);
    o.key = key;
    return o;
  };
  var UpdateServiceProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(PatchProto), {
    _tag: "UpdateService"
  });
  var makeUpdateService = (key, update5) => {
    const o = Object.create(UpdateServiceProto);
    o.key = key;
    o.update = update5;
    return o;
  };
  var diff = (oldValue, newValue) => {
    const missingServices = new Map(oldValue.unsafeMap);
    let patch9 = empty10();
    for (const [tag, newService] of newValue.unsafeMap.entries()) {
      if (missingServices.has(tag)) {
        const old = missingServices.get(tag);
        missingServices.delete(tag);
        if (!equals(old, newService)) {
          patch9 = combine4(makeUpdateService(tag, () => newService))(patch9);
        }
      } else {
        missingServices.delete(tag);
        patch9 = combine4(makeAddService(tag, newService))(patch9);
      }
    }
    for (const [tag] of missingServices.entries()) {
      patch9 = combine4(makeRemoveService(tag))(patch9);
    }
    return patch9;
  };
  var combine4 = /* @__PURE__ */ dual(2, (self, that) => makeAndThen(self, that));
  var patch = /* @__PURE__ */ dual(2, (self, context4) => {
    if (self._tag === "Empty") {
      return context4;
    }
    let wasServiceUpdated = false;
    let patches = of2(self);
    const updatedContext = new Map(context4.unsafeMap);
    while (isNonEmpty(patches)) {
      const head5 = headNonEmpty2(patches);
      const tail = tailNonEmpty2(patches);
      switch (head5._tag) {
        case "Empty": {
          patches = tail;
          break;
        }
        case "AddService": {
          updatedContext.set(head5.key, head5.service);
          patches = tail;
          break;
        }
        case "AndThen": {
          patches = prepend2(prepend2(tail, head5.second), head5.first);
          break;
        }
        case "RemoveService": {
          updatedContext.delete(head5.key);
          patches = tail;
          break;
        }
        case "UpdateService": {
          updatedContext.set(head5.key, head5.update(updatedContext.get(head5.key)));
          wasServiceUpdated = true;
          patches = tail;
          break;
        }
      }
    }
    if (!wasServiceUpdated) {
      return makeContext(updatedContext);
    }
    const map14 = /* @__PURE__ */ new Map();
    for (const [tag] of context4.unsafeMap) {
      if (updatedContext.has(tag)) {
        map14.set(tag, updatedContext.get(tag));
        updatedContext.delete(tag);
      }
    }
    for (const [tag, s] of updatedContext) {
      map14.set(tag, s);
    }
    return makeContext(map14);
  });

  // <eztb>/node_modules/effect/dist/esm/internal/differ/hashSetPatch.js
  var HashSetPatchTypeId = /* @__PURE__ */ Symbol.for("effect/DifferHashSetPatch");
  function variance2(a) {
    return a;
  }
  var PatchProto2 = {
    ...Structural.prototype,
    [HashSetPatchTypeId]: {
      _Value: variance2,
      _Key: variance2,
      _Patch: variance2
    }
  };
  var EmptyProto2 = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(PatchProto2), {
    _tag: "Empty"
  });
  var _empty6 = /* @__PURE__ */ Object.create(EmptyProto2);
  var empty11 = () => _empty6;
  var AndThenProto2 = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(PatchProto2), {
    _tag: "AndThen"
  });
  var makeAndThen2 = (first2, second) => {
    const o = Object.create(AndThenProto2);
    o.first = first2;
    o.second = second;
    return o;
  };
  var AddProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(PatchProto2), {
    _tag: "Add"
  });
  var makeAdd = (value) => {
    const o = Object.create(AddProto);
    o.value = value;
    return o;
  };
  var RemoveProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(PatchProto2), {
    _tag: "Remove"
  });
  var makeRemove = (value) => {
    const o = Object.create(RemoveProto);
    o.value = value;
    return o;
  };
  var diff2 = (oldValue, newValue) => {
    const [removed, patch9] = reduce4([oldValue, empty11()], ([set6, patch10], value) => {
      if (has3(value)(set6)) {
        return [remove4(value)(set6), patch10];
      }
      return [set6, combine5(makeAdd(value))(patch10)];
    })(newValue);
    return reduce4(patch9, (patch10, value) => combine5(makeRemove(value))(patch10))(removed);
  };
  var combine5 = /* @__PURE__ */ dual(2, (self, that) => makeAndThen2(self, that));
  var patch2 = /* @__PURE__ */ dual(2, (self, oldValue) => {
    if (self._tag === "Empty") {
      return oldValue;
    }
    let set6 = oldValue;
    let patches = of2(self);
    while (isNonEmpty(patches)) {
      const head5 = headNonEmpty2(patches);
      const tail = tailNonEmpty2(patches);
      switch (head5._tag) {
        case "Empty": {
          patches = tail;
          break;
        }
        case "AndThen": {
          patches = prepend2(head5.first)(prepend2(head5.second)(tail));
          break;
        }
        case "Add": {
          set6 = add4(head5.value)(set6);
          patches = tail;
          break;
        }
        case "Remove": {
          set6 = remove4(head5.value)(set6);
          patches = tail;
        }
      }
    }
    return set6;
  });

  // <eztb>/node_modules/effect/dist/esm/internal/differ/readonlyArrayPatch.js
  var ReadonlyArrayPatchTypeId = /* @__PURE__ */ Symbol.for("effect/DifferReadonlyArrayPatch");
  function variance3(a) {
    return a;
  }
  var PatchProto3 = {
    ...Structural.prototype,
    [ReadonlyArrayPatchTypeId]: {
      _Value: variance3,
      _Patch: variance3
    }
  };
  var EmptyProto3 = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(PatchProto3), {
    _tag: "Empty"
  });
  var _empty7 = /* @__PURE__ */ Object.create(EmptyProto3);
  var empty12 = () => _empty7;
  var AndThenProto3 = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(PatchProto3), {
    _tag: "AndThen"
  });
  var makeAndThen3 = (first2, second) => {
    const o = Object.create(AndThenProto3);
    o.first = first2;
    o.second = second;
    return o;
  };
  var AppendProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(PatchProto3), {
    _tag: "Append"
  });
  var makeAppend = (values3) => {
    const o = Object.create(AppendProto);
    o.values = values3;
    return o;
  };
  var SliceProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(PatchProto3), {
    _tag: "Slice"
  });
  var makeSlice = (from, until) => {
    const o = Object.create(SliceProto);
    o.from = from;
    o.until = until;
    return o;
  };
  var UpdateProto = /* @__PURE__ */ Object.assign(/* @__PURE__ */ Object.create(PatchProto3), {
    _tag: "Update"
  });
  var makeUpdate = (index, patch9) => {
    const o = Object.create(UpdateProto);
    o.index = index;
    o.patch = patch9;
    return o;
  };
  var diff3 = (options) => {
    let i = 0;
    let patch9 = empty12();
    while (i < options.oldValue.length && i < options.newValue.length) {
      const oldElement = options.oldValue[i];
      const newElement = options.newValue[i];
      const valuePatch = options.differ.diff(oldElement, newElement);
      if (!equals(valuePatch, options.differ.empty)) {
        patch9 = combine6(patch9, makeUpdate(i, valuePatch));
      }
      i = i + 1;
    }
    if (i < options.oldValue.length) {
      patch9 = combine6(patch9, makeSlice(0, i));
    }
    if (i < options.newValue.length) {
      patch9 = combine6(patch9, makeAppend(drop(i)(options.newValue)));
    }
    return patch9;
  };
  var combine6 = /* @__PURE__ */ dual(2, (self, that) => makeAndThen3(self, that));
  var patch3 = /* @__PURE__ */ dual(3, (self, oldValue, differ3) => {
    if (self._tag === "Empty") {
      return oldValue;
    }
    let readonlyArray2 = oldValue.slice();
    let patches = of(self);
    while (isNonEmptyArray2(patches)) {
      const head5 = headNonEmpty(patches);
      const tail = tailNonEmpty(patches);
      switch (head5._tag) {
        case "Empty": {
          patches = tail;
          break;
        }
        case "AndThen": {
          tail.unshift(head5.first, head5.second);
          patches = tail;
          break;
        }
        case "Append": {
          for (const value of head5.values) {
            readonlyArray2.push(value);
          }
          patches = tail;
          break;
        }
        case "Slice": {
          readonlyArray2 = readonlyArray2.slice(head5.from, head5.until);
          patches = tail;
          break;
        }
        case "Update": {
          readonlyArray2[head5.index] = differ3.patch(head5.patch, readonlyArray2[head5.index]);
          patches = tail;
          break;
        }
      }
    }
    return readonlyArray2;
  });

  // <eztb>/node_modules/effect/dist/esm/internal/differ.js
  var DifferTypeId = /* @__PURE__ */ Symbol.for("effect/Differ");
  var DifferProto = {
    [DifferTypeId]: {
      _P: identity,
      _V: identity
    },
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var make14 = (params) => {
    const differ3 = Object.create(DifferProto);
    differ3.empty = params.empty;
    differ3.diff = params.diff;
    differ3.combine = params.combine;
    differ3.patch = params.patch;
    return differ3;
  };
  var environment = () => make14({
    empty: empty10(),
    combine: (first2, second) => combine4(second)(first2),
    diff: (oldValue, newValue) => diff(oldValue, newValue),
    patch: (patch9, oldValue) => patch(oldValue)(patch9)
  });
  var hashSet = () => make14({
    empty: empty11(),
    combine: (first2, second) => combine5(second)(first2),
    diff: (oldValue, newValue) => diff2(oldValue, newValue),
    patch: (patch9, oldValue) => patch2(oldValue)(patch9)
  });
  var readonlyArray = (differ3) => make14({
    empty: empty12(),
    combine: (first2, second) => combine6(first2, second),
    diff: (oldValue, newValue) => diff3({
      oldValue,
      newValue,
      differ: differ3
    }),
    patch: (patch9, oldValue) => patch3(patch9, oldValue, differ3)
  });
  var update = () => updateWith((_, a) => a);
  var updateWith = (f) => make14({
    empty: identity,
    combine: (first2, second) => {
      if (first2 === identity) {
        return second;
      }
      if (second === identity) {
        return first2;
      }
      return (a) => second(first2(a));
    },
    diff: (oldValue, newValue) => {
      if (equals(oldValue, newValue)) {
        return identity;
      }
      return constant(newValue);
    },
    patch: (patch9, oldValue) => f(oldValue, patch9(oldValue))
  });

  // <eztb>/node_modules/effect/dist/esm/internal/runtimeFlagsPatch.js
  var BIT_MASK = 255;
  var BIT_SHIFT = 8;
  var active = (patch9) => patch9 & BIT_MASK;
  var enabled = (patch9) => patch9 >> BIT_SHIFT & BIT_MASK;
  var make15 = (active2, enabled2) => (active2 & BIT_MASK) + ((enabled2 & active2 & BIT_MASK) << BIT_SHIFT);
  var empty13 = /* @__PURE__ */ make15(0, 0);
  var enable = (flag) => make15(flag, flag);
  var disable = (flag) => make15(flag, 0);
  var exclude = /* @__PURE__ */ dual(2, (self, flag) => make15(active(self) & ~flag, enabled(self)));
  var andThen2 = /* @__PURE__ */ dual(2, (self, that) => self | that);
  var invert = (n) => ~n >>> 0 & BIT_MASK;

  // <eztb>/node_modules/effect/dist/esm/internal/runtimeFlags.js
  var None2 = 0;
  var Interruption = 1 << 0;
  var OpSupervision = 1 << 1;
  var RuntimeMetrics = 1 << 2;
  var WindDown = 1 << 4;
  var CooperativeYielding = 1 << 5;
  var cooperativeYielding = (self) => isEnabled(self, CooperativeYielding);
  var disable2 = /* @__PURE__ */ dual(2, (self, flag) => self & ~flag);
  var enable2 = /* @__PURE__ */ dual(2, (self, flag) => self | flag);
  var interruptible = (self) => interruption(self) && !windDown(self);
  var interruption = (self) => isEnabled(self, Interruption);
  var isEnabled = /* @__PURE__ */ dual(2, (self, flag) => (self & flag) !== 0);
  var make16 = (...flags) => flags.reduce((a, b) => a | b, 0);
  var none5 = /* @__PURE__ */ make16(None2);
  var runtimeMetrics = (self) => isEnabled(self, RuntimeMetrics);
  var windDown = (self) => isEnabled(self, WindDown);
  var diff4 = /* @__PURE__ */ dual(2, (self, that) => make15(self ^ that, that));
  var patch4 = /* @__PURE__ */ dual(2, (self, patch9) => self & (invert(active(patch9)) | enabled(patch9)) | active(patch9) & enabled(patch9));
  var differ = /* @__PURE__ */ make14({
    empty: empty13,
    diff: (oldValue, newValue) => diff4(oldValue, newValue),
    combine: (first2, second) => andThen2(second)(first2),
    patch: (_patch, oldValue) => patch4(oldValue, _patch)
  });

  // <eztb>/node_modules/effect/dist/esm/RuntimeFlagsPatch.js
  var empty14 = empty13;
  var enable3 = enable;
  var disable3 = disable;
  var exclude2 = exclude;

  // <eztb>/node_modules/effect/dist/esm/internal/blockedRequests.js
  var empty15 = {
    _tag: "Empty"
  };
  var par = (self, that) => ({
    _tag: "Par",
    left: self,
    right: that
  });
  var seq = (self, that) => ({
    _tag: "Seq",
    left: self,
    right: that
  });
  var single = (dataSource, blockedRequest) => ({
    _tag: "Single",
    dataSource,
    blockedRequest
  });
  var flatten2 = (self) => {
    let current = of3(self);
    let updated = empty9();
    while (1) {
      const [parallel4, sequential4] = reduce6(current, [parallelCollectionEmpty(), empty9()], ([parallel5, sequential5], blockedRequest) => {
        const [par2, seq2] = step(blockedRequest);
        return [parallelCollectionCombine(parallel5, par2), appendAll3(sequential5, seq2)];
      });
      updated = merge4(updated, parallel4);
      if (isNil(sequential4)) {
        return reverse3(updated);
      }
      current = sequential4;
    }
    throw new Error("BUG: BlockedRequests.flatten - please report an issue at https://github.com/Effect-TS/effect/issues");
  };
  var step = (requests) => {
    let current = requests;
    let parallel4 = parallelCollectionEmpty();
    let stack = empty9();
    let sequential4 = empty9();
    while (1) {
      switch (current._tag) {
        case "Empty": {
          if (isNil(stack)) {
            return [parallel4, sequential4];
          }
          current = stack.head;
          stack = stack.tail;
          break;
        }
        case "Par": {
          stack = cons(current.right, stack);
          current = current.left;
          break;
        }
        case "Seq": {
          const left3 = current.left;
          const right3 = current.right;
          switch (left3._tag) {
            case "Empty": {
              current = right3;
              break;
            }
            case "Par": {
              const l = left3.left;
              const r = left3.right;
              current = par(seq(l, right3), seq(r, right3));
              break;
            }
            case "Seq": {
              const l = left3.left;
              const r = left3.right;
              current = seq(l, seq(r, right3));
              break;
            }
            case "Single": {
              current = left3;
              sequential4 = cons(right3, sequential4);
              break;
            }
          }
          break;
        }
        case "Single": {
          parallel4 = parallelCollectionAdd(parallel4, current);
          if (isNil(stack)) {
            return [parallel4, sequential4];
          }
          current = stack.head;
          stack = stack.tail;
          break;
        }
      }
    }
    throw new Error("BUG: BlockedRequests.step - please report an issue at https://github.com/Effect-TS/effect/issues");
  };
  var merge4 = (sequential4, parallel4) => {
    if (isNil(sequential4)) {
      return of3(parallelCollectionToSequentialCollection(parallel4));
    }
    if (parallelCollectionIsEmpty(parallel4)) {
      return sequential4;
    }
    const seqHeadKeys = sequentialCollectionKeys(sequential4.head);
    const parKeys = parallelCollectionKeys(parallel4);
    if (seqHeadKeys.length === 1 && parKeys.length === 1 && equals(seqHeadKeys[0], parKeys[0])) {
      return cons(sequentialCollectionCombine(sequential4.head, parallelCollectionToSequentialCollection(parallel4)), sequential4.tail);
    }
    return cons(parallelCollectionToSequentialCollection(parallel4), sequential4);
  };
  var EntryTypeId = /* @__PURE__ */ Symbol.for("effect/RequestBlock/Entry");
  var _a5;
  _a5 = EntryTypeId;
  var EntryImpl = class {
    constructor(request3, result, listeners, ownerId, state) {
      __publicField(this, "request");
      __publicField(this, "result");
      __publicField(this, "listeners");
      __publicField(this, "ownerId");
      __publicField(this, "state");
      __publicField(this, _a5, blockedRequestVariance);
      this.request = request3;
      this.result = result;
      this.listeners = listeners;
      this.ownerId = ownerId;
      this.state = state;
    }
  };
  var blockedRequestVariance = {
    /* c8 ignore next */
    _R: (_) => _
  };
  var makeEntry = (options) => new EntryImpl(options.request, options.result, options.listeners, options.ownerId, options.state);
  var RequestBlockParallelTypeId = /* @__PURE__ */ Symbol.for("effect/RequestBlock/RequestBlockParallel");
  var parallelVariance = {
    /* c8 ignore next */
    _R: (_) => _
  };
  var _a6;
  _a6 = RequestBlockParallelTypeId;
  var ParallelImpl = class {
    constructor(map14) {
      __publicField(this, "map");
      __publicField(this, _a6, parallelVariance);
      this.map = map14;
    }
  };
  var parallelCollectionEmpty = () => new ParallelImpl(empty8());
  var parallelCollectionAdd = (self, blockedRequest) => new ParallelImpl(modifyAt2(self.map, blockedRequest.dataSource, (_) => orElseSome(map2(_, append2(blockedRequest.blockedRequest)), () => of2(blockedRequest.blockedRequest))));
  var parallelCollectionCombine = (self, that) => new ParallelImpl(reduce5(self.map, that.map, (map14, value, key) => set3(map14, key, match2(get7(map14, key), {
    onNone: () => value,
    onSome: (other) => appendAll2(value, other)
  }))));
  var parallelCollectionIsEmpty = (self) => isEmpty3(self.map);
  var parallelCollectionKeys = (self) => Array.from(keys2(self.map));
  var parallelCollectionToSequentialCollection = (self) => sequentialCollectionMake(map6(self.map, (x) => of2(x)));
  var SequentialCollectionTypeId = /* @__PURE__ */ Symbol.for("effect/RequestBlock/RequestBlockSequential");
  var sequentialVariance = {
    /* c8 ignore next */
    _R: (_) => _
  };
  var _a7;
  _a7 = SequentialCollectionTypeId;
  var SequentialImpl = class {
    constructor(map14) {
      __publicField(this, "map");
      __publicField(this, _a7, sequentialVariance);
      this.map = map14;
    }
  };
  var sequentialCollectionMake = (map14) => new SequentialImpl(map14);
  var sequentialCollectionCombine = (self, that) => new SequentialImpl(reduce5(that.map, self.map, (map14, value, key) => set3(map14, key, match2(get7(map14, key), {
    onNone: () => empty4(),
    onSome: (a) => appendAll2(a, value)
  }))));
  var sequentialCollectionKeys = (self) => Array.from(keys2(self.map));
  var sequentialCollectionToChunk = (self) => Array.from(self.map);

  // <eztb>/node_modules/effect/dist/esm/internal/opCodes/cause.js
  var OP_DIE = "Die";
  var OP_EMPTY = "Empty";
  var OP_FAIL = "Fail";
  var OP_INTERRUPT = "Interrupt";
  var OP_PARALLEL = "Parallel";
  var OP_SEQUENTIAL = "Sequential";

  // <eztb>/node_modules/effect/dist/esm/internal/cause.js
  var CauseSymbolKey = "effect/Cause";
  var CauseTypeId = /* @__PURE__ */ Symbol.for(CauseSymbolKey);
  var variance4 = {
    /* c8 ignore next */
    _E: (_) => _
  };
  var proto = {
    [CauseTypeId]: variance4,
    [symbol]() {
      return pipe(hash(CauseSymbolKey), combine(hash(flattenCause(this))), cached(this));
    },
    [symbol2](that) {
      return isCause(that) && causeEquals(this, that);
    },
    pipe() {
      return pipeArguments(this, arguments);
    },
    toJSON() {
      switch (this._tag) {
        case "Empty":
          return {
            _id: "Cause",
            _tag: this._tag
          };
        case "Die":
          return {
            _id: "Cause",
            _tag: this._tag,
            defect: toJSON(this.defect)
          };
        case "Interrupt":
          return {
            _id: "Cause",
            _tag: this._tag,
            fiberId: this.fiberId.toJSON()
          };
        case "Fail":
          return {
            _id: "Cause",
            _tag: this._tag,
            failure: toJSON(this.error)
          };
        case "Sequential":
        case "Parallel":
          return {
            _id: "Cause",
            _tag: this._tag,
            left: toJSON(this.left),
            right: toJSON(this.right)
          };
      }
    },
    toString() {
      return pretty(this);
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    }
  };
  var empty16 = /* @__PURE__ */ (() => {
    const o = /* @__PURE__ */ Object.create(proto);
    o._tag = OP_EMPTY;
    return o;
  })();
  var fail = (error) => {
    const o = Object.create(proto);
    o._tag = OP_FAIL;
    o.error = error;
    return o;
  };
  var die = (defect) => {
    const o = Object.create(proto);
    o._tag = OP_DIE;
    o.defect = defect;
    return o;
  };
  var interrupt = (fiberId3) => {
    const o = Object.create(proto);
    o._tag = OP_INTERRUPT;
    o.fiberId = fiberId3;
    return o;
  };
  var parallel = (left3, right3) => {
    const o = Object.create(proto);
    o._tag = OP_PARALLEL;
    o.left = left3;
    o.right = right3;
    return o;
  };
  var sequential = (left3, right3) => {
    const o = Object.create(proto);
    o._tag = OP_SEQUENTIAL;
    o.left = left3;
    o.right = right3;
    return o;
  };
  var isCause = (u) => hasProperty(u, CauseTypeId);
  var isEmptyType = (self) => self._tag === OP_EMPTY;
  var isDieType = (self) => self._tag === OP_DIE;
  var isEmpty5 = (self) => {
    if (self._tag === OP_EMPTY) {
      return true;
    }
    return reduce7(self, true, (acc, cause3) => {
      switch (cause3._tag) {
        case OP_EMPTY: {
          return some2(acc);
        }
        case OP_DIE:
        case OP_FAIL:
        case OP_INTERRUPT: {
          return some2(false);
        }
        default: {
          return none2();
        }
      }
    });
  };
  var isInterrupted = (self) => isSome2(interruptOption(self));
  var isInterruptedOnly = (self) => reduceWithContext(void 0, IsInterruptedOnlyCauseReducer)(self);
  var failures = (self) => reverse2(reduce7(self, empty4(), (list, cause3) => cause3._tag === OP_FAIL ? some2(pipe(list, prepend2(cause3.error))) : none2()));
  var defects = (self) => reverse2(reduce7(self, empty4(), (list, cause3) => cause3._tag === OP_DIE ? some2(pipe(list, prepend2(cause3.defect))) : none2()));
  var interruptors = (self) => reduce7(self, empty7(), (set6, cause3) => cause3._tag === OP_INTERRUPT ? some2(pipe(set6, add4(cause3.fiberId))) : none2());
  var failureOption = (self) => find(self, (cause3) => cause3._tag === OP_FAIL ? some2(cause3.error) : none2());
  var failureOrCause = (self) => {
    const option3 = failureOption(self);
    switch (option3._tag) {
      case "None": {
        return right2(self);
      }
      case "Some": {
        return left2(option3.value);
      }
    }
  };
  var interruptOption = (self) => find(self, (cause3) => cause3._tag === OP_INTERRUPT ? some2(cause3.fiberId) : none2());
  var keepDefects = (self) => match4(self, {
    onEmpty: none2(),
    onFail: () => none2(),
    onDie: (defect) => some2(die(defect)),
    onInterrupt: () => none2(),
    onSequential: mergeWith(sequential),
    onParallel: mergeWith(parallel)
  });
  var keepDefectsAndElectFailures = (self) => match4(self, {
    onEmpty: none2(),
    onFail: (failure) => some2(die(failure)),
    onDie: (defect) => some2(die(defect)),
    onInterrupt: () => none2(),
    onSequential: mergeWith(sequential),
    onParallel: mergeWith(parallel)
  });
  var stripFailures = (self) => match4(self, {
    onEmpty: empty16,
    onFail: () => empty16,
    onDie: die,
    onInterrupt: interrupt,
    onSequential: sequential,
    onParallel: parallel
  });
  var electFailures = (self) => match4(self, {
    onEmpty: empty16,
    onFail: die,
    onDie: die,
    onInterrupt: interrupt,
    onSequential: sequential,
    onParallel: parallel
  });
  var flatMap7 = /* @__PURE__ */ dual(2, (self, f) => match4(self, {
    onEmpty: empty16,
    onFail: (error) => f(error),
    onDie: (defect) => die(defect),
    onInterrupt: (fiberId3) => interrupt(fiberId3),
    onSequential: (left3, right3) => sequential(left3, right3),
    onParallel: (left3, right3) => parallel(left3, right3)
  }));
  var flatten3 = (self) => flatMap7(self, identity);
  var causeEquals = (left3, right3) => {
    let leftStack = of2(left3);
    let rightStack = of2(right3);
    while (isNonEmpty(leftStack) && isNonEmpty(rightStack)) {
      const [leftParallel, leftSequential] = pipe(headNonEmpty2(leftStack), reduce7([empty7(), empty4()], ([parallel4, sequential4], cause3) => {
        const [par2, seq2] = evaluateCause(cause3);
        return some2([pipe(parallel4, union3(par2)), pipe(sequential4, appendAll2(seq2))]);
      }));
      const [rightParallel, rightSequential] = pipe(headNonEmpty2(rightStack), reduce7([empty7(), empty4()], ([parallel4, sequential4], cause3) => {
        const [par2, seq2] = evaluateCause(cause3);
        return some2([pipe(parallel4, union3(par2)), pipe(sequential4, appendAll2(seq2))]);
      }));
      if (!equals(leftParallel, rightParallel)) {
        return false;
      }
      leftStack = leftSequential;
      rightStack = rightSequential;
    }
    return true;
  };
  var flattenCause = (cause3) => {
    return flattenCauseLoop(of2(cause3), empty4());
  };
  var flattenCauseLoop = (causes, flattened) => {
    while (1) {
      const [parallel4, sequential4] = pipe(causes, reduce([empty7(), empty4()], ([parallel5, sequential5], cause3) => {
        const [par2, seq2] = evaluateCause(cause3);
        return [pipe(parallel5, union3(par2)), pipe(sequential5, appendAll2(seq2))];
      }));
      const updated = size3(parallel4) > 0 ? pipe(flattened, prepend2(parallel4)) : flattened;
      if (isEmpty(sequential4)) {
        return reverse2(updated);
      }
      causes = sequential4;
      flattened = updated;
    }
    throw new Error(getBugErrorMessage("Cause.flattenCauseLoop"));
  };
  var find = /* @__PURE__ */ dual(2, (self, pf) => {
    const stack = [self];
    while (stack.length > 0) {
      const item = stack.pop();
      const option3 = pf(item);
      switch (option3._tag) {
        case "None": {
          switch (item._tag) {
            case OP_SEQUENTIAL:
            case OP_PARALLEL: {
              stack.push(item.right);
              stack.push(item.left);
              break;
            }
          }
          break;
        }
        case "Some": {
          return option3;
        }
      }
    }
    return none2();
  });
  var evaluateCause = (self) => {
    let cause3 = self;
    const stack = [];
    let _parallel = empty7();
    let _sequential = empty4();
    while (cause3 !== void 0) {
      switch (cause3._tag) {
        case OP_EMPTY: {
          if (stack.length === 0) {
            return [_parallel, _sequential];
          }
          cause3 = stack.pop();
          break;
        }
        case OP_FAIL: {
          _parallel = add4(_parallel, make6(cause3._tag, cause3.error));
          if (stack.length === 0) {
            return [_parallel, _sequential];
          }
          cause3 = stack.pop();
          break;
        }
        case OP_DIE: {
          _parallel = add4(_parallel, make6(cause3._tag, cause3.defect));
          if (stack.length === 0) {
            return [_parallel, _sequential];
          }
          cause3 = stack.pop();
          break;
        }
        case OP_INTERRUPT: {
          _parallel = add4(_parallel, make6(cause3._tag, cause3.fiberId));
          if (stack.length === 0) {
            return [_parallel, _sequential];
          }
          cause3 = stack.pop();
          break;
        }
        case OP_SEQUENTIAL: {
          switch (cause3.left._tag) {
            case OP_EMPTY: {
              cause3 = cause3.right;
              break;
            }
            case OP_SEQUENTIAL: {
              cause3 = sequential(cause3.left.left, sequential(cause3.left.right, cause3.right));
              break;
            }
            case OP_PARALLEL: {
              cause3 = parallel(sequential(cause3.left.left, cause3.right), sequential(cause3.left.right, cause3.right));
              break;
            }
            default: {
              _sequential = prepend2(_sequential, cause3.right);
              cause3 = cause3.left;
              break;
            }
          }
          break;
        }
        case OP_PARALLEL: {
          stack.push(cause3.right);
          cause3 = cause3.left;
          break;
        }
      }
    }
    throw new Error(getBugErrorMessage("Cause.evaluateCauseLoop"));
  };
  var IsInterruptedOnlyCauseReducer = {
    emptyCase: constTrue,
    failCase: constFalse,
    dieCase: constFalse,
    interruptCase: constTrue,
    sequentialCase: (_, left3, right3) => left3 && right3,
    parallelCase: (_, left3, right3) => left3 && right3
  };
  var OP_SEQUENTIAL_CASE = "SequentialCase";
  var OP_PARALLEL_CASE = "ParallelCase";
  var match4 = /* @__PURE__ */ dual(2, (self, {
    onDie,
    onEmpty,
    onFail,
    onInterrupt: onInterrupt3,
    onParallel,
    onSequential
  }) => {
    return reduceWithContext(self, void 0, {
      emptyCase: () => onEmpty,
      failCase: (_, error) => onFail(error),
      dieCase: (_, defect) => onDie(defect),
      interruptCase: (_, fiberId3) => onInterrupt3(fiberId3),
      sequentialCase: (_, left3, right3) => onSequential(left3, right3),
      parallelCase: (_, left3, right3) => onParallel(left3, right3)
    });
  });
  var reduce7 = /* @__PURE__ */ dual(3, (self, zero2, pf) => {
    let accumulator = zero2;
    let cause3 = self;
    const causes = [];
    while (cause3 !== void 0) {
      const option3 = pf(accumulator, cause3);
      accumulator = isSome2(option3) ? option3.value : accumulator;
      switch (cause3._tag) {
        case OP_SEQUENTIAL: {
          causes.push(cause3.right);
          cause3 = cause3.left;
          break;
        }
        case OP_PARALLEL: {
          causes.push(cause3.right);
          cause3 = cause3.left;
          break;
        }
        default: {
          cause3 = void 0;
          break;
        }
      }
      if (cause3 === void 0 && causes.length > 0) {
        cause3 = causes.pop();
      }
    }
    return accumulator;
  });
  var reduceWithContext = /* @__PURE__ */ dual(3, (self, context4, reducer) => {
    const input = [self];
    const output = [];
    while (input.length > 0) {
      const cause3 = input.pop();
      switch (cause3._tag) {
        case OP_EMPTY: {
          output.push(right2(reducer.emptyCase(context4)));
          break;
        }
        case OP_FAIL: {
          output.push(right2(reducer.failCase(context4, cause3.error)));
          break;
        }
        case OP_DIE: {
          output.push(right2(reducer.dieCase(context4, cause3.defect)));
          break;
        }
        case OP_INTERRUPT: {
          output.push(right2(reducer.interruptCase(context4, cause3.fiberId)));
          break;
        }
        case OP_SEQUENTIAL: {
          input.push(cause3.right);
          input.push(cause3.left);
          output.push(left2({
            _tag: OP_SEQUENTIAL_CASE
          }));
          break;
        }
        case OP_PARALLEL: {
          input.push(cause3.right);
          input.push(cause3.left);
          output.push(left2({
            _tag: OP_PARALLEL_CASE
          }));
          break;
        }
      }
    }
    const accumulator = [];
    while (output.length > 0) {
      const either6 = output.pop();
      switch (either6._tag) {
        case "Left": {
          switch (either6.left._tag) {
            case OP_SEQUENTIAL_CASE: {
              const left3 = accumulator.pop();
              const right3 = accumulator.pop();
              const value = reducer.sequentialCase(context4, left3, right3);
              accumulator.push(value);
              break;
            }
            case OP_PARALLEL_CASE: {
              const left3 = accumulator.pop();
              const right3 = accumulator.pop();
              const value = reducer.parallelCase(context4, left3, right3);
              accumulator.push(value);
              break;
            }
          }
          break;
        }
        case "Right": {
          accumulator.push(either6.right);
          break;
        }
      }
    }
    if (accumulator.length === 0) {
      throw new Error("BUG: Cause.reduceWithContext - please report an issue at https://github.com/Effect-TS/effect/issues");
    }
    return accumulator.pop();
  });
  var pretty = (cause3, options) => {
    if (isInterruptedOnly(cause3)) {
      return "All fibers interrupted without errors.";
    }
    return prettyErrors(cause3).map(function(e) {
      if (options?.renderErrorCause !== true || e.cause === void 0) {
        return e.stack;
      }
      return `${e.stack} {
${renderErrorCause(e.cause, "  ")}
}`;
    }).join("\n");
  };
  var renderErrorCause = (cause3, prefix) => {
    const lines = cause3.stack.split("\n");
    let stack = `${prefix}[cause]: ${lines[0]}`;
    for (let i = 1, len = lines.length; i < len; i++) {
      stack += `
${prefix}${lines[i]}`;
    }
    if (cause3.cause) {
      stack += ` {
${renderErrorCause(cause3.cause, `${prefix}  `)}
${prefix}}`;
    }
    return stack;
  };
  var PrettyError = class _PrettyError extends globalThis.Error {
    constructor(originalError) {
      const originalErrorIsObject = typeof originalError === "object" && originalError !== null;
      const prevLimit = Error.stackTraceLimit;
      Error.stackTraceLimit = 1;
      super(prettyErrorMessage(originalError), originalErrorIsObject && "cause" in originalError && typeof originalError.cause !== "undefined" ? {
        cause: new _PrettyError(originalError.cause)
      } : void 0);
      __publicField(this, "span");
      if (this.message === "") {
        this.message = "An error has occurred";
      }
      Error.stackTraceLimit = prevLimit;
      this.name = originalError instanceof Error ? originalError.name : "Error";
      if (originalErrorIsObject) {
        if (spanSymbol in originalError) {
          this.span = originalError[spanSymbol];
        }
        Object.keys(originalError).forEach((key) => {
          if (!(key in this)) {
            this[key] = originalError[key];
          }
        });
      }
      this.stack = prettyErrorStack(`${this.name}: ${this.message}`, originalError instanceof Error && originalError.stack ? originalError.stack : "", this.span);
    }
  };
  var prettyErrorMessage = (u) => {
    if (typeof u === "string") {
      return u;
    }
    if (typeof u === "object" && u !== null && u instanceof Error) {
      return u.message;
    }
    try {
      if (hasProperty(u, "toString") && isFunction2(u["toString"]) && u["toString"] !== Object.prototype.toString && u["toString"] !== globalThis.Array.prototype.toString) {
        return u["toString"]();
      }
    } catch {
    }
    return stringifyCircular(u);
  };
  var locationRegex = /\((.*)\)/g;
  var spanToTrace = /* @__PURE__ */ globalValue("effect/Tracer/spanToTrace", () => /* @__PURE__ */ new WeakMap());
  var prettyErrorStack = (message, stack, span2) => {
    const out = [message];
    const lines = stack.startsWith(message) ? stack.slice(message.length).split("\n") : stack.split("\n");
    for (let i = 1; i < lines.length; i++) {
      if (lines[i].includes(" at new BaseEffectError") || lines[i].includes(" at new YieldableError")) {
        i++;
        continue;
      }
      if (lines[i].includes("Generator.next")) {
        break;
      }
      if (lines[i].includes("effect_internal_function")) {
        break;
      }
      out.push(lines[i].replace(/at .*effect_instruction_i.*\((.*)\)/, "at $1").replace(/EffectPrimitive\.\w+/, "<anonymous>"));
    }
    if (span2) {
      let current = span2;
      let i = 0;
      while (current && current._tag === "Span" && i < 10) {
        const stackFn = spanToTrace.get(current);
        if (typeof stackFn === "function") {
          const stack2 = stackFn();
          if (typeof stack2 === "string") {
            const locationMatchAll = stack2.matchAll(locationRegex);
            let match11 = false;
            for (const [, location2] of locationMatchAll) {
              match11 = true;
              out.push(`    at ${current.name} (${location2})`);
            }
            if (!match11) {
              out.push(`    at ${current.name} (${stack2.replace(/^at /, "")})`);
            }
          } else {
            out.push(`    at ${current.name}`);
          }
        } else {
          out.push(`    at ${current.name}`);
        }
        current = getOrUndefined2(current.parent);
        i++;
      }
    }
    return out.join("\n");
  };
  var spanSymbol = /* @__PURE__ */ Symbol.for("effect/SpanAnnotation");
  var prettyErrors = (cause3) => reduceWithContext(cause3, void 0, {
    emptyCase: () => [],
    dieCase: (_, unknownError) => {
      return [new PrettyError(unknownError)];
    },
    failCase: (_, error) => {
      return [new PrettyError(error)];
    },
    interruptCase: () => [],
    parallelCase: (_, l, r) => [...l, ...r],
    sequentialCase: (_, l, r) => [...l, ...r]
  });

  // <eztb>/node_modules/effect/dist/esm/internal/opCodes/deferred.js
  var OP_STATE_PENDING = "Pending";
  var OP_STATE_DONE = "Done";

  // <eztb>/node_modules/effect/dist/esm/internal/deferred.js
  var DeferredSymbolKey = "effect/Deferred";
  var DeferredTypeId = /* @__PURE__ */ Symbol.for(DeferredSymbolKey);
  var deferredVariance = {
    /* c8 ignore next */
    _E: (_) => _,
    /* c8 ignore next */
    _A: (_) => _
  };
  var pending = (joiners) => {
    return {
      _tag: OP_STATE_PENDING,
      joiners
    };
  };
  var done = (effect) => {
    return {
      _tag: OP_STATE_DONE,
      effect
    };
  };

  // <eztb>/node_modules/effect/dist/esm/internal/singleShotGen.js
  var SingleShotGen2 = class _SingleShotGen {
    constructor(self) {
      __publicField(this, "self");
      __publicField(this, "called", false);
      this.self = self;
    }
    next(a) {
      return this.called ? {
        value: a,
        done: true
      } : (this.called = true, {
        value: this.self,
        done: false
      });
    }
    return(a) {
      return {
        value: a,
        done: true
      };
    }
    throw(e) {
      throw e;
    }
    [Symbol.iterator]() {
      return new _SingleShotGen(this.self);
    }
  };

  // <eztb>/node_modules/effect/dist/esm/internal/core.js
  var blocked = (blockedRequests, _continue3) => {
    const effect = new EffectPrimitive("Blocked");
    effect.effect_instruction_i0 = blockedRequests;
    effect.effect_instruction_i1 = _continue3;
    return effect;
  };
  var runRequestBlock = (blockedRequests) => {
    const effect = new EffectPrimitive("RunBlocked");
    effect.effect_instruction_i0 = blockedRequests;
    return effect;
  };
  var EffectTypeId2 = /* @__PURE__ */ Symbol.for("effect/Effect");
  var RevertFlags = class {
    constructor(patch9, op) {
      __publicField(this, "patch");
      __publicField(this, "op");
      __publicField(this, "_op", OP_REVERT_FLAGS);
      this.patch = patch9;
      this.op = op;
    }
  };
  var _a8;
  var EffectPrimitive = class {
    constructor(_op) {
      __publicField(this, "_op");
      __publicField(this, "effect_instruction_i0");
      __publicField(this, "effect_instruction_i1");
      __publicField(this, "effect_instruction_i2");
      __publicField(this, "trace");
      __publicField(this, _a8, effectVariance);
      this._op = _op;
    }
    [(_a8 = EffectTypeId2, symbol2)](that) {
      return this === that;
    }
    [symbol]() {
      return cached(this, random(this));
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
    toJSON() {
      return {
        _id: "Effect",
        _op: this._op,
        effect_instruction_i0: toJSON(this.effect_instruction_i0),
        effect_instruction_i1: toJSON(this.effect_instruction_i1),
        effect_instruction_i2: toJSON(this.effect_instruction_i2)
      };
    }
    toString() {
      return format2(this.toJSON());
    }
    [NodeInspectSymbol]() {
      return this.toJSON();
    }
    [Symbol.iterator]() {
      return new SingleShotGen2(new YieldWrap(this));
    }
  };
  var _a9;
  var EffectPrimitiveFailure = class {
    constructor(_op) {
      __publicField(this, "_op");
      __publicField(this, "effect_instruction_i0");
      __publicField(this, "effect_instruction_i1");
      __publicField(this, "effect_instruction_i2");
      __publicField(this, "trace");
      __publicField(this, _a9, effectVariance);
      this._op = _op;
      this._tag = _op;
    }
    [(_a9 = EffectTypeId2, symbol2)](that) {
      return exitIsExit(that) && that._op === "Failure" && // @ts-expect-error
      equals(this.effect_instruction_i0, that.effect_instruction_i0);
    }
    [symbol]() {
      return pipe(
        // @ts-expect-error
        string(this._tag),
        // @ts-expect-error
        combine(hash(this.effect_instruction_i0)),
        cached(this)
      );
    }
    get cause() {
      return this.effect_instruction_i0;
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
    toJSON() {
      return {
        _id: "Exit",
        _tag: this._op,
        cause: this.cause.toJSON()
      };
    }
    toString() {
      return format2(this.toJSON());
    }
    [NodeInspectSymbol]() {
      return this.toJSON();
    }
    [Symbol.iterator]() {
      return new SingleShotGen2(new YieldWrap(this));
    }
  };
  var _a10;
  var EffectPrimitiveSuccess = class {
    constructor(_op) {
      __publicField(this, "_op");
      __publicField(this, "effect_instruction_i0");
      __publicField(this, "effect_instruction_i1");
      __publicField(this, "effect_instruction_i2");
      __publicField(this, "trace");
      __publicField(this, _a10, effectVariance);
      this._op = _op;
      this._tag = _op;
    }
    [(_a10 = EffectTypeId2, symbol2)](that) {
      return exitIsExit(that) && that._op === "Success" && // @ts-expect-error
      equals(this.effect_instruction_i0, that.effect_instruction_i0);
    }
    [symbol]() {
      return pipe(
        // @ts-expect-error
        string(this._tag),
        // @ts-expect-error
        combine(hash(this.effect_instruction_i0)),
        cached(this)
      );
    }
    get value() {
      return this.effect_instruction_i0;
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
    toJSON() {
      return {
        _id: "Exit",
        _tag: this._op,
        value: toJSON(this.value)
      };
    }
    toString() {
      return format2(this.toJSON());
    }
    [NodeInspectSymbol]() {
      return this.toJSON();
    }
    [Symbol.iterator]() {
      return new SingleShotGen2(new YieldWrap(this));
    }
  };
  var isEffect = (u) => hasProperty(u, EffectTypeId2);
  var withFiberRuntime = (withRuntime) => {
    const effect = new EffectPrimitive(OP_WITH_RUNTIME);
    effect.effect_instruction_i0 = withRuntime;
    return effect;
  };
  var acquireUseRelease = /* @__PURE__ */ dual(3, (acquire, use, release) => uninterruptibleMask((restore) => flatMap8(acquire, (a) => flatMap8(exit(suspend(() => restore(use(a)))), (exit4) => {
    return suspend(() => release(a, exit4)).pipe(matchCauseEffect({
      onFailure: (cause3) => {
        switch (exit4._tag) {
          case OP_FAILURE:
            return failCause(sequential(exit4.effect_instruction_i0, cause3));
          case OP_SUCCESS:
            return failCause(cause3);
        }
      },
      onSuccess: () => exit4
    }));
  }))));
  var as = /* @__PURE__ */ dual(2, (self, value) => flatMap8(self, () => succeed(value)));
  var asVoid = (self) => as(self, void 0);
  var custom = function() {
    const wrapper = new EffectPrimitive(OP_COMMIT);
    switch (arguments.length) {
      case 2: {
        wrapper.effect_instruction_i0 = arguments[0];
        wrapper.commit = arguments[1];
        break;
      }
      case 3: {
        wrapper.effect_instruction_i0 = arguments[0];
        wrapper.effect_instruction_i1 = arguments[1];
        wrapper.commit = arguments[2];
        break;
      }
      case 4: {
        wrapper.effect_instruction_i0 = arguments[0];
        wrapper.effect_instruction_i1 = arguments[1];
        wrapper.effect_instruction_i2 = arguments[2];
        wrapper.commit = arguments[3];
        break;
      }
      default: {
        throw new Error(getBugErrorMessage("you're not supposed to end up here"));
      }
    }
    return wrapper;
  };
  var unsafeAsync = (register, blockingOn = none4) => {
    const effect = new EffectPrimitive(OP_ASYNC);
    let cancelerRef = void 0;
    effect.effect_instruction_i0 = (resume2) => {
      cancelerRef = register(resume2);
    };
    effect.effect_instruction_i1 = blockingOn;
    return onInterrupt(effect, (_) => isEffect(cancelerRef) ? cancelerRef : void_2);
  };
  var asyncInterrupt = (register, blockingOn = none4) => suspend(() => unsafeAsync(register, blockingOn));
  var async_ = (resume2, blockingOn = none4) => {
    return custom(resume2, function() {
      let backingResume = void 0;
      let pendingEffect = void 0;
      function proxyResume(effect2) {
        if (backingResume) {
          backingResume(effect2);
        } else if (pendingEffect === void 0) {
          pendingEffect = effect2;
        }
      }
      const effect = new EffectPrimitive(OP_ASYNC);
      effect.effect_instruction_i0 = (resume3) => {
        backingResume = resume3;
        if (pendingEffect) {
          resume3(pendingEffect);
        }
      };
      effect.effect_instruction_i1 = blockingOn;
      let cancelerRef = void 0;
      let controllerRef = void 0;
      if (this.effect_instruction_i0.length !== 1) {
        controllerRef = new AbortController();
        cancelerRef = internalCall(() => this.effect_instruction_i0(proxyResume, controllerRef.signal));
      } else {
        cancelerRef = internalCall(() => this.effect_instruction_i0(proxyResume));
      }
      return cancelerRef || controllerRef ? onInterrupt(effect, (_) => {
        if (controllerRef) {
          controllerRef.abort();
        }
        return cancelerRef ?? void_2;
      }) : effect;
    });
  };
  var catchAllCause = /* @__PURE__ */ dual(2, (self, f) => {
    const effect = new EffectPrimitive(OP_ON_FAILURE);
    effect.effect_instruction_i0 = self;
    effect.effect_instruction_i1 = f;
    return effect;
  });
  var catchAll = /* @__PURE__ */ dual(2, (self, f) => matchEffect(self, {
    onFailure: f,
    onSuccess: succeed
  }));
  var catchIf = /* @__PURE__ */ dual(3, (self, predicate, f) => catchAllCause(self, (cause3) => {
    const either6 = failureOrCause(cause3);
    switch (either6._tag) {
      case "Left":
        return predicate(either6.left) ? f(either6.left) : failCause(cause3);
      case "Right":
        return failCause(either6.right);
    }
  }));
  var catchSome = /* @__PURE__ */ dual(2, (self, pf) => catchAllCause(self, (cause3) => {
    const either6 = failureOrCause(cause3);
    switch (either6._tag) {
      case "Left":
        return pipe(pf(either6.left), getOrElse2(() => failCause(cause3)));
      case "Right":
        return failCause(either6.right);
    }
  }));
  var checkInterruptible = (f) => withFiberRuntime((_, status) => f(interruption(status.runtimeFlags)));
  var originalSymbol = /* @__PURE__ */ Symbol.for("effect/OriginalAnnotation");
  var capture = (obj, span2) => {
    if (isSome2(span2)) {
      return new Proxy(obj, {
        has(target, p) {
          return p === spanSymbol || p === originalSymbol || p in target;
        },
        get(target, p) {
          if (p === spanSymbol) {
            return span2.value;
          }
          if (p === originalSymbol) {
            return obj;
          }
          return target[p];
        }
      });
    }
    return obj;
  };
  var die2 = (defect) => isObject(defect) && !(spanSymbol in defect) ? withFiberRuntime((fiber) => failCause(die(capture(defect, currentSpanFromFiber(fiber))))) : failCause(die(defect));
  var dieMessage = (message) => failCauseSync(() => die(new RuntimeException(message)));
  var dieSync = (evaluate2) => flatMap8(sync(evaluate2), die2);
  var either2 = (self) => matchEffect(self, {
    onFailure: (e) => succeed(left2(e)),
    onSuccess: (a) => succeed(right2(a))
  });
  var exit = (self) => matchCause(self, {
    onFailure: exitFailCause,
    onSuccess: exitSucceed
  });
  var fail2 = (error) => isObject(error) && !(spanSymbol in error) ? withFiberRuntime((fiber) => failCause(fail(capture(error, currentSpanFromFiber(fiber))))) : failCause(fail(error));
  var failSync = (evaluate2) => flatMap8(sync(evaluate2), fail2);
  var failCause = (cause3) => {
    const effect = new EffectPrimitiveFailure(OP_FAILURE);
    effect.effect_instruction_i0 = cause3;
    return effect;
  };
  var failCauseSync = (evaluate2) => flatMap8(sync(evaluate2), failCause);
  var fiberId = /* @__PURE__ */ withFiberRuntime((state) => succeed(state.id()));
  var fiberIdWith = (f) => withFiberRuntime((state) => f(state.id()));
  var flatMap8 = /* @__PURE__ */ dual(2, (self, f) => {
    const effect = new EffectPrimitive(OP_ON_SUCCESS);
    effect.effect_instruction_i0 = self;
    effect.effect_instruction_i1 = f;
    return effect;
  });
  var andThen3 = /* @__PURE__ */ dual(2, (self, f) => flatMap8(self, (a) => {
    const b = typeof f === "function" ? f(a) : f;
    if (isEffect(b)) {
      return b;
    } else if (isPromiseLike(b)) {
      return unsafeAsync((resume2) => {
        b.then((a2) => resume2(succeed(a2)), (e) => resume2(fail2(new UnknownException(e, "An unknown error occurred in Effect.andThen"))));
      });
    }
    return succeed(b);
  }));
  var step2 = (self) => {
    const effect = new EffectPrimitive("OnStep");
    effect.effect_instruction_i0 = self;
    return effect;
  };
  var flatten4 = (self) => flatMap8(self, identity);
  var flip2 = (self) => matchEffect(self, {
    onFailure: succeed,
    onSuccess: fail2
  });
  var matchCause = /* @__PURE__ */ dual(2, (self, options) => matchCauseEffect(self, {
    onFailure: (cause3) => succeed(options.onFailure(cause3)),
    onSuccess: (a) => succeed(options.onSuccess(a))
  }));
  var matchCauseEffect = /* @__PURE__ */ dual(2, (self, options) => {
    const effect = new EffectPrimitive(OP_ON_SUCCESS_AND_FAILURE);
    effect.effect_instruction_i0 = self;
    effect.effect_instruction_i1 = options.onFailure;
    effect.effect_instruction_i2 = options.onSuccess;
    return effect;
  });
  var matchEffect = /* @__PURE__ */ dual(2, (self, options) => matchCauseEffect(self, {
    onFailure: (cause3) => {
      const defects2 = defects(cause3);
      if (defects2.length > 0) {
        return failCause(electFailures(cause3));
      }
      const failures2 = failures(cause3);
      if (failures2.length > 0) {
        return options.onFailure(unsafeHead(failures2));
      }
      return failCause(cause3);
    },
    onSuccess: options.onSuccess
  }));
  var forEachSequential = /* @__PURE__ */ dual(2, (self, f) => suspend(() => {
    const arr = fromIterable(self);
    const ret = allocate(arr.length);
    let i = 0;
    return as(whileLoop({
      while: () => i < arr.length,
      body: () => f(arr[i], i),
      step: (b) => {
        ret[i++] = b;
      }
    }), ret);
  }));
  var forEachSequentialDiscard = /* @__PURE__ */ dual(2, (self, f) => suspend(() => {
    const arr = fromIterable(self);
    let i = 0;
    return whileLoop({
      while: () => i < arr.length,
      body: () => f(arr[i], i),
      step: () => {
        i++;
      }
    });
  }));
  var if_ = /* @__PURE__ */ dual((args2) => typeof args2[0] === "boolean" || isEffect(args2[0]), (self, options) => isEffect(self) ? flatMap8(self, (b) => b ? options.onTrue() : options.onFalse()) : self ? options.onTrue() : options.onFalse());
  var interrupt2 = /* @__PURE__ */ flatMap8(fiberId, (fiberId3) => interruptWith(fiberId3));
  var interruptWith = (fiberId3) => failCause(interrupt(fiberId3));
  var interruptible2 = (self) => {
    const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
    effect.effect_instruction_i0 = enable3(Interruption);
    effect.effect_instruction_i1 = () => self;
    return effect;
  };
  var interruptibleMask = (f) => custom(f, function() {
    const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
    effect.effect_instruction_i0 = enable3(Interruption);
    effect.effect_instruction_i1 = (oldFlags) => interruption(oldFlags) ? internalCall(() => this.effect_instruction_i0(interruptible2)) : internalCall(() => this.effect_instruction_i0(uninterruptible));
    return effect;
  });
  var intoDeferred = /* @__PURE__ */ dual(2, (self, deferred) => uninterruptibleMask((restore) => flatMap8(exit(restore(self)), (exit4) => deferredDone(deferred, exit4))));
  var map9 = /* @__PURE__ */ dual(2, (self, f) => flatMap8(self, (a) => sync(() => f(a))));
  var mapBoth2 = /* @__PURE__ */ dual(2, (self, options) => matchEffect(self, {
    onFailure: (e) => failSync(() => options.onFailure(e)),
    onSuccess: (a) => sync(() => options.onSuccess(a))
  }));
  var mapError = /* @__PURE__ */ dual(2, (self, f) => matchCauseEffect(self, {
    onFailure: (cause3) => {
      const either6 = failureOrCause(cause3);
      switch (either6._tag) {
        case "Left": {
          return failSync(() => f(either6.left));
        }
        case "Right": {
          return failCause(either6.right);
        }
      }
    },
    onSuccess: succeed
  }));
  var onError = /* @__PURE__ */ dual(2, (self, cleanup) => onExit(self, (exit4) => exitIsSuccess(exit4) ? void_2 : cleanup(exit4.effect_instruction_i0)));
  var onExit = /* @__PURE__ */ dual(2, (self, cleanup) => uninterruptibleMask((restore) => matchCauseEffect(restore(self), {
    onFailure: (cause1) => {
      const result = exitFailCause(cause1);
      return matchCauseEffect(cleanup(result), {
        onFailure: (cause22) => exitFailCause(sequential(cause1, cause22)),
        onSuccess: () => result
      });
    },
    onSuccess: (success) => {
      const result = exitSucceed(success);
      return zipRight(cleanup(result), result);
    }
  })));
  var onInterrupt = /* @__PURE__ */ dual(2, (self, cleanup) => onExit(self, exitMatch({
    onFailure: (cause3) => isInterruptedOnly(cause3) ? asVoid(cleanup(interruptors(cause3))) : void_2,
    onSuccess: () => void_2
  })));
  var orElse2 = /* @__PURE__ */ dual(2, (self, that) => attemptOrElse(self, that, succeed));
  var orDie = (self) => orDieWith(self, identity);
  var orDieWith = /* @__PURE__ */ dual(2, (self, f) => matchEffect(self, {
    onFailure: (e) => die2(f(e)),
    onSuccess: succeed
  }));
  var partitionMap2 = partitionMap;
  var runtimeFlags = /* @__PURE__ */ withFiberRuntime((_, status) => succeed(status.runtimeFlags));
  var succeed = (value) => {
    const effect = new EffectPrimitiveSuccess(OP_SUCCESS);
    effect.effect_instruction_i0 = value;
    return effect;
  };
  var suspend = (evaluate2) => {
    const effect = new EffectPrimitive(OP_COMMIT);
    effect.commit = evaluate2;
    return effect;
  };
  var sync = (thunk) => {
    const effect = new EffectPrimitive(OP_SYNC);
    effect.effect_instruction_i0 = thunk;
    return effect;
  };
  var tap = /* @__PURE__ */ dual((args2) => args2.length === 3 || args2.length === 2 && !(isObject(args2[1]) && "onlyEffect" in args2[1]), (self, f) => flatMap8(self, (a) => {
    const b = typeof f === "function" ? f(a) : f;
    if (isEffect(b)) {
      return as(b, a);
    } else if (isPromiseLike(b)) {
      return unsafeAsync((resume2) => {
        b.then((_) => resume2(succeed(a)), (e) => resume2(fail2(new UnknownException(e, "An unknown error occurred in Effect.tap"))));
      });
    }
    return succeed(a);
  }));
  var transplant = (f) => withFiberRuntime((state) => {
    const scopeOverride = state.getFiberRef(currentForkScopeOverride);
    const scope3 = pipe(scopeOverride, getOrElse2(() => state.scope()));
    return f(fiberRefLocally(currentForkScopeOverride, some2(scope3)));
  });
  var attemptOrElse = /* @__PURE__ */ dual(3, (self, that, onSuccess) => matchCauseEffect(self, {
    onFailure: (cause3) => {
      const defects2 = defects(cause3);
      if (defects2.length > 0) {
        return failCause(getOrThrow2(keepDefectsAndElectFailures(cause3)));
      }
      return that();
    },
    onSuccess
  }));
  var uninterruptible = (self) => {
    const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
    effect.effect_instruction_i0 = disable3(Interruption);
    effect.effect_instruction_i1 = () => self;
    return effect;
  };
  var uninterruptibleMask = (f) => custom(f, function() {
    const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
    effect.effect_instruction_i0 = disable3(Interruption);
    effect.effect_instruction_i1 = (oldFlags) => interruption(oldFlags) ? internalCall(() => this.effect_instruction_i0(interruptible2)) : internalCall(() => this.effect_instruction_i0(uninterruptible));
    return effect;
  });
  var void_2 = /* @__PURE__ */ succeed(void 0);
  var updateRuntimeFlags = (patch9) => {
    const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
    effect.effect_instruction_i0 = patch9;
    effect.effect_instruction_i1 = void 0;
    return effect;
  };
  var whenEffect = /* @__PURE__ */ dual(2, (self, condition) => flatMap8(condition, (b) => {
    if (b) {
      return pipe(self, map9(some2));
    }
    return succeed(none2());
  }));
  var whileLoop = (options) => {
    const effect = new EffectPrimitive(OP_WHILE);
    effect.effect_instruction_i0 = options.while;
    effect.effect_instruction_i1 = options.body;
    effect.effect_instruction_i2 = options.step;
    return effect;
  };
  var fromIterator = (iterator) => suspend(() => {
    const effect = new EffectPrimitive(OP_ITERATOR);
    effect.effect_instruction_i0 = iterator();
    return effect;
  });
  var gen2 = function() {
    const f = arguments.length === 1 ? arguments[0] : arguments[1].bind(arguments[0]);
    return fromIterator(() => f(pipe));
  };
  var fnUntraced = (body, ...pipeables) => Object.defineProperty(pipeables.length === 0 ? function(...args2) {
    return fromIterator(() => body.apply(this, args2));
  } : function(...args2) {
    let effect = fromIterator(() => body.apply(this, args2));
    for (const x of pipeables) {
      effect = x(effect, ...args2);
    }
    return effect;
  }, "length", {
    value: body.length,
    configurable: true
  });
  var withConcurrency = /* @__PURE__ */ dual(2, (self, concurrency) => fiberRefLocally(self, currentConcurrency, concurrency));
  var withRequestBatching = /* @__PURE__ */ dual(2, (self, requestBatching) => fiberRefLocally(self, currentRequestBatching, requestBatching));
  var withRuntimeFlags = /* @__PURE__ */ dual(2, (self, update5) => {
    const effect = new EffectPrimitive(OP_UPDATE_RUNTIME_FLAGS);
    effect.effect_instruction_i0 = update5;
    effect.effect_instruction_i1 = () => self;
    return effect;
  });
  var withTracerEnabled = /* @__PURE__ */ dual(2, (effect, enabled2) => fiberRefLocally(effect, currentTracerEnabled, enabled2));
  var withTracerTiming = /* @__PURE__ */ dual(2, (effect, enabled2) => fiberRefLocally(effect, currentTracerTimingEnabled, enabled2));
  var yieldNow = (options) => {
    const effect = new EffectPrimitive(OP_YIELD);
    return typeof options?.priority !== "undefined" ? withSchedulingPriority(effect, options.priority) : effect;
  };
  var zip2 = /* @__PURE__ */ dual(2, (self, that) => flatMap8(self, (a) => map9(that, (b) => [a, b])));
  var zipLeft = /* @__PURE__ */ dual(2, (self, that) => flatMap8(self, (a) => as(that, a)));
  var zipRight = /* @__PURE__ */ dual(2, (self, that) => flatMap8(self, () => that));
  var zipWith3 = /* @__PURE__ */ dual(3, (self, that, f) => flatMap8(self, (a) => map9(that, (b) => f(a, b))));
  var never = /* @__PURE__ */ asyncInterrupt(() => {
    const interval = setInterval(() => {
    }, 2 ** 31 - 1);
    return sync(() => clearInterval(interval));
  });
  var interruptFiber = (self) => flatMap8(fiberId, (fiberId3) => pipe(self, interruptAsFiber(fiberId3)));
  var interruptAsFiber = /* @__PURE__ */ dual(2, (self, fiberId3) => flatMap8(self.interruptAsFork(fiberId3), () => self.await));
  var logLevelAll = {
    _tag: "All",
    syslog: 0,
    label: "ALL",
    ordinal: Number.MIN_SAFE_INTEGER,
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var logLevelFatal = {
    _tag: "Fatal",
    syslog: 2,
    label: "FATAL",
    ordinal: 5e4,
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var logLevelError = {
    _tag: "Error",
    syslog: 3,
    label: "ERROR",
    ordinal: 4e4,
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var logLevelWarning = {
    _tag: "Warning",
    syslog: 4,
    label: "WARN",
    ordinal: 3e4,
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var logLevelInfo = {
    _tag: "Info",
    syslog: 6,
    label: "INFO",
    ordinal: 2e4,
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var logLevelDebug = {
    _tag: "Debug",
    syslog: 7,
    label: "DEBUG",
    ordinal: 1e4,
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var logLevelTrace = {
    _tag: "Trace",
    syslog: 7,
    label: "TRACE",
    ordinal: 0,
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var logLevelNone = {
    _tag: "None",
    syslog: 7,
    label: "OFF",
    ordinal: Number.MAX_SAFE_INTEGER,
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var FiberRefSymbolKey = "effect/FiberRef";
  var FiberRefTypeId = /* @__PURE__ */ Symbol.for(FiberRefSymbolKey);
  var fiberRefVariance = {
    /* c8 ignore next */
    _A: (_) => _
  };
  var fiberRefGet = (self) => withFiberRuntime((fiber) => exitSucceed(fiber.getFiberRef(self)));
  var fiberRefGetWith = /* @__PURE__ */ dual(2, (self, f) => flatMap8(fiberRefGet(self), f));
  var fiberRefSet = /* @__PURE__ */ dual(2, (self, value) => fiberRefModify(self, () => [void 0, value]));
  var fiberRefModify = /* @__PURE__ */ dual(2, (self, f) => withFiberRuntime((state) => {
    const [b, a] = f(state.getFiberRef(self));
    state.setFiberRef(self, a);
    return succeed(b);
  }));
  var RequestResolverSymbolKey = "effect/RequestResolver";
  var RequestResolverTypeId = /* @__PURE__ */ Symbol.for(RequestResolverSymbolKey);
  var requestResolverVariance = {
    /* c8 ignore next */
    _A: (_) => _,
    /* c8 ignore next */
    _R: (_) => _
  };
  var _a11;
  var RequestResolverImpl = class _RequestResolverImpl {
    constructor(runAll, target) {
      __publicField(this, "runAll");
      __publicField(this, "target");
      __publicField(this, _a11, requestResolverVariance);
      this.runAll = runAll;
      this.target = target;
    }
    [(_a11 = RequestResolverTypeId, symbol)]() {
      return cached(this, this.target ? hash(this.target) : random(this));
    }
    [symbol2](that) {
      return this.target ? isRequestResolver(that) && equals(this.target, that.target) : this === that;
    }
    identified(...ids3) {
      return new _RequestResolverImpl(this.runAll, fromIterable2(ids3));
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var isRequestResolver = (u) => hasProperty(u, RequestResolverTypeId);
  var fiberRefLocally = /* @__PURE__ */ dual(3, (use, self, value) => acquireUseRelease(zipLeft(fiberRefGet(self), fiberRefSet(self, value)), () => use, (oldValue) => fiberRefSet(self, oldValue)));
  var fiberRefLocallyWith = /* @__PURE__ */ dual(3, (use, self, f) => fiberRefGetWith(self, (a) => fiberRefLocally(use, self, f(a))));
  var fiberRefUnsafeMake = (initial, options) => fiberRefUnsafeMakePatch(initial, {
    differ: update(),
    fork: options?.fork ?? identity,
    join: options?.join
  });
  var fiberRefUnsafeMakeHashSet = (initial) => {
    const differ3 = hashSet();
    return fiberRefUnsafeMakePatch(initial, {
      differ: differ3,
      fork: differ3.empty
    });
  };
  var fiberRefUnsafeMakeReadonlyArray = (initial) => {
    const differ3 = readonlyArray(update());
    return fiberRefUnsafeMakePatch(initial, {
      differ: differ3,
      fork: differ3.empty
    });
  };
  var fiberRefUnsafeMakeContext = (initial) => {
    const differ3 = environment();
    return fiberRefUnsafeMakePatch(initial, {
      differ: differ3,
      fork: differ3.empty
    });
  };
  var fiberRefUnsafeMakePatch = (initial, options) => {
    const _fiberRef = {
      ...CommitPrototype,
      [FiberRefTypeId]: fiberRefVariance,
      initial,
      commit() {
        return fiberRefGet(this);
      },
      diff: (oldValue, newValue) => options.differ.diff(oldValue, newValue),
      combine: (first2, second) => options.differ.combine(first2, second),
      patch: (patch9) => (oldValue) => options.differ.patch(patch9, oldValue),
      fork: options.fork,
      join: options.join ?? ((_, n) => n)
    };
    return _fiberRef;
  };
  var fiberRefUnsafeMakeRuntimeFlags = (initial) => fiberRefUnsafeMakePatch(initial, {
    differ,
    fork: differ.empty
  });
  var currentContext = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentContext"), () => fiberRefUnsafeMakeContext(empty3()));
  var currentSchedulingPriority = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentSchedulingPriority"), () => fiberRefUnsafeMake(0));
  var currentMaxOpsBeforeYield = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentMaxOpsBeforeYield"), () => fiberRefUnsafeMake(2048));
  var currentLogAnnotations = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentLogAnnotation"), () => fiberRefUnsafeMake(empty8()));
  var currentLogLevel = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentLogLevel"), () => fiberRefUnsafeMake(logLevelInfo));
  var currentLogSpan = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentLogSpan"), () => fiberRefUnsafeMake(empty9()));
  var withSchedulingPriority = /* @__PURE__ */ dual(2, (self, scheduler) => fiberRefLocally(self, currentSchedulingPriority, scheduler));
  var withMaxOpsBeforeYield = /* @__PURE__ */ dual(2, (self, scheduler) => fiberRefLocally(self, currentMaxOpsBeforeYield, scheduler));
  var currentConcurrency = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentConcurrency"), () => fiberRefUnsafeMake("unbounded"));
  var currentRequestBatching = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentRequestBatching"), () => fiberRefUnsafeMake(true));
  var currentUnhandledErrorLogLevel = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentUnhandledErrorLogLevel"), () => fiberRefUnsafeMake(some2(logLevelDebug)));
  var currentVersionMismatchErrorLogLevel = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/versionMismatchErrorLogLevel"), () => fiberRefUnsafeMake(some2(logLevelWarning)));
  var withUnhandledErrorLogLevel = /* @__PURE__ */ dual(2, (self, level) => fiberRefLocally(self, currentUnhandledErrorLogLevel, level));
  var currentMetricLabels = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentMetricLabels"), () => fiberRefUnsafeMakeReadonlyArray(empty()));
  var metricLabels = /* @__PURE__ */ fiberRefGet(currentMetricLabels);
  var currentForkScopeOverride = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentForkScopeOverride"), () => fiberRefUnsafeMake(none2(), {
    fork: () => none2(),
    join: (parent, _) => parent
  }));
  var currentInterruptedCause = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentInterruptedCause"), () => fiberRefUnsafeMake(empty16, {
    fork: () => empty16,
    join: (parent, _) => parent
  }));
  var currentTracerEnabled = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentTracerEnabled"), () => fiberRefUnsafeMake(true));
  var currentTracerTimingEnabled = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentTracerTiming"), () => fiberRefUnsafeMake(true));
  var currentTracerSpanAnnotations = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentTracerSpanAnnotations"), () => fiberRefUnsafeMake(empty8()));
  var currentTracerSpanLinks = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentTracerSpanLinks"), () => fiberRefUnsafeMake(empty4()));
  var ScopeTypeId = /* @__PURE__ */ Symbol.for("effect/Scope");
  var CloseableScopeTypeId = /* @__PURE__ */ Symbol.for("effect/CloseableScope");
  var scopeAddFinalizer = (self, finalizer) => self.addFinalizer(() => asVoid(finalizer));
  var scopeAddFinalizerExit = (self, finalizer) => self.addFinalizer(finalizer);
  var scopeClose = (self, exit4) => self.close(exit4);
  var scopeFork = (self, strategy) => self.fork(strategy);
  var YieldableError = /* @__PURE__ */ (function() {
    class YieldableError2 extends globalThis.Error {
      commit() {
        return fail2(this);
      }
      toJSON() {
        const obj = {
          ...this
        };
        if (this.message) obj.message = this.message;
        if (this.cause) obj.cause = this.cause;
        return obj;
      }
      [NodeInspectSymbol]() {
        if (this.toString !== globalThis.Error.prototype.toString) {
          return this.stack ? `${this.toString()}
${this.stack.split("\n").slice(1).join("\n")}` : this.toString();
        } else if ("Bun" in globalThis) {
          return pretty(fail(this), {
            renderErrorCause: true
          });
        }
        return this;
      }
    }
    Object.assign(YieldableError2.prototype, StructuralCommitPrototype);
    return YieldableError2;
  })();
  var makeException = (proto4, tag) => {
    class Base3 extends YieldableError {
      constructor() {
        super(...arguments);
        __publicField(this, "_tag", tag);
      }
    }
    Object.assign(Base3.prototype, proto4);
    Base3.prototype.name = tag;
    return Base3;
  };
  var RuntimeExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/RuntimeException");
  var RuntimeException = /* @__PURE__ */ makeException({
    [RuntimeExceptionTypeId]: RuntimeExceptionTypeId
  }, "RuntimeException");
  var InterruptedExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/InterruptedException");
  var InterruptedException = /* @__PURE__ */ makeException({
    [InterruptedExceptionTypeId]: InterruptedExceptionTypeId
  }, "InterruptedException");
  var isInterruptedException = (u) => hasProperty(u, InterruptedExceptionTypeId);
  var IllegalArgumentExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/IllegalArgument");
  var IllegalArgumentException = /* @__PURE__ */ makeException({
    [IllegalArgumentExceptionTypeId]: IllegalArgumentExceptionTypeId
  }, "IllegalArgumentException");
  var NoSuchElementExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/NoSuchElement");
  var NoSuchElementException = /* @__PURE__ */ makeException({
    [NoSuchElementExceptionTypeId]: NoSuchElementExceptionTypeId
  }, "NoSuchElementException");
  var isNoSuchElementException = (u) => hasProperty(u, NoSuchElementExceptionTypeId);
  var InvalidPubSubCapacityExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/InvalidPubSubCapacityException");
  var InvalidPubSubCapacityException = /* @__PURE__ */ makeException({
    [InvalidPubSubCapacityExceptionTypeId]: InvalidPubSubCapacityExceptionTypeId
  }, "InvalidPubSubCapacityException");
  var ExceededCapacityExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/ExceededCapacityException");
  var ExceededCapacityException = /* @__PURE__ */ makeException({
    [ExceededCapacityExceptionTypeId]: ExceededCapacityExceptionTypeId
  }, "ExceededCapacityException");
  var TimeoutExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/Timeout");
  var TimeoutException = /* @__PURE__ */ makeException({
    [TimeoutExceptionTypeId]: TimeoutExceptionTypeId
  }, "TimeoutException");
  var timeoutExceptionFromDuration = (duration3) => new TimeoutException(`Operation timed out after '${format3(duration3)}'`);
  var UnknownExceptionTypeId = /* @__PURE__ */ Symbol.for("effect/Cause/errors/UnknownException");
  var UnknownException = /* @__PURE__ */ (function() {
    class UnknownException2 extends YieldableError {
      constructor(cause3, message) {
        super(message ?? "An unknown error occurred", {
          cause: cause3
        });
        __publicField(this, "_tag", "UnknownException");
        __publicField(this, "error");
        this.error = cause3;
      }
    }
    Object.assign(UnknownException2.prototype, {
      [UnknownExceptionTypeId]: UnknownExceptionTypeId,
      name: "UnknownException"
    });
    return UnknownException2;
  })();
  var exitIsExit = (u) => isEffect(u) && "_tag" in u && (u._tag === "Success" || u._tag === "Failure");
  var exitIsFailure = (self) => self._tag === "Failure";
  var exitIsSuccess = (self) => self._tag === "Success";
  var exitAs = /* @__PURE__ */ dual(2, (self, value) => {
    switch (self._tag) {
      case OP_FAILURE: {
        return exitFailCause(self.effect_instruction_i0);
      }
      case OP_SUCCESS: {
        return exitSucceed(value);
      }
    }
  });
  var exitAsVoid = (self) => exitAs(self, void 0);
  var exitCollectAll = (exits, options) => exitCollectAllInternal(exits, options?.parallel ? parallel : sequential);
  var exitDie = (defect) => exitFailCause(die(defect));
  var exitFail = (error) => exitFailCause(fail(error));
  var exitFailCause = (cause3) => {
    const effect = new EffectPrimitiveFailure(OP_FAILURE);
    effect.effect_instruction_i0 = cause3;
    return effect;
  };
  var exitFlatMap = /* @__PURE__ */ dual(2, (self, f) => {
    switch (self._tag) {
      case OP_FAILURE: {
        return exitFailCause(self.effect_instruction_i0);
      }
      case OP_SUCCESS: {
        return f(self.effect_instruction_i0);
      }
    }
  });
  var exitFlatten = (self) => pipe(self, exitFlatMap(identity));
  var exitInterrupt = (fiberId3) => exitFailCause(interrupt(fiberId3));
  var exitMap = /* @__PURE__ */ dual(2, (self, f) => {
    switch (self._tag) {
      case OP_FAILURE:
        return exitFailCause(self.effect_instruction_i0);
      case OP_SUCCESS:
        return exitSucceed(f(self.effect_instruction_i0));
    }
  });
  var exitMatch = /* @__PURE__ */ dual(2, (self, {
    onFailure,
    onSuccess
  }) => {
    switch (self._tag) {
      case OP_FAILURE:
        return onFailure(self.effect_instruction_i0);
      case OP_SUCCESS:
        return onSuccess(self.effect_instruction_i0);
    }
  });
  var exitMatchEffect = /* @__PURE__ */ dual(2, (self, {
    onFailure,
    onSuccess
  }) => {
    switch (self._tag) {
      case OP_FAILURE:
        return onFailure(self.effect_instruction_i0);
      case OP_SUCCESS:
        return onSuccess(self.effect_instruction_i0);
    }
  });
  var exitSucceed = (value) => {
    const effect = new EffectPrimitiveSuccess(OP_SUCCESS);
    effect.effect_instruction_i0 = value;
    return effect;
  };
  var exitVoid = /* @__PURE__ */ exitSucceed(void 0);
  var exitZipWith = /* @__PURE__ */ dual(3, (self, that, {
    onFailure,
    onSuccess
  }) => {
    switch (self._tag) {
      case OP_FAILURE: {
        switch (that._tag) {
          case OP_SUCCESS:
            return exitFailCause(self.effect_instruction_i0);
          case OP_FAILURE: {
            return exitFailCause(onFailure(self.effect_instruction_i0, that.effect_instruction_i0));
          }
        }
      }
      case OP_SUCCESS: {
        switch (that._tag) {
          case OP_SUCCESS:
            return exitSucceed(onSuccess(self.effect_instruction_i0, that.effect_instruction_i0));
          case OP_FAILURE:
            return exitFailCause(that.effect_instruction_i0);
        }
      }
    }
  });
  var exitCollectAllInternal = (exits, combineCauses) => {
    const list = fromIterable2(exits);
    if (!isNonEmpty(list)) {
      return none2();
    }
    return pipe(tailNonEmpty2(list), reduce(pipe(headNonEmpty2(list), exitMap(of2)), (accumulator, current) => pipe(accumulator, exitZipWith(current, {
      onSuccess: (list2, value) => pipe(list2, prepend2(value)),
      onFailure: combineCauses
    }))), exitMap(reverse2), exitMap((chunk2) => toReadonlyArray(chunk2)), some2);
  };
  var deferredUnsafeMake = (fiberId3) => {
    const _deferred = {
      ...CommitPrototype,
      [DeferredTypeId]: deferredVariance,
      state: make11(pending([])),
      commit() {
        return deferredAwait(this);
      },
      blockingOn: fiberId3
    };
    return _deferred;
  };
  var deferredMake = () => flatMap8(fiberId, (id) => deferredMakeAs(id));
  var deferredMakeAs = (fiberId3) => sync(() => deferredUnsafeMake(fiberId3));
  var deferredAwait = (self) => asyncInterrupt((resume2) => {
    const state = get6(self.state);
    switch (state._tag) {
      case OP_STATE_DONE: {
        return resume2(state.effect);
      }
      case OP_STATE_PENDING: {
        state.joiners.push(resume2);
        return deferredInterruptJoiner(self, resume2);
      }
    }
  }, self.blockingOn);
  var deferredComplete = /* @__PURE__ */ dual(2, (self, effect) => intoDeferred(effect, self));
  var deferredCompleteWith = /* @__PURE__ */ dual(2, (self, effect) => sync(() => {
    const state = get6(self.state);
    switch (state._tag) {
      case OP_STATE_DONE: {
        return false;
      }
      case OP_STATE_PENDING: {
        set2(self.state, done(effect));
        for (let i = 0, len = state.joiners.length; i < len; i++) {
          state.joiners[i](effect);
        }
        return true;
      }
    }
  }));
  var deferredDone = /* @__PURE__ */ dual(2, (self, exit4) => deferredCompleteWith(self, exit4));
  var deferredFailCause = /* @__PURE__ */ dual(2, (self, cause3) => deferredCompleteWith(self, failCause(cause3)));
  var deferredInterrupt = (self) => flatMap8(fiberId, (fiberId3) => deferredCompleteWith(self, interruptWith(fiberId3)));
  var deferredSucceed = /* @__PURE__ */ dual(2, (self, value) => deferredCompleteWith(self, succeed(value)));
  var deferredUnsafeDone = (self, effect) => {
    const state = get6(self.state);
    if (state._tag === OP_STATE_PENDING) {
      set2(self.state, done(effect));
      for (let i = 0, len = state.joiners.length; i < len; i++) {
        state.joiners[i](effect);
      }
    }
  };
  var deferredInterruptJoiner = (self, joiner) => sync(() => {
    const state = get6(self.state);
    if (state._tag === OP_STATE_PENDING) {
      const index = state.joiners.indexOf(joiner);
      if (index >= 0) {
        state.joiners.splice(index, 1);
      }
    }
  });
  var constContext = /* @__PURE__ */ withFiberRuntime((fiber) => exitSucceed(fiber.currentContext));
  var context = () => constContext;
  var contextWithEffect = (f) => flatMap8(context(), f);
  var provideContext = /* @__PURE__ */ dual(2, (self, context4) => fiberRefLocally(currentContext, context4)(self));
  var provideSomeContext = /* @__PURE__ */ dual(2, (self, context4) => fiberRefLocallyWith(currentContext, (parent) => merge3(parent, context4))(self));
  var mapInputContext = /* @__PURE__ */ dual(2, (self, f) => contextWithEffect((context4) => provideContext(self, f(context4))));
  var filterEffectOrElse = /* @__PURE__ */ dual(2, (self, options) => flatMap8(self, (a) => flatMap8(options.predicate(a), (pass) => pass ? succeed(a) : options.orElse(a))));
  var filterEffectOrFail = /* @__PURE__ */ dual(2, (self, options) => filterEffectOrElse(self, {
    predicate: options.predicate,
    orElse: (a) => fail2(options.orFailWith(a))
  }));
  var currentSpanFromFiber = (fiber) => {
    const span2 = fiber.currentSpan;
    return span2 !== void 0 && span2._tag === "Span" ? some2(span2) : none2();
  };
  var NoopSpanProto = {
    _tag: "Span",
    spanId: "noop",
    traceId: "noop",
    sampled: false,
    status: {
      _tag: "Ended",
      startTime: /* @__PURE__ */ BigInt(0),
      endTime: /* @__PURE__ */ BigInt(0),
      exit: exitVoid
    },
    attributes: /* @__PURE__ */ new Map(),
    links: [],
    kind: "internal",
    attribute() {
    },
    event() {
    },
    end() {
    },
    addLinks() {
    }
  };
  var noopSpan = (options) => Object.assign(Object.create(NoopSpanProto), options);

  // <eztb>/node_modules/effect/dist/esm/Deferred.js
  var _await = deferredAwait;
  var done2 = deferredDone;
  var interrupt3 = deferredInterrupt;
  var unsafeMake3 = deferredUnsafeMake;

  // <eztb>/node_modules/effect/dist/esm/Exit.js
  var flatten5 = exitFlatten;
  var succeed2 = exitSucceed;

  // <eztb>/node_modules/effect/dist/esm/MutableHashMap.js
  var TypeId9 = /* @__PURE__ */ Symbol.for("effect/MutableHashMap");
  var MutableHashMapProto = {
    [TypeId9]: TypeId9,
    [Symbol.iterator]() {
      return new MutableHashMapIterator(this);
    },
    toString() {
      return format2(this.toJSON());
    },
    toJSON() {
      return {
        _id: "MutableHashMap",
        values: Array.from(this).map(toJSON)
      };
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var MutableHashMapIterator = class _MutableHashMapIterator {
    constructor(self) {
      __publicField(this, "self");
      __publicField(this, "referentialIterator");
      __publicField(this, "bucketIterator");
      this.self = self;
      this.referentialIterator = self.referential[Symbol.iterator]();
    }
    next() {
      if (this.bucketIterator !== void 0) {
        return this.bucketIterator.next();
      }
      const result = this.referentialIterator.next();
      if (result.done) {
        this.bucketIterator = new BucketIterator(this.self.buckets.values());
        return this.next();
      }
      return result;
    }
    [Symbol.iterator]() {
      return new _MutableHashMapIterator(this.self);
    }
  };
  var BucketIterator = class {
    constructor(backing) {
      __publicField(this, "backing");
      __publicField(this, "currentBucket");
      this.backing = backing;
    }
    next() {
      if (this.currentBucket === void 0) {
        const result2 = this.backing.next();
        if (result2.done) {
          return result2;
        }
        this.currentBucket = result2.value[Symbol.iterator]();
      }
      const result = this.currentBucket.next();
      if (result.done) {
        this.currentBucket = void 0;
        return this.next();
      }
      return result;
    }
  };
  var empty17 = () => {
    const self = Object.create(MutableHashMapProto);
    self.referential = /* @__PURE__ */ new Map();
    self.buckets = /* @__PURE__ */ new Map();
    self.bucketsSize = 0;
    return self;
  };
  var get8 = /* @__PURE__ */ dual(2, (self, key) => {
    if (isEqual(key) === false) {
      return self.referential.has(key) ? some2(self.referential.get(key)) : none2();
    }
    const hash2 = key[symbol]();
    const bucket = self.buckets.get(hash2);
    if (bucket === void 0) {
      return none2();
    }
    return getFromBucket(self, bucket, key);
  });
  var getFromBucket = (self, bucket, key, remove8 = false) => {
    for (let i = 0, len = bucket.length; i < len; i++) {
      if (key[symbol2](bucket[i][0])) {
        const value = bucket[i][1];
        if (remove8) {
          bucket.splice(i, 1);
          self.bucketsSize--;
        }
        return some2(value);
      }
    }
    return none2();
  };
  var has4 = /* @__PURE__ */ dual(2, (self, key) => isSome2(get8(self, key)));
  var set4 = /* @__PURE__ */ dual(3, (self, key, value) => {
    if (isEqual(key) === false) {
      self.referential.set(key, value);
      return self;
    }
    const hash2 = key[symbol]();
    const bucket = self.buckets.get(hash2);
    if (bucket === void 0) {
      self.buckets.set(hash2, [[key, value]]);
      self.bucketsSize++;
      return self;
    }
    removeFromBucket(self, bucket, key);
    bucket.push([key, value]);
    self.bucketsSize++;
    return self;
  });
  var removeFromBucket = (self, bucket, key) => {
    for (let i = 0, len = bucket.length; i < len; i++) {
      if (key[symbol2](bucket[i][0])) {
        bucket.splice(i, 1);
        self.bucketsSize--;
        return;
      }
    }
  };
  var remove5 = /* @__PURE__ */ dual(2, (self, key) => {
    if (isEqual(key) === false) {
      self.referential.delete(key);
      return self;
    }
    const hash2 = key[symbol]();
    const bucket = self.buckets.get(hash2);
    if (bucket === void 0) {
      return self;
    }
    removeFromBucket(self, bucket, key);
    if (bucket.length === 0) {
      self.buckets.delete(hash2);
    }
    return self;
  });
  var size4 = (self) => {
    return self.referential.size + self.bucketsSize;
  };

  // <eztb>/node_modules/effect/dist/esm/MutableList.js
  var TypeId10 = /* @__PURE__ */ Symbol.for("effect/MutableList");
  var MutableListProto = {
    [TypeId10]: TypeId10,
    [Symbol.iterator]() {
      let done7 = false;
      let head5 = this.head;
      return {
        next() {
          if (done7) {
            return this.return();
          }
          if (head5 == null) {
            done7 = true;
            return this.return();
          }
          const value = head5.value;
          head5 = head5.next;
          return {
            done: done7,
            value
          };
        },
        return(value) {
          if (!done7) {
            done7 = true;
          }
          return {
            done: true,
            value
          };
        }
      };
    },
    toString() {
      return format2(this.toJSON());
    },
    toJSON() {
      return {
        _id: "MutableList",
        values: Array.from(this).map(toJSON)
      };
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var makeNode = (value) => ({
    value,
    removed: false,
    prev: void 0,
    next: void 0
  });
  var empty18 = () => {
    const list = Object.create(MutableListProto);
    list.head = void 0;
    list.tail = void 0;
    list._length = 0;
    return list;
  };
  var isEmpty6 = (self) => length(self) === 0;
  var length = (self) => self._length;
  var append3 = /* @__PURE__ */ dual(2, (self, value) => {
    const node = makeNode(value);
    if (self.head === void 0) {
      self.head = node;
    }
    if (self.tail === void 0) {
      self.tail = node;
    } else {
      self.tail.next = node;
      node.prev = self.tail;
      self.tail = node;
    }
    ;
    self._length += 1;
    return self;
  });
  var shift = (self) => {
    const head5 = self.head;
    if (head5 !== void 0) {
      remove6(self, head5);
      return head5.value;
    }
    return void 0;
  };
  var remove6 = (self, node) => {
    if (node.removed) {
      return;
    }
    node.removed = true;
    if (node.prev !== void 0 && node.next !== void 0) {
      node.prev.next = node.next;
      node.next.prev = node.prev;
    } else if (node.prev !== void 0) {
      self.tail = node.prev;
      node.prev.next = void 0;
    } else if (node.next !== void 0) {
      self.head = node.next;
      node.next.prev = void 0;
    } else {
      self.tail = void 0;
      self.head = void 0;
    }
    if (self._length > 0) {
      ;
      self._length -= 1;
    }
  };

  // <eztb>/node_modules/effect/dist/esm/MutableQueue.js
  var TypeId11 = /* @__PURE__ */ Symbol.for("effect/MutableQueue");
  var EmptyMutableQueue = /* @__PURE__ */ Symbol.for("effect/mutable/MutableQueue/Empty");
  var MutableQueueProto = {
    [TypeId11]: TypeId11,
    [Symbol.iterator]() {
      return Array.from(this.queue)[Symbol.iterator]();
    },
    toString() {
      return format2(this.toJSON());
    },
    toJSON() {
      return {
        _id: "MutableQueue",
        values: Array.from(this).map(toJSON)
      };
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var make18 = (capacity) => {
    const queue = Object.create(MutableQueueProto);
    queue.queue = empty18();
    queue.capacity = capacity;
    return queue;
  };
  var unbounded = () => make18(void 0);
  var offer = /* @__PURE__ */ dual(2, (self, value) => {
    const queueLength = length(self.queue);
    if (self.capacity !== void 0 && queueLength === self.capacity) {
      return false;
    }
    append3(value)(self.queue);
    return true;
  });
  var poll = /* @__PURE__ */ dual(2, (self, def) => {
    if (isEmpty6(self.queue)) {
      return def;
    }
    return shift(self.queue);
  });

  // <eztb>/node_modules/effect/dist/esm/internal/clock.js
  var ClockSymbolKey = "effect/Clock";
  var ClockTypeId = /* @__PURE__ */ Symbol.for(ClockSymbolKey);
  var clockTag = /* @__PURE__ */ GenericTag("effect/Clock");
  var MAX_TIMER_MILLIS = 2 ** 31 - 1;
  var globalClockScheduler = {
    unsafeSchedule(task, duration3) {
      const millis2 = toMillis(duration3);
      if (millis2 > MAX_TIMER_MILLIS) {
        return constFalse;
      }
      let completed = false;
      const handle = setTimeout(() => {
        completed = true;
        task();
      }, millis2);
      return () => {
        clearTimeout(handle);
        return !completed;
      };
    }
  };
  var performanceNowNanos = /* @__PURE__ */ (function() {
    const bigint1e62 = /* @__PURE__ */ BigInt(1e6);
    if (typeof performance === "undefined" || typeof performance.now !== "function") {
      return () => BigInt(Date.now()) * bigint1e62;
    }
    let origin;
    return () => {
      if (origin === void 0) {
        origin = BigInt(Date.now()) * bigint1e62 - BigInt(Math.round(performance.now() * 1e6));
      }
      return origin + BigInt(Math.round(performance.now() * 1e6));
    };
  })();
  var processOrPerformanceNow = /* @__PURE__ */ (function() {
    const processHrtime = typeof process === "object" && "hrtime" in process && typeof process.hrtime.bigint === "function" ? process.hrtime : void 0;
    if (!processHrtime) {
      return performanceNowNanos;
    }
    const origin = /* @__PURE__ */ performanceNowNanos() - /* @__PURE__ */ processHrtime.bigint();
    return () => origin + processHrtime.bigint();
  })();
  var _a12;
  _a12 = ClockTypeId;
  var ClockImpl = class {
    constructor() {
      __publicField(this, _a12, ClockTypeId);
      __publicField(this, "currentTimeMillis", /* @__PURE__ */ sync(() => this.unsafeCurrentTimeMillis()));
      __publicField(this, "currentTimeNanos", /* @__PURE__ */ sync(() => this.unsafeCurrentTimeNanos()));
    }
    unsafeCurrentTimeMillis() {
      return Date.now();
    }
    unsafeCurrentTimeNanos() {
      return processOrPerformanceNow();
    }
    scheduler() {
      return succeed(globalClockScheduler);
    }
    sleep(duration3) {
      return async_((resume2) => {
        const canceler = globalClockScheduler.unsafeSchedule(() => resume2(void_2), duration3);
        return asVoid(sync(canceler));
      });
    }
  };
  var make19 = () => new ClockImpl();

  // <eztb>/node_modules/effect/dist/esm/internal/opCodes/configError.js
  var OP_AND = "And";
  var OP_OR = "Or";
  var OP_INVALID_DATA = "InvalidData";
  var OP_MISSING_DATA = "MissingData";
  var OP_SOURCE_UNAVAILABLE = "SourceUnavailable";
  var OP_UNSUPPORTED = "Unsupported";

  // <eztb>/node_modules/effect/dist/esm/internal/configError.js
  var ConfigErrorSymbolKey = "effect/ConfigError";
  var ConfigErrorTypeId = /* @__PURE__ */ Symbol.for(ConfigErrorSymbolKey);
  var proto2 = {
    _tag: "ConfigError",
    [ConfigErrorTypeId]: ConfigErrorTypeId
  };
  var And = (self, that) => {
    const error = Object.create(proto2);
    error._op = OP_AND;
    error.left = self;
    error.right = that;
    Object.defineProperty(error, "toString", {
      enumerable: false,
      value() {
        return `${this.left} and ${this.right}`;
      }
    });
    Object.defineProperty(error, "message", {
      enumerable: false,
      get() {
        return this.toString();
      }
    });
    return error;
  };
  var Or = (self, that) => {
    const error = Object.create(proto2);
    error._op = OP_OR;
    error.left = self;
    error.right = that;
    Object.defineProperty(error, "toString", {
      enumerable: false,
      value() {
        return `${this.left} or ${this.right}`;
      }
    });
    Object.defineProperty(error, "message", {
      enumerable: false,
      get() {
        return this.toString();
      }
    });
    return error;
  };
  var InvalidData = (path, message, options = {
    pathDelim: "."
  }) => {
    const error = Object.create(proto2);
    error._op = OP_INVALID_DATA;
    error.path = path;
    error.message = message;
    Object.defineProperty(error, "toString", {
      enumerable: false,
      value() {
        const path2 = pipe(this.path, join(options.pathDelim));
        return `(Invalid data at ${path2}: "${this.message}")`;
      }
    });
    return error;
  };
  var MissingData = (path, message, options = {
    pathDelim: "."
  }) => {
    const error = Object.create(proto2);
    error._op = OP_MISSING_DATA;
    error.path = path;
    error.message = message;
    Object.defineProperty(error, "toString", {
      enumerable: false,
      value() {
        const path2 = pipe(this.path, join(options.pathDelim));
        return `(Missing data at ${path2}: "${this.message}")`;
      }
    });
    return error;
  };
  var SourceUnavailable = (path, message, cause3, options = {
    pathDelim: "."
  }) => {
    const error = Object.create(proto2);
    error._op = OP_SOURCE_UNAVAILABLE;
    error.path = path;
    error.message = message;
    error.cause = cause3;
    Object.defineProperty(error, "toString", {
      enumerable: false,
      value() {
        const path2 = pipe(this.path, join(options.pathDelim));
        return `(Source unavailable at ${path2}: "${this.message}")`;
      }
    });
    return error;
  };
  var Unsupported = (path, message, options = {
    pathDelim: "."
  }) => {
    const error = Object.create(proto2);
    error._op = OP_UNSUPPORTED;
    error.path = path;
    error.message = message;
    Object.defineProperty(error, "toString", {
      enumerable: false,
      value() {
        const path2 = pipe(this.path, join(options.pathDelim));
        return `(Unsupported operation at ${path2}: "${this.message}")`;
      }
    });
    return error;
  };
  var prefixed = /* @__PURE__ */ dual(2, (self, prefix) => {
    switch (self._op) {
      case OP_AND: {
        return And(prefixed(self.left, prefix), prefixed(self.right, prefix));
      }
      case OP_OR: {
        return Or(prefixed(self.left, prefix), prefixed(self.right, prefix));
      }
      case OP_INVALID_DATA: {
        return InvalidData([...prefix, ...self.path], self.message);
      }
      case OP_MISSING_DATA: {
        return MissingData([...prefix, ...self.path], self.message);
      }
      case OP_SOURCE_UNAVAILABLE: {
        return SourceUnavailable([...prefix, ...self.path], self.message, self.cause);
      }
      case OP_UNSUPPORTED: {
        return Unsupported([...prefix, ...self.path], self.message);
      }
    }
  });

  // <eztb>/node_modules/effect/dist/esm/internal/configProvider/pathPatch.js
  var empty19 = {
    _tag: "Empty"
  };
  var patch5 = /* @__PURE__ */ dual(2, (path, patch9) => {
    let input = of3(patch9);
    let output = path;
    while (isCons(input)) {
      const patch10 = input.head;
      switch (patch10._tag) {
        case "Empty": {
          input = input.tail;
          break;
        }
        case "AndThen": {
          input = cons(patch10.first, cons(patch10.second, input.tail));
          break;
        }
        case "MapName": {
          output = map3(output, patch10.f);
          input = input.tail;
          break;
        }
        case "Nested": {
          output = prepend(output, patch10.name);
          input = input.tail;
          break;
        }
        case "Unnested": {
          const containsName = pipe(head(output), contains(patch10.name));
          if (containsName) {
            output = tailNonEmpty(output);
            input = input.tail;
          } else {
            return left2(MissingData(output, `Expected ${patch10.name} to be in path in ConfigProvider#unnested`));
          }
          break;
        }
      }
    }
    return right2(output);
  });

  // <eztb>/node_modules/effect/dist/esm/internal/opCodes/config.js
  var OP_CONSTANT = "Constant";
  var OP_FAIL2 = "Fail";
  var OP_FALLBACK = "Fallback";
  var OP_DESCRIBED = "Described";
  var OP_LAZY = "Lazy";
  var OP_MAP_OR_FAIL = "MapOrFail";
  var OP_NESTED = "Nested";
  var OP_PRIMITIVE = "Primitive";
  var OP_SEQUENCE = "Sequence";
  var OP_HASHMAP = "HashMap";
  var OP_ZIP_WITH = "ZipWith";

  // <eztb>/node_modules/effect/dist/esm/internal/configProvider.js
  var concat = (l, r) => [...l, ...r];
  var ConfigProviderSymbolKey = "effect/ConfigProvider";
  var ConfigProviderTypeId = /* @__PURE__ */ Symbol.for(ConfigProviderSymbolKey);
  var configProviderTag = /* @__PURE__ */ GenericTag("effect/ConfigProvider");
  var FlatConfigProviderSymbolKey = "effect/ConfigProviderFlat";
  var FlatConfigProviderTypeId = /* @__PURE__ */ Symbol.for(FlatConfigProviderSymbolKey);
  var make21 = (options) => ({
    [ConfigProviderTypeId]: ConfigProviderTypeId,
    pipe() {
      return pipeArguments(this, arguments);
    },
    ...options
  });
  var makeFlat = (options) => ({
    [FlatConfigProviderTypeId]: FlatConfigProviderTypeId,
    patch: options.patch,
    load: (path, config, split = true) => options.load(path, config, split),
    enumerateChildren: options.enumerateChildren
  });
  var fromFlat = (flat) => make21({
    load: (config) => flatMap8(fromFlatLoop(flat, empty(), config, false), (chunk2) => match2(head(chunk2), {
      onNone: () => fail2(MissingData(empty(), `Expected a single value having structure: ${config}`)),
      onSome: succeed
    })),
    flattened: flat
  });
  var fromEnv = (options) => {
    const {
      pathDelim,
      seqDelim
    } = Object.assign({}, {
      pathDelim: "_",
      seqDelim: ","
    }, options);
    const makePathString = (path) => pipe(path, join(pathDelim));
    const unmakePathString = (pathString) => pathString.split(pathDelim);
    const getEnv = () => typeof process !== "undefined" && "env" in process && typeof process.env === "object" ? process.env : {};
    const load = (path, primitive, split = true) => {
      const pathString = makePathString(path);
      const current = getEnv();
      const valueOpt = pathString in current ? some2(current[pathString]) : none2();
      return pipe(valueOpt, mapError(() => MissingData(path, `Expected ${pathString} to exist in the process context`)), flatMap8((value) => parsePrimitive(value, path, primitive, seqDelim, split)));
    };
    const enumerateChildren = (path) => sync(() => {
      const current = getEnv();
      const keys5 = Object.keys(current);
      const keyPaths = keys5.map((value) => unmakePathString(value.toUpperCase()));
      const filteredKeyPaths = keyPaths.filter((keyPath) => {
        for (let i = 0; i < path.length; i++) {
          const pathComponent = pipe(path, unsafeGet(i));
          const currentElement = keyPath[i];
          if (currentElement === void 0 || pathComponent !== currentElement) {
            return false;
          }
        }
        return true;
      }).flatMap((keyPath) => keyPath.slice(path.length, path.length + 1));
      return fromIterable5(filteredKeyPaths);
    });
    return fromFlat(makeFlat({
      load,
      enumerateChildren,
      patch: empty19
    }));
  };
  var extend = (leftDef, rightDef, left3, right3) => {
    const leftPad = unfold(left3.length, (index) => index >= right3.length ? none2() : some2([leftDef(index), index + 1]));
    const rightPad = unfold(right3.length, (index) => index >= left3.length ? none2() : some2([rightDef(index), index + 1]));
    const leftExtension = concat(left3, leftPad);
    const rightExtension = concat(right3, rightPad);
    return [leftExtension, rightExtension];
  };
  var appendConfigPath = (path, config) => {
    let op = config;
    if (op._tag === "Nested") {
      const out = path.slice();
      while (op._tag === "Nested") {
        out.push(op.name);
        op = op.config;
      }
      return out;
    }
    return path;
  };
  var fromFlatLoop = (flat, prefix, config, split) => {
    const op = config;
    switch (op._tag) {
      case OP_CONSTANT: {
        return succeed(of(op.value));
      }
      case OP_DESCRIBED: {
        return suspend(() => fromFlatLoop(flat, prefix, op.config, split));
      }
      case OP_FAIL2: {
        return fail2(MissingData(prefix, op.message));
      }
      case OP_FALLBACK: {
        return pipe(suspend(() => fromFlatLoop(flat, prefix, op.first, split)), catchAll((error1) => {
          if (op.condition(error1)) {
            return pipe(fromFlatLoop(flat, prefix, op.second, split), catchAll((error2) => fail2(Or(error1, error2))));
          }
          return fail2(error1);
        }));
      }
      case OP_LAZY: {
        return suspend(() => fromFlatLoop(flat, prefix, op.config(), split));
      }
      case OP_MAP_OR_FAIL: {
        return suspend(() => pipe(fromFlatLoop(flat, prefix, op.original, split), flatMap8(forEachSequential((a) => pipe(op.mapOrFail(a), mapError(prefixed(appendConfigPath(prefix, op.original))))))));
      }
      case OP_NESTED: {
        return suspend(() => fromFlatLoop(flat, concat(prefix, of(op.name)), op.config, split));
      }
      case OP_PRIMITIVE: {
        return pipe(patch5(prefix, flat.patch), flatMap8((prefix2) => pipe(flat.load(prefix2, op, split), flatMap8((values3) => {
          if (values3.length === 0) {
            const name = pipe(last(prefix2), getOrElse2(() => "<n/a>"));
            return fail2(MissingData([], `Expected ${op.description} with name ${name}`));
          }
          return succeed(values3);
        }))));
      }
      case OP_SEQUENCE: {
        return pipe(patch5(prefix, flat.patch), flatMap8((patchedPrefix) => pipe(flat.enumerateChildren(patchedPrefix), flatMap8(indicesFrom), flatMap8((indices) => {
          if (indices.length === 0) {
            return suspend(() => map9(fromFlatLoop(flat, prefix, op.config, true), of));
          }
          return pipe(forEachSequential(indices, (index) => fromFlatLoop(flat, append(prefix, `[${index}]`), op.config, true)), map9((chunkChunk) => {
            const flattened = flatten(chunkChunk);
            if (flattened.length === 0) {
              return of(empty());
            }
            return of(flattened);
          }));
        }))));
      }
      case OP_HASHMAP: {
        return suspend(() => pipe(patch5(prefix, flat.patch), flatMap8((prefix2) => pipe(flat.enumerateChildren(prefix2), flatMap8((keys5) => {
          return pipe(keys5, forEachSequential((key) => fromFlatLoop(flat, concat(prefix2, of(key)), op.valueConfig, split)), map9((matrix) => {
            if (matrix.length === 0) {
              return of(empty8());
            }
            return pipe(transpose(matrix), map3((values3) => fromIterable6(zip(fromIterable(keys5), values3))));
          }));
        })))));
      }
      case OP_ZIP_WITH: {
        return suspend(() => pipe(fromFlatLoop(flat, prefix, op.left, split), either2, flatMap8((left3) => pipe(fromFlatLoop(flat, prefix, op.right, split), either2, flatMap8((right3) => {
          if (isLeft2(left3) && isLeft2(right3)) {
            return fail2(And(left3.left, right3.left));
          }
          if (isLeft2(left3) && isRight2(right3)) {
            return fail2(left3.left);
          }
          if (isRight2(left3) && isLeft2(right3)) {
            return fail2(right3.left);
          }
          if (isRight2(left3) && isRight2(right3)) {
            const path = pipe(prefix, join("."));
            const fail5 = fromFlatLoopFail(prefix, path);
            const [lefts, rights] = extend(fail5, fail5, pipe(left3.right, map3(right2)), pipe(right3.right, map3(right2)));
            return pipe(lefts, zip(rights), forEachSequential(([left4, right4]) => pipe(zip2(left4, right4), map9(([left5, right5]) => op.zip(left5, right5)))));
          }
          throw new Error("BUG: ConfigProvider.fromFlatLoop - please report an issue at https://github.com/Effect-TS/effect/issues");
        })))));
      }
    }
  };
  var fromFlatLoopFail = (prefix, path) => (index) => left2(MissingData(prefix, `The element at index ${index} in a sequence at path "${path}" was missing`));
  var splitPathString = (text, delim) => {
    const split = text.split(new RegExp(`\\s*${escape(delim)}\\s*`));
    return split;
  };
  var parsePrimitive = (text, path, primitive, delimiter, split) => {
    if (!split) {
      return pipe(primitive.parse(text), mapBoth2({
        onFailure: prefixed(path),
        onSuccess: of
      }));
    }
    return pipe(splitPathString(text, delimiter), forEachSequential((char) => primitive.parse(char.trim())), mapError(prefixed(path)));
  };
  var transpose = (array3) => {
    return Object.keys(array3[0]).map((column) => array3.map((row) => row[column]));
  };
  var indicesFrom = (quotedIndices) => pipe(forEachSequential(quotedIndices, parseQuotedIndex), mapBoth2({
    onFailure: () => empty(),
    onSuccess: sort(Order)
  }), either2, map9(merge));
  var QUOTED_INDEX_REGEX = /^(\[(\d+)\])$/;
  var parseQuotedIndex = (str) => {
    const match11 = str.match(QUOTED_INDEX_REGEX);
    if (match11 !== null) {
      const matchedIndex = match11[2];
      return pipe(matchedIndex !== void 0 && matchedIndex.length > 0 ? some2(matchedIndex) : none2(), flatMap2(parseInteger));
    }
    return none2();
  };
  var parseInteger = (str) => {
    const parsedIndex = Number.parseInt(str);
    return Number.isNaN(parsedIndex) ? none2() : some2(parsedIndex);
  };

  // <eztb>/node_modules/effect/dist/esm/internal/defaultServices/console.js
  var TypeId12 = /* @__PURE__ */ Symbol.for("effect/Console");
  var consoleTag = /* @__PURE__ */ GenericTag("effect/Console");
  var defaultConsole = {
    [TypeId12]: TypeId12,
    assert(condition, ...args2) {
      return sync(() => {
        console.assert(condition, ...args2);
      });
    },
    clear: /* @__PURE__ */ sync(() => {
      console.clear();
    }),
    count(label) {
      return sync(() => {
        console.count(label);
      });
    },
    countReset(label) {
      return sync(() => {
        console.countReset(label);
      });
    },
    debug(...args2) {
      return sync(() => {
        console.debug(...args2);
      });
    },
    dir(item, options) {
      return sync(() => {
        console.dir(item, options);
      });
    },
    dirxml(...args2) {
      return sync(() => {
        console.dirxml(...args2);
      });
    },
    error(...args2) {
      return sync(() => {
        console.error(...args2);
      });
    },
    group(options) {
      return options?.collapsed ? sync(() => console.groupCollapsed(options?.label)) : sync(() => console.group(options?.label));
    },
    groupEnd: /* @__PURE__ */ sync(() => {
      console.groupEnd();
    }),
    info(...args2) {
      return sync(() => {
        console.info(...args2);
      });
    },
    log(...args2) {
      return sync(() => {
        console.log(...args2);
      });
    },
    table(tabularData, properties) {
      return sync(() => {
        console.table(tabularData, properties);
      });
    },
    time(label) {
      return sync(() => console.time(label));
    },
    timeEnd(label) {
      return sync(() => console.timeEnd(label));
    },
    timeLog(label, ...args2) {
      return sync(() => {
        console.timeLog(label, ...args2);
      });
    },
    trace(...args2) {
      return sync(() => {
        console.trace(...args2);
      });
    },
    warn(...args2) {
      return sync(() => {
        console.warn(...args2);
      });
    },
    unsafe: console
  };

  // <eztb>/node_modules/effect/dist/esm/internal/random.js
  var RandomSymbolKey = "effect/Random";
  var RandomTypeId = /* @__PURE__ */ Symbol.for(RandomSymbolKey);
  var randomTag = /* @__PURE__ */ GenericTag("effect/Random");
  var _a13;
  _a13 = RandomTypeId;
  var RandomImpl = class {
    constructor(seed) {
      __publicField(this, "seed");
      __publicField(this, _a13, RandomTypeId);
      __publicField(this, "PRNG");
      this.seed = seed;
      this.PRNG = new PCGRandom(seed);
    }
    get next() {
      return sync(() => this.PRNG.number());
    }
    get nextBoolean() {
      return map9(this.next, (n) => n > 0.5);
    }
    get nextInt() {
      return sync(() => this.PRNG.integer(Number.MAX_SAFE_INTEGER));
    }
    nextRange(min4, max6) {
      return map9(this.next, (n) => (max6 - min4) * n + min4);
    }
    nextIntBetween(min4, max6) {
      return sync(() => this.PRNG.integer(max6 - min4) + min4);
    }
    shuffle(elements) {
      return shuffleWith(elements, (n) => this.nextIntBetween(0, n));
    }
  };
  var shuffleWith = (elements, nextIntBounded) => {
    return suspend(() => pipe(sync(() => Array.from(elements)), flatMap8((buffer) => {
      const numbers = [];
      for (let i = buffer.length; i >= 2; i = i - 1) {
        numbers.push(i);
      }
      return pipe(numbers, forEachSequentialDiscard((n) => pipe(nextIntBounded(n), map9((k) => swap(buffer, n - 1, k)))), as(fromIterable2(buffer)));
    })));
  };
  var swap = (buffer, index1, index2) => {
    const tmp = buffer[index1];
    buffer[index1] = buffer[index2];
    buffer[index2] = tmp;
    return buffer;
  };
  var make22 = (seed) => new RandomImpl(hash(seed));
  var _a14;
  _a14 = RandomTypeId;
  var FixedRandomImpl = class {
    constructor(values3) {
      __publicField(this, "values");
      __publicField(this, _a14, RandomTypeId);
      __publicField(this, "index", 0);
      this.values = values3;
      if (values3.length === 0) {
        throw new Error("Requires at least one value");
      }
    }
    getNextValue() {
      const value = this.values[this.index];
      this.index = (this.index + 1) % this.values.length;
      return value;
    }
    get next() {
      return sync(() => {
        const value = this.getNextValue();
        if (typeof value === "number") {
          return Math.max(0, Math.min(1, value));
        }
        return hash(value) / 2147483647;
      });
    }
    get nextBoolean() {
      return sync(() => {
        const value = this.getNextValue();
        if (typeof value === "boolean") {
          return value;
        }
        return hash(value) % 2 === 0;
      });
    }
    get nextInt() {
      return sync(() => {
        const value = this.getNextValue();
        if (typeof value === "number" && Number.isFinite(value)) {
          return Math.round(value);
        }
        return Math.abs(hash(value));
      });
    }
    nextRange(min4, max6) {
      return map9(this.next, (n) => (max6 - min4) * n + min4);
    }
    nextIntBetween(min4, max6) {
      return sync(() => {
        const value = this.getNextValue();
        if (typeof value === "number" && Number.isFinite(value)) {
          return Math.max(min4, Math.min(max6 - 1, Math.round(value)));
        }
        const hash2 = Math.abs(hash(value));
        return min4 + hash2 % (max6 - min4);
      });
    }
    shuffle(elements) {
      return shuffleWith(elements, (n) => this.nextIntBetween(0, n));
    }
  };
  var fixed = (values3) => new FixedRandomImpl(values3);

  // <eztb>/node_modules/effect/dist/esm/internal/tracer.js
  var TracerTypeId = /* @__PURE__ */ Symbol.for("effect/Tracer");
  var make23 = (options) => ({
    [TracerTypeId]: TracerTypeId,
    ...options
  });
  var tracerTag = /* @__PURE__ */ GenericTag("effect/Tracer");
  var spanTag = /* @__PURE__ */ GenericTag("effect/ParentSpan");
  var randomHexString = /* @__PURE__ */ (function() {
    const characters = "abcdef0123456789";
    const charactersLength = characters.length;
    return function(length2) {
      let result = "";
      for (let i = 0; i < length2; i++) {
        result += characters.charAt(Math.floor(Math.random() * charactersLength));
      }
      return result;
    };
  })();
  var NativeSpan = class {
    constructor(name, parent, context4, links, startTime, kind) {
      __publicField(this, "name");
      __publicField(this, "parent");
      __publicField(this, "context");
      __publicField(this, "startTime");
      __publicField(this, "kind");
      __publicField(this, "_tag", "Span");
      __publicField(this, "spanId");
      __publicField(this, "traceId", "native");
      __publicField(this, "sampled", true);
      __publicField(this, "status");
      __publicField(this, "attributes");
      __publicField(this, "events", []);
      __publicField(this, "links");
      this.name = name;
      this.parent = parent;
      this.context = context4;
      this.startTime = startTime;
      this.kind = kind;
      this.status = {
        _tag: "Started",
        startTime
      };
      this.attributes = /* @__PURE__ */ new Map();
      this.traceId = parent._tag === "Some" ? parent.value.traceId : randomHexString(32);
      this.spanId = randomHexString(16);
      this.links = Array.from(links);
    }
    end(endTime, exit4) {
      this.status = {
        _tag: "Ended",
        endTime,
        exit: exit4,
        startTime: this.status.startTime
      };
    }
    attribute(key, value) {
      this.attributes.set(key, value);
    }
    event(name, startTime, attributes) {
      this.events.push([name, startTime, attributes ?? {}]);
    }
    addLinks(links) {
      this.links.push(...links);
    }
  };
  var nativeTracer = /* @__PURE__ */ make23({
    span: (name, parent, context4, links, startTime, kind) => new NativeSpan(name, parent, context4, links, startTime, kind),
    context: (f) => f()
  });
  var addSpanStackTrace = (options) => {
    if (options?.captureStackTrace === false) {
      return options;
    } else if (options?.captureStackTrace !== void 0 && typeof options.captureStackTrace !== "boolean") {
      return options;
    }
    const limit = Error.stackTraceLimit;
    Error.stackTraceLimit = 3;
    const traceError = new Error();
    Error.stackTraceLimit = limit;
    let cache7 = false;
    return {
      ...options,
      captureStackTrace: () => {
        if (cache7 !== false) {
          return cache7;
        }
        if (traceError.stack !== void 0) {
          const stack = traceError.stack.split("\n");
          if (stack[3] !== void 0) {
            cache7 = stack[3].trim();
            return cache7;
          }
        }
      }
    };
  };
  var DisablePropagation = /* @__PURE__ */ Reference2()("effect/Tracer/DisablePropagation", {
    defaultValue: constFalse
  });

  // <eztb>/node_modules/effect/dist/esm/internal/defaultServices.js
  var liveServices = /* @__PURE__ */ pipe(/* @__PURE__ */ empty3(), /* @__PURE__ */ add2(clockTag, /* @__PURE__ */ make19()), /* @__PURE__ */ add2(consoleTag, defaultConsole), /* @__PURE__ */ add2(randomTag, /* @__PURE__ */ make22(/* @__PURE__ */ Math.random())), /* @__PURE__ */ add2(configProviderTag, /* @__PURE__ */ fromEnv()), /* @__PURE__ */ add2(tracerTag, nativeTracer));
  var currentServices = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/DefaultServices/currentServices"), () => fiberRefUnsafeMakeContext(liveServices));
  var sleep = (duration3) => {
    const decodedDuration = decode(duration3);
    return clockWith((clock3) => clock3.sleep(decodedDuration));
  };
  var defaultServicesWith = (f) => withFiberRuntime((fiber) => f(fiber.currentDefaultServices));
  var clockWith = (f) => defaultServicesWith((services) => f(services.unsafeMap.get(clockTag.key)));
  var currentTimeMillis = /* @__PURE__ */ clockWith((clock3) => clock3.currentTimeMillis);
  var currentTimeNanos = /* @__PURE__ */ clockWith((clock3) => clock3.currentTimeNanos);
  var withClock = /* @__PURE__ */ dual(2, (effect, c) => fiberRefLocallyWith(currentServices, add2(clockTag, c))(effect));
  var withConfigProvider = /* @__PURE__ */ dual(2, (self, provider) => fiberRefLocallyWith(currentServices, add2(configProviderTag, provider))(self));
  var configProviderWith = (f) => defaultServicesWith((services) => f(services.unsafeMap.get(configProviderTag.key)));
  var randomWith = (f) => defaultServicesWith((services) => f(services.unsafeMap.get(randomTag.key)));
  var withRandom = /* @__PURE__ */ dual(2, (effect, value) => fiberRefLocallyWith(currentServices, add2(randomTag, value))(effect));
  var next = /* @__PURE__ */ randomWith((random4) => random4.next);
  var tracerWith = (f) => defaultServicesWith((services) => f(services.unsafeMap.get(tracerTag.key)));
  var withTracer = /* @__PURE__ */ dual(2, (effect, value) => fiberRefLocallyWith(currentServices, add2(tracerTag, value))(effect));

  // <eztb>/node_modules/effect/dist/esm/Clock.js
  var sleep2 = sleep;
  var currentTimeMillis2 = currentTimeMillis;
  var currentTimeNanos2 = currentTimeNanos;
  var clockWith2 = clockWith;
  var Clock = clockTag;

  // <eztb>/node_modules/effect/dist/esm/internal/fiberRefs.js
  function unsafeMake4(fiberRefLocals) {
    return new FiberRefsImpl(fiberRefLocals);
  }
  function empty20() {
    return unsafeMake4(/* @__PURE__ */ new Map());
  }
  var FiberRefsSym = /* @__PURE__ */ Symbol.for("effect/FiberRefs");
  var _a15;
  _a15 = FiberRefsSym;
  var FiberRefsImpl = class {
    constructor(locals) {
      __publicField(this, "locals");
      __publicField(this, _a15, FiberRefsSym);
      this.locals = locals;
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var findAncestor = (_ref, _parentStack, _childStack, _childModified = false) => {
    const ref = _ref;
    let parentStack = _parentStack;
    let childStack = _childStack;
    let childModified = _childModified;
    let ret = void 0;
    while (ret === void 0) {
      if (isNonEmptyReadonlyArray(parentStack) && isNonEmptyReadonlyArray(childStack)) {
        const parentFiberId = headNonEmpty(parentStack)[0];
        const parentAncestors = tailNonEmpty(parentStack);
        const childFiberId = headNonEmpty(childStack)[0];
        const childRefValue = headNonEmpty(childStack)[1];
        const childAncestors = tailNonEmpty(childStack);
        if (parentFiberId.startTimeMillis < childFiberId.startTimeMillis) {
          childStack = childAncestors;
          childModified = true;
        } else if (parentFiberId.startTimeMillis > childFiberId.startTimeMillis) {
          parentStack = parentAncestors;
        } else {
          if (parentFiberId.id < childFiberId.id) {
            childStack = childAncestors;
            childModified = true;
          } else if (parentFiberId.id > childFiberId.id) {
            parentStack = parentAncestors;
          } else {
            ret = [childRefValue, childModified];
          }
        }
      } else {
        ret = [ref.initial, true];
      }
    }
    return ret;
  };
  var joinAs = /* @__PURE__ */ dual(3, (self, fiberId3, that) => {
    const parentFiberRefs = new Map(self.locals);
    that.locals.forEach((childStack, fiberRef) => {
      const childValue = childStack[0][1];
      if (!childStack[0][0][symbol2](fiberId3)) {
        if (!parentFiberRefs.has(fiberRef)) {
          if (equals(childValue, fiberRef.initial)) {
            return;
          }
          parentFiberRefs.set(fiberRef, [[fiberId3, fiberRef.join(fiberRef.initial, childValue)]]);
          return;
        }
        const parentStack = parentFiberRefs.get(fiberRef);
        const [ancestor, wasModified] = findAncestor(fiberRef, parentStack, childStack);
        if (wasModified) {
          const patch9 = fiberRef.diff(ancestor, childValue);
          const oldValue = parentStack[0][1];
          const newValue = fiberRef.join(oldValue, fiberRef.patch(patch9)(oldValue));
          if (!equals(oldValue, newValue)) {
            let newStack;
            const parentFiberId = parentStack[0][0];
            if (parentFiberId[symbol2](fiberId3)) {
              newStack = [[parentFiberId, newValue], ...parentStack.slice(1)];
            } else {
              newStack = [[fiberId3, newValue], ...parentStack];
            }
            parentFiberRefs.set(fiberRef, newStack);
          }
        }
      }
    });
    return new FiberRefsImpl(parentFiberRefs);
  });
  var forkAs = /* @__PURE__ */ dual(2, (self, childId) => {
    const map14 = /* @__PURE__ */ new Map();
    unsafeForkAs(self, map14, childId);
    return new FiberRefsImpl(map14);
  });
  var unsafeForkAs = (self, map14, fiberId3) => {
    self.locals.forEach((stack, fiberRef) => {
      const oldValue = stack[0][1];
      const newValue = fiberRef.patch(fiberRef.fork)(oldValue);
      if (equals(oldValue, newValue)) {
        map14.set(fiberRef, stack);
      } else {
        map14.set(fiberRef, [[fiberId3, newValue], ...stack]);
      }
    });
  };
  var fiberRefs = (self) => fromIterable5(self.locals.keys());
  var setAll = (self) => forEachSequentialDiscard(fiberRefs(self), (fiberRef) => fiberRefSet(fiberRef, getOrDefault(self, fiberRef)));
  var delete_ = /* @__PURE__ */ dual(2, (self, fiberRef) => {
    const locals = new Map(self.locals);
    locals.delete(fiberRef);
    return new FiberRefsImpl(locals);
  });
  var get9 = /* @__PURE__ */ dual(2, (self, fiberRef) => {
    if (!self.locals.has(fiberRef)) {
      return none2();
    }
    return some2(headNonEmpty(self.locals.get(fiberRef))[1]);
  });
  var getOrDefault = /* @__PURE__ */ dual(2, (self, fiberRef) => pipe(get9(self, fiberRef), getOrElse2(() => fiberRef.initial)));
  var updateAs = /* @__PURE__ */ dual(2, (self, {
    fiberId: fiberId3,
    fiberRef,
    value
  }) => {
    if (self.locals.size === 0) {
      return new FiberRefsImpl(/* @__PURE__ */ new Map([[fiberRef, [[fiberId3, value]]]]));
    }
    const locals = new Map(self.locals);
    unsafeUpdateAs(locals, fiberId3, fiberRef, value);
    return new FiberRefsImpl(locals);
  });
  var unsafeUpdateAs = (locals, fiberId3, fiberRef, value) => {
    const oldStack = locals.get(fiberRef) ?? [];
    let newStack;
    if (isNonEmptyReadonlyArray(oldStack)) {
      const [currentId, currentValue] = headNonEmpty(oldStack);
      if (currentId[symbol2](fiberId3)) {
        if (equals(currentValue, value)) {
          return;
        } else {
          newStack = [[fiberId3, value], ...oldStack.slice(1)];
        }
      } else {
        newStack = [[fiberId3, value], ...oldStack];
      }
    } else {
      newStack = [[fiberId3, value]];
    }
    locals.set(fiberRef, newStack);
  };
  var updateManyAs = /* @__PURE__ */ dual(2, (self, {
    entries: entries2,
    forkAs: forkAs2
  }) => {
    if (self.locals.size === 0) {
      return new FiberRefsImpl(new Map(entries2));
    }
    const locals = new Map(self.locals);
    if (forkAs2 !== void 0) {
      unsafeForkAs(self, locals, forkAs2);
    }
    entries2.forEach(([fiberRef, values3]) => {
      if (values3.length === 1) {
        unsafeUpdateAs(locals, values3[0][0], fiberRef, values3[0][1]);
      } else {
        values3.forEach(([fiberId3, value]) => {
          unsafeUpdateAs(locals, fiberId3, fiberRef, value);
        });
      }
    });
    return new FiberRefsImpl(locals);
  });

  // <eztb>/node_modules/effect/dist/esm/FiberRefs.js
  var get10 = get9;
  var getOrDefault2 = getOrDefault;
  var joinAs2 = joinAs;
  var setAll2 = setAll;
  var updateManyAs2 = updateManyAs;
  var empty21 = empty20;

  // <eztb>/node_modules/effect/dist/esm/LogLevel.js
  var All = logLevelAll;
  var Fatal = logLevelFatal;
  var Error2 = logLevelError;
  var Warning = logLevelWarning;
  var Info = logLevelInfo;
  var Debug = logLevelDebug;
  var Trace = logLevelTrace;
  var None3 = logLevelNone;
  var Order3 = /* @__PURE__ */ pipe(Order, /* @__PURE__ */ mapInput2((level) => level.ordinal));
  var greaterThan3 = /* @__PURE__ */ greaterThan(Order3);
  var fromLiteral = (literal) => {
    switch (literal) {
      case "All":
        return All;
      case "Debug":
        return Debug;
      case "Error":
        return Error2;
      case "Fatal":
        return Fatal;
      case "Info":
        return Info;
      case "Trace":
        return Trace;
      case "None":
        return None3;
      case "Warning":
        return Warning;
    }
  };

  // <eztb>/node_modules/effect/dist/esm/internal/logSpan.js
  var make24 = (label, startTime) => ({
    label,
    startTime
  });
  var formatLabel = (key) => key.replace(/[\s="]/g, "_");
  var render = (now) => (self) => {
    const label = formatLabel(self.label);
    return `${label}=${now - self.startTime}ms`;
  };

  // <eztb>/node_modules/effect/dist/esm/LogSpan.js
  var make25 = make24;

  // <eztb>/node_modules/effect/dist/esm/Effectable.js
  var EffectPrototype2 = EffectPrototype;
  var CommitPrototype2 = CommitPrototype;
  var Base2 = Base;
  var Class2 = class extends Base2 {
  };

  // <eztb>/node_modules/effect/dist/esm/Readable.js
  var TypeId13 = /* @__PURE__ */ Symbol.for("effect/Readable");
  var Proto = {
    [TypeId13]: TypeId13,
    pipe() {
      return pipeArguments(this, arguments);
    }
  };

  // <eztb>/node_modules/effect/dist/esm/internal/ref.js
  var RefTypeId = /* @__PURE__ */ Symbol.for("effect/Ref");
  var refVariance = {
    /* c8 ignore next */
    _A: (_) => _
  };
  var _a16, _b, _c;
  var RefImpl = class extends (_c = Class2, _b = RefTypeId, _a16 = TypeId13, _c) {
    constructor(ref) {
      super();
      __publicField(this, "ref");
      __publicField(this, _b, refVariance);
      __publicField(this, _a16, TypeId13);
      __publicField(this, "get");
      this.ref = ref;
      this.get = sync(() => get6(this.ref));
    }
    commit() {
      return this.get;
    }
    modify(f) {
      return sync(() => {
        const current = get6(this.ref);
        const [b, a] = f(current);
        if (current !== a) {
          set2(a)(this.ref);
        }
        return b;
      });
    }
  };
  var unsafeMake5 = (value) => new RefImpl(make11(value));
  var make26 = (value) => sync(() => unsafeMake5(value));
  var get11 = (self) => self.get;
  var set5 = /* @__PURE__ */ dual(2, (self, value) => self.modify(() => [void 0, value]));
  var getAndSet = /* @__PURE__ */ dual(2, (self, value) => self.modify((a) => [a, value]));
  var modify3 = /* @__PURE__ */ dual(2, (self, f) => self.modify(f));
  var update2 = /* @__PURE__ */ dual(2, (self, f) => self.modify((a) => [void 0, f(a)]));

  // <eztb>/node_modules/effect/dist/esm/Ref.js
  var make27 = make26;
  var get12 = get11;
  var getAndSet2 = getAndSet;
  var update3 = update2;

  // <eztb>/node_modules/effect/dist/esm/Tracer.js
  var tracerWith2 = tracerWith;

  // <eztb>/node_modules/effect/dist/esm/internal/fiberRefs/patch.js
  var OP_EMPTY2 = "Empty";
  var OP_ADD = "Add";
  var OP_REMOVE = "Remove";
  var OP_UPDATE = "Update";
  var OP_AND_THEN = "AndThen";
  var empty22 = {
    _tag: OP_EMPTY2
  };
  var diff5 = (oldValue, newValue) => {
    const missingLocals = new Map(oldValue.locals);
    let patch9 = empty22;
    for (const [fiberRef, pairs] of newValue.locals.entries()) {
      const newValue2 = headNonEmpty(pairs)[1];
      const old = missingLocals.get(fiberRef);
      if (old !== void 0) {
        const oldValue2 = headNonEmpty(old)[1];
        if (!equals(oldValue2, newValue2)) {
          patch9 = combine7({
            _tag: OP_UPDATE,
            fiberRef,
            patch: fiberRef.diff(oldValue2, newValue2)
          })(patch9);
        }
      } else {
        patch9 = combine7({
          _tag: OP_ADD,
          fiberRef,
          value: newValue2
        })(patch9);
      }
      missingLocals.delete(fiberRef);
    }
    for (const [fiberRef] of missingLocals.entries()) {
      patch9 = combine7({
        _tag: OP_REMOVE,
        fiberRef
      })(patch9);
    }
    return patch9;
  };
  var combine7 = /* @__PURE__ */ dual(2, (self, that) => ({
    _tag: OP_AND_THEN,
    first: self,
    second: that
  }));
  var patch6 = /* @__PURE__ */ dual(3, (self, fiberId3, oldValue) => {
    let fiberRefs3 = oldValue;
    let patches = of(self);
    while (isNonEmptyReadonlyArray(patches)) {
      const head5 = headNonEmpty(patches);
      const tail = tailNonEmpty(patches);
      switch (head5._tag) {
        case OP_EMPTY2: {
          patches = tail;
          break;
        }
        case OP_ADD: {
          fiberRefs3 = updateAs(fiberRefs3, {
            fiberId: fiberId3,
            fiberRef: head5.fiberRef,
            value: head5.value
          });
          patches = tail;
          break;
        }
        case OP_REMOVE: {
          fiberRefs3 = delete_(fiberRefs3, head5.fiberRef);
          patches = tail;
          break;
        }
        case OP_UPDATE: {
          const value = getOrDefault(fiberRefs3, head5.fiberRef);
          fiberRefs3 = updateAs(fiberRefs3, {
            fiberId: fiberId3,
            fiberRef: head5.fiberRef,
            value: head5.fiberRef.patch(head5.patch)(value)
          });
          patches = tail;
          break;
        }
        case OP_AND_THEN: {
          patches = prepend(head5.first)(prepend(head5.second)(tail));
          break;
        }
      }
    }
    return fiberRefs3;
  });

  // <eztb>/node_modules/effect/dist/esm/internal/metric/label.js
  var MetricLabelSymbolKey = "effect/MetricLabel";
  var MetricLabelTypeId = /* @__PURE__ */ Symbol.for(MetricLabelSymbolKey);
  var _a17;
  var MetricLabelImpl = class {
    constructor(key, value) {
      __publicField(this, "key");
      __publicField(this, "value");
      __publicField(this, _a17, MetricLabelTypeId);
      __publicField(this, "_hash");
      this.key = key;
      this.value = value;
      this._hash = string(MetricLabelSymbolKey + this.key + this.value);
    }
    [(_a17 = MetricLabelTypeId, symbol)]() {
      return this._hash;
    }
    [symbol2](that) {
      return isMetricLabel(that) && this.key === that.key && this.value === that.value;
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var make28 = (key, value) => {
    return new MetricLabelImpl(key, value);
  };
  var isMetricLabel = (u) => hasProperty(u, MetricLabelTypeId);

  // <eztb>/node_modules/effect/dist/esm/internal/core-effect.js
  var annotateLogs = /* @__PURE__ */ dual((args2) => isEffect(args2[0]), function() {
    const args2 = arguments;
    return fiberRefLocallyWith(args2[0], currentLogAnnotations, typeof args2[1] === "string" ? set3(args2[1], args2[2]) : (annotations) => Object.entries(args2[1]).reduce((acc, [key, value]) => set3(acc, key, value), annotations));
  });
  var asSome = (self) => map9(self, some2);
  var asSomeError = (self) => mapError(self, some2);
  var try_2 = (arg) => {
    let evaluate2;
    let onFailure = void 0;
    if (typeof arg === "function") {
      evaluate2 = arg;
    } else {
      evaluate2 = arg.try;
      onFailure = arg.catch;
    }
    return suspend(() => {
      try {
        return succeed(internalCall(evaluate2));
      } catch (error) {
        return fail2(onFailure ? internalCall(() => onFailure(error)) : new UnknownException(error, "An unknown error occurred in Effect.try"));
      }
    });
  };
  var _catch = /* @__PURE__ */ dual(3, (self, tag, options) => catchAll(self, (e) => {
    if (hasProperty(e, tag) && e[tag] === options.failure) {
      return options.onFailure(e);
    }
    return fail2(e);
  }));
  var catchAllDefect = /* @__PURE__ */ dual(2, (self, f) => catchAllCause(self, (cause3) => {
    const option3 = find(cause3, (_) => isDieType(_) ? some2(_) : none2());
    switch (option3._tag) {
      case "None": {
        return failCause(cause3);
      }
      case "Some": {
        return f(option3.value.defect);
      }
    }
  }));
  var catchSomeCause = /* @__PURE__ */ dual(2, (self, f) => matchCauseEffect(self, {
    onFailure: (cause3) => {
      const option3 = f(cause3);
      switch (option3._tag) {
        case "None": {
          return failCause(cause3);
        }
        case "Some": {
          return option3.value;
        }
      }
    },
    onSuccess: succeed
  }));
  var catchSomeDefect = /* @__PURE__ */ dual(2, (self, pf) => catchAllCause(self, (cause3) => {
    const option3 = find(cause3, (_) => isDieType(_) ? some2(_) : none2());
    switch (option3._tag) {
      case "None": {
        return failCause(cause3);
      }
      case "Some": {
        const optionEffect = pf(option3.value.defect);
        return optionEffect._tag === "Some" ? optionEffect.value : failCause(cause3);
      }
    }
  }));
  var catchTag = /* @__PURE__ */ dual((args2) => isEffect(args2[0]), (self, ...args2) => {
    const f = args2[args2.length - 1];
    let predicate;
    if (args2.length === 2) {
      predicate = isTagged(args2[0]);
    } else {
      predicate = (e) => {
        const tag = hasProperty(e, "_tag") ? e["_tag"] : void 0;
        if (!tag) return false;
        for (let i = 0; i < args2.length - 1; i++) {
          if (args2[i] === tag) return true;
        }
        return false;
      };
    }
    return catchIf(self, predicate, f);
  });
  var catchTags = /* @__PURE__ */ dual(2, (self, cases) => {
    let keys5;
    return catchIf(self, (e) => {
      keys5 ?? (keys5 = Object.keys(cases));
      return hasProperty(e, "_tag") && isString(e["_tag"]) && keys5.includes(e["_tag"]);
    }, (e) => cases[e["_tag"]](e));
  });
  var cause = (self) => matchCause(self, {
    onFailure: identity,
    onSuccess: () => empty16
  });
  var clockWith3 = clockWith2;
  var clock = /* @__PURE__ */ clockWith3(succeed);
  var delay = /* @__PURE__ */ dual(2, (self, duration3) => zipRight(sleep2(duration3), self));
  var descriptorWith = (f) => withFiberRuntime((state, status) => f({
    id: state.id(),
    status,
    interruptors: interruptors(state.getFiberRef(currentInterruptedCause))
  }));
  var allowInterrupt = /* @__PURE__ */ descriptorWith((descriptor3) => size3(descriptor3.interruptors) > 0 ? interrupt2 : void_2);
  var descriptor = /* @__PURE__ */ descriptorWith(succeed);
  var diffFiberRefs = (self) => summarized(self, fiberRefs2, diff5);
  var diffFiberRefsAndRuntimeFlags = (self) => summarized(self, zip2(fiberRefs2, runtimeFlags), ([refs, flags], [refsNew, flagsNew]) => [diff5(refs, refsNew), diff4(flags, flagsNew)]);
  var Do2 = /* @__PURE__ */ succeed({});
  var bind3 = /* @__PURE__ */ bind(map9, flatMap8);
  var bindTo3 = /* @__PURE__ */ bindTo(map9);
  var let_3 = /* @__PURE__ */ let_(map9);
  var dropUntil = /* @__PURE__ */ dual(2, (elements, predicate) => suspend(() => {
    const iterator = elements[Symbol.iterator]();
    const builder = [];
    let next4;
    let dropping = succeed(false);
    let i = 0;
    while ((next4 = iterator.next()) && !next4.done) {
      const a = next4.value;
      const index = i++;
      dropping = flatMap8(dropping, (bool) => {
        if (bool) {
          builder.push(a);
          return succeed(true);
        }
        return predicate(a, index);
      });
    }
    return map9(dropping, () => builder);
  }));
  var dropWhile = /* @__PURE__ */ dual(2, (elements, predicate) => suspend(() => {
    const iterator = elements[Symbol.iterator]();
    const builder = [];
    let next4;
    let dropping = succeed(true);
    let i = 0;
    while ((next4 = iterator.next()) && !next4.done) {
      const a = next4.value;
      const index = i++;
      dropping = flatMap8(dropping, (d) => map9(d ? predicate(a, index) : succeed(false), (b) => {
        if (!b) {
          builder.push(a);
        }
        return b;
      }));
    }
    return map9(dropping, () => builder);
  }));
  var contextWith = (f) => map9(context(), f);
  var eventually = (self) => orElse2(self, () => flatMap8(yieldNow(), () => eventually(self)));
  var filterMap3 = /* @__PURE__ */ dual(2, (elements, pf) => map9(forEachSequential(elements, identity), filterMap(pf)));
  var filterOrDie = /* @__PURE__ */ dual(3, (self, predicate, orDieWith3) => filterOrElse(self, predicate, (a) => dieSync(() => orDieWith3(a))));
  var filterOrDieMessage = /* @__PURE__ */ dual(3, (self, predicate, message) => filterOrElse(self, predicate, () => dieMessage(message)));
  var filterOrElse = /* @__PURE__ */ dual(3, (self, predicate, orElse4) => flatMap8(self, (a) => predicate(a) ? succeed(a) : orElse4(a)));
  var liftPredicate2 = /* @__PURE__ */ dual(3, (self, predicate, orFailWith) => suspend(() => predicate(self) ? succeed(self) : fail2(orFailWith(self))));
  var filterOrFail = /* @__PURE__ */ dual((args2) => isEffect(args2[0]), (self, predicate, orFailWith) => filterOrElse(self, predicate, (a) => orFailWith === void 0 ? fail2(new NoSuchElementException()) : failSync(() => orFailWith(a))));
  var findFirst3 = /* @__PURE__ */ dual(2, (elements, predicate) => suspend(() => {
    const iterator = elements[Symbol.iterator]();
    const next4 = iterator.next();
    if (!next4.done) {
      return findLoop(iterator, 0, predicate, next4.value);
    }
    return succeed(none2());
  }));
  var findLoop = (iterator, index, f, value) => flatMap8(f(value, index), (result) => {
    if (result) {
      return succeed(some2(value));
    }
    const next4 = iterator.next();
    if (!next4.done) {
      return findLoop(iterator, index + 1, f, next4.value);
    }
    return succeed(none2());
  });
  var firstSuccessOf = (effects) => suspend(() => {
    const list = fromIterable2(effects);
    if (!isNonEmpty(list)) {
      return dieSync(() => new IllegalArgumentException(`Received an empty collection of effects`));
    }
    return pipe(tailNonEmpty2(list), reduce(headNonEmpty2(list), (left3, right3) => orElse2(left3, () => right3)));
  });
  var flipWith = /* @__PURE__ */ dual(2, (self, f) => flip2(f(flip2(self))));
  var match6 = /* @__PURE__ */ dual(2, (self, options) => matchEffect(self, {
    onFailure: (e) => succeed(options.onFailure(e)),
    onSuccess: (a) => succeed(options.onSuccess(a))
  }));
  var every4 = /* @__PURE__ */ dual(2, (elements, predicate) => suspend(() => forAllLoop(elements[Symbol.iterator](), 0, predicate)));
  var forAllLoop = (iterator, index, f) => {
    const next4 = iterator.next();
    return next4.done ? succeed(true) : flatMap8(f(next4.value, index), (b) => b ? forAllLoop(iterator, index + 1, f) : succeed(b));
  };
  var forever = (self) => {
    const loop3 = flatMap8(flatMap8(self, () => yieldNow()), () => loop3);
    return loop3;
  };
  var fiberRefs2 = /* @__PURE__ */ withFiberRuntime((state) => succeed(state.getFiberRefs()));
  var head3 = (self) => flatMap8(self, (as6) => {
    const iterator = as6[Symbol.iterator]();
    const next4 = iterator.next();
    if (next4.done) {
      return fail2(new NoSuchElementException());
    }
    return succeed(next4.value);
  });
  var ignore = (self) => match6(self, {
    onFailure: constVoid,
    onSuccess: constVoid
  });
  var ignoreLogged = (self) => matchCauseEffect(self, {
    onFailure: (cause3) => logDebug(cause3, "An error was silently ignored because it is not anticipated to be useful"),
    onSuccess: () => void_2
  });
  var inheritFiberRefs = (childFiberRefs) => updateFiberRefs((parentFiberId, parentFiberRefs) => joinAs2(parentFiberRefs, parentFiberId, childFiberRefs));
  var isFailure = (self) => match6(self, {
    onFailure: constTrue,
    onSuccess: constFalse
  });
  var isSuccess = (self) => match6(self, {
    onFailure: constFalse,
    onSuccess: constTrue
  });
  var iterate = (initial, options) => suspend(() => {
    if (options.while(initial)) {
      return flatMap8(options.body(initial), (z2) => iterate(z2, options));
    }
    return succeed(initial);
  });
  var logWithLevel = (level) => (...message) => {
    const levelOption = fromNullable2(level);
    let cause3 = void 0;
    for (let i = 0, len = message.length; i < len; i++) {
      const msg = message[i];
      if (isCause(msg)) {
        if (cause3 !== void 0) {
          cause3 = sequential(cause3, msg);
        } else {
          cause3 = msg;
        }
        message = [...message.slice(0, i), ...message.slice(i + 1)];
        i--;
      }
    }
    if (cause3 === void 0) {
      cause3 = empty16;
    }
    return withFiberRuntime((fiberState) => {
      fiberState.log(message, cause3, levelOption);
      return void_2;
    });
  };
  var log2 = /* @__PURE__ */ logWithLevel();
  var logTrace = /* @__PURE__ */ logWithLevel(Trace);
  var logDebug = /* @__PURE__ */ logWithLevel(Debug);
  var logInfo = /* @__PURE__ */ logWithLevel(Info);
  var logWarning = /* @__PURE__ */ logWithLevel(Warning);
  var logError = /* @__PURE__ */ logWithLevel(Error2);
  var logFatal = /* @__PURE__ */ logWithLevel(Fatal);
  var withLogSpan = /* @__PURE__ */ dual(2, (effect, label) => flatMap8(currentTimeMillis2, (now) => fiberRefLocallyWith(effect, currentLogSpan, prepend3(make25(label, now)))));
  var logAnnotations = /* @__PURE__ */ fiberRefGet(currentLogAnnotations);
  var loop = (initial, options) => options.discard ? loopDiscard(initial, options.while, options.step, options.body) : map9(loopInternal(initial, options.while, options.step, options.body), fromIterable);
  var loopInternal = (initial, cont, inc, body) => suspend(() => cont(initial) ? flatMap8(body(initial), (a) => map9(loopInternal(inc(initial), cont, inc, body), prepend3(a))) : sync(() => empty9()));
  var loopDiscard = (initial, cont, inc, body) => suspend(() => cont(initial) ? flatMap8(body(initial), () => loopDiscard(inc(initial), cont, inc, body)) : void_2);
  var mapAccum2 = /* @__PURE__ */ dual(3, (elements, initial, f) => suspend(() => {
    const iterator = elements[Symbol.iterator]();
    const builder = [];
    let result = succeed(initial);
    let next4;
    let i = 0;
    while (!(next4 = iterator.next()).done) {
      const index = i++;
      const value = next4.value;
      result = flatMap8(result, (state) => map9(f(state, value, index), ([z, b]) => {
        builder.push(b);
        return z;
      }));
    }
    return map9(result, (z) => [z, builder]);
  }));
  var mapErrorCause = /* @__PURE__ */ dual(2, (self, f) => matchCauseEffect(self, {
    onFailure: (c) => failCauseSync(() => f(c)),
    onSuccess: succeed
  }));
  var memoize = (self) => pipe(deferredMake(), flatMap8((deferred) => pipe(diffFiberRefsAndRuntimeFlags(self), intoDeferred(deferred), once, map9((complete3) => zipRight(complete3, pipe(deferredAwait(deferred), flatMap8(([patch9, a]) => as(zip2(patchFiberRefs(patch9[0]), updateRuntimeFlags(patch9[1])), a))))))));
  var merge5 = (self) => matchEffect(self, {
    onFailure: (e) => succeed(e),
    onSuccess: succeed
  });
  var negate = (self) => map9(self, (b) => !b);
  var none6 = (self) => flatMap8(self, (option3) => {
    switch (option3._tag) {
      case "None":
        return void_2;
      case "Some":
        return fail2(new NoSuchElementException());
    }
  });
  var once = (self) => map9(make27(true), (ref) => asVoid(whenEffect(self, getAndSet2(ref, false))));
  var option = (self) => matchEffect(self, {
    onFailure: () => succeed(none2()),
    onSuccess: (a) => succeed(some2(a))
  });
  var orElseFail = /* @__PURE__ */ dual(2, (self, evaluate2) => orElse2(self, () => failSync(evaluate2)));
  var orElseSucceed = /* @__PURE__ */ dual(2, (self, evaluate2) => orElse2(self, () => sync(evaluate2)));
  var parallelErrors = (self) => matchCauseEffect(self, {
    onFailure: (cause3) => {
      const errors = fromIterable(failures(cause3));
      return errors.length === 0 ? failCause(cause3) : fail2(errors);
    },
    onSuccess: succeed
  });
  var patchFiberRefs = (patch9) => updateFiberRefs((fiberId3, fiberRefs3) => pipe(patch9, patch6(fiberId3, fiberRefs3)));
  var promise = (evaluate2) => evaluate2.length >= 1 ? async_((resolve, signal) => {
    try {
      evaluate2(signal).then((a) => resolve(succeed(a)), (e) => resolve(die2(e)));
    } catch (e) {
      resolve(die2(e));
    }
  }) : async_((resolve) => {
    try {
      ;
      evaluate2().then((a) => resolve(succeed(a)), (e) => resolve(die2(e)));
    } catch (e) {
      resolve(die2(e));
    }
  });
  var provideService = /* @__PURE__ */ dual(3, (self, tag, service) => contextWithEffect((env) => provideContext(self, add2(env, tag, service))));
  var provideServiceEffect = /* @__PURE__ */ dual(3, (self, tag, effect) => contextWithEffect((env) => flatMap8(effect, (service) => provideContext(self, pipe(env, add2(tag, service))))));
  var random2 = /* @__PURE__ */ randomWith(succeed);
  var reduce8 = /* @__PURE__ */ dual(3, (elements, zero2, f) => fromIterable(elements).reduce((acc, el, i) => flatMap8(acc, (a) => f(a, el, i)), succeed(zero2)));
  var reduceRight2 = /* @__PURE__ */ dual(3, (elements, zero2, f) => fromIterable(elements).reduceRight((acc, el, i) => flatMap8(acc, (a) => f(el, a, i)), succeed(zero2)));
  var reduceWhile = /* @__PURE__ */ dual(3, (elements, zero2, options) => flatMap8(sync(() => elements[Symbol.iterator]()), (iterator) => reduceWhileLoop(iterator, 0, zero2, options.while, options.body)));
  var reduceWhileLoop = (iterator, index, state, predicate, f) => {
    const next4 = iterator.next();
    if (!next4.done && predicate(state)) {
      return flatMap8(f(state, next4.value, index), (nextState) => reduceWhileLoop(iterator, index + 1, nextState, predicate, f));
    }
    return succeed(state);
  };
  var repeatN = /* @__PURE__ */ dual(2, (self, n) => suspend(() => repeatNLoop(self, n)));
  var repeatNLoop = (self, n) => flatMap8(self, (a) => n <= 0 ? succeed(a) : zipRight(yieldNow(), repeatNLoop(self, n - 1)));
  var sandbox = (self) => matchCauseEffect(self, {
    onFailure: fail2,
    onSuccess: succeed
  });
  var setFiberRefs = (fiberRefs3) => suspend(() => setAll2(fiberRefs3));
  var sleep3 = sleep2;
  var succeedNone = /* @__PURE__ */ succeed(/* @__PURE__ */ none2());
  var succeedSome = (value) => succeed(some2(value));
  var summarized = /* @__PURE__ */ dual(3, (self, summary5, f) => flatMap8(summary5, (start3) => flatMap8(self, (value) => map9(summary5, (end3) => [f(start3, end3), value]))));
  var tagMetrics = /* @__PURE__ */ dual((args2) => isEffect(args2[0]), function() {
    return labelMetrics(arguments[0], typeof arguments[1] === "string" ? [make28(arguments[1], arguments[2])] : Object.entries(arguments[1]).map(([k, v]) => make28(k, v)));
  });
  var labelMetrics = /* @__PURE__ */ dual(2, (self, labels) => fiberRefLocallyWith(self, currentMetricLabels, (old) => union(old, labels)));
  var takeUntil = /* @__PURE__ */ dual(2, (elements, predicate) => suspend(() => {
    const iterator = elements[Symbol.iterator]();
    const builder = [];
    let next4;
    let effect = succeed(false);
    let i = 0;
    while ((next4 = iterator.next()) && !next4.done) {
      const a = next4.value;
      const index = i++;
      effect = flatMap8(effect, (bool) => {
        if (bool) {
          return succeed(true);
        }
        builder.push(a);
        return predicate(a, index);
      });
    }
    return map9(effect, () => builder);
  }));
  var takeWhile = /* @__PURE__ */ dual(2, (elements, predicate) => suspend(() => {
    const iterator = elements[Symbol.iterator]();
    const builder = [];
    let next4;
    let taking = succeed(true);
    let i = 0;
    while ((next4 = iterator.next()) && !next4.done) {
      const a = next4.value;
      const index = i++;
      taking = flatMap8(taking, (taking2) => pipe(taking2 ? predicate(a, index) : succeed(false), map9((bool) => {
        if (bool) {
          builder.push(a);
        }
        return bool;
      })));
    }
    return map9(taking, () => builder);
  }));
  var tapBoth = /* @__PURE__ */ dual(2, (self, {
    onFailure,
    onSuccess
  }) => matchCauseEffect(self, {
    onFailure: (cause3) => {
      const either6 = failureOrCause(cause3);
      switch (either6._tag) {
        case "Left": {
          return zipRight(onFailure(either6.left), failCause(cause3));
        }
        case "Right": {
          return failCause(cause3);
        }
      }
    },
    onSuccess: (a) => as(onSuccess(a), a)
  }));
  var tapDefect = /* @__PURE__ */ dual(2, (self, f) => catchAllCause(self, (cause3) => match2(keepDefects(cause3), {
    onNone: () => failCause(cause3),
    onSome: (a) => zipRight(f(a), failCause(cause3))
  })));
  var tapError = /* @__PURE__ */ dual(2, (self, f) => matchCauseEffect(self, {
    onFailure: (cause3) => {
      const either6 = failureOrCause(cause3);
      switch (either6._tag) {
        case "Left":
          return zipRight(f(either6.left), failCause(cause3));
        case "Right":
          return failCause(cause3);
      }
    },
    onSuccess: succeed
  }));
  var tapErrorTag = /* @__PURE__ */ dual(3, (self, k, f) => tapError(self, (e) => {
    if (isTagged(e, k)) {
      return f(e);
    }
    return void_2;
  }));
  var tapErrorCause = /* @__PURE__ */ dual(2, (self, f) => matchCauseEffect(self, {
    onFailure: (cause3) => zipRight(f(cause3), failCause(cause3)),
    onSuccess: succeed
  }));
  var timed = (self) => timedWith(self, currentTimeNanos2);
  var timedWith = /* @__PURE__ */ dual(2, (self, nanos2) => summarized(self, nanos2, (start3, end3) => nanos(end3 - start3)));
  var tracerWith3 = tracerWith2;
  var tracer = /* @__PURE__ */ tracerWith3(succeed);
  var tryPromise = (arg) => {
    let evaluate2;
    let catcher = void 0;
    if (typeof arg === "function") {
      evaluate2 = arg;
    } else {
      evaluate2 = arg.try;
      catcher = arg.catch;
    }
    const fail5 = (e) => catcher ? failSync(() => catcher(e)) : fail2(new UnknownException(e, "An unknown error occurred in Effect.tryPromise"));
    if (evaluate2.length >= 1) {
      return async_((resolve, signal) => {
        try {
          evaluate2(signal).then((a) => resolve(succeed(a)), (e) => resolve(fail5(e)));
        } catch (e) {
          resolve(fail5(e));
        }
      });
    }
    return async_((resolve) => {
      try {
        evaluate2().then((a) => resolve(succeed(a)), (e) => resolve(fail5(e)));
      } catch (e) {
        resolve(fail5(e));
      }
    });
  };
  var tryMap = /* @__PURE__ */ dual(2, (self, options) => flatMap8(self, (a) => try_2({
    try: () => options.try(a),
    catch: options.catch
  })));
  var tryMapPromise = /* @__PURE__ */ dual(2, (self, options) => flatMap8(self, (a) => tryPromise({
    try: options.try.length >= 1 ? (signal) => options.try(a, signal) : () => options.try(a),
    catch: options.catch
  })));
  var unless = /* @__PURE__ */ dual(2, (self, condition) => suspend(() => condition() ? succeedNone : asSome(self)));
  var unlessEffect = /* @__PURE__ */ dual(2, (self, condition) => flatMap8(condition, (b) => b ? succeedNone : asSome(self)));
  var unsandbox = (self) => mapErrorCause(self, flatten3);
  var updateFiberRefs = (f) => withFiberRuntime((state) => {
    state.setFiberRefs(f(state.id(), state.getFiberRefs()));
    return void_2;
  });
  var updateService = /* @__PURE__ */ dual(3, (self, tag, f) => mapInputContext(self, (context4) => add2(context4, tag, f(unsafeGet3(context4, tag)))));
  var when = /* @__PURE__ */ dual(2, (self, condition) => suspend(() => condition() ? map9(self, some2) : succeed(none2())));
  var whenFiberRef = /* @__PURE__ */ dual(3, (self, fiberRef, predicate) => flatMap8(fiberRefGet(fiberRef), (s) => predicate(s) ? map9(self, (a) => [s, some2(a)]) : succeed([s, none2()])));
  var whenRef = /* @__PURE__ */ dual(3, (self, ref, predicate) => flatMap8(get12(ref), (s) => predicate(s) ? map9(self, (a) => [s, some2(a)]) : succeed([s, none2()])));
  var withMetric = /* @__PURE__ */ dual(2, (self, metric) => metric(self));
  var serviceFunctionEffect = (getService, f) => (...args2) => flatMap8(getService, (a) => f(a)(...args2));
  var serviceFunction = (getService, f) => (...args2) => map9(getService, (a) => f(a)(...args2));
  var serviceFunctions = (getService) => new Proxy({}, {
    get(_target, prop, _receiver) {
      return (...args2) => flatMap8(getService, (s) => s[prop](...args2));
    }
  });
  var serviceConstants = (getService) => new Proxy({}, {
    get(_target, prop, _receiver) {
      return flatMap8(getService, (s) => isEffect(s[prop]) ? s[prop] : succeed(s[prop]));
    }
  });
  var serviceMembers = (getService) => ({
    functions: serviceFunctions(getService),
    constants: serviceConstants(getService)
  });
  var serviceOption = (tag) => map9(context(), getOption2(tag));
  var serviceOptional = (tag) => flatMap8(context(), getOption2(tag));
  var annotateCurrentSpan = function() {
    const args2 = arguments;
    return ignore(flatMap8(currentSpan, (span2) => sync(() => {
      if (typeof args2[0] === "string") {
        span2.attribute(args2[0], args2[1]);
      } else {
        for (const key in args2[0]) {
          span2.attribute(key, args2[0][key]);
        }
      }
    })));
  };
  var linkSpanCurrent = function() {
    const args2 = arguments;
    const links = Array.isArray(args2[0]) ? args2[0] : [{
      _tag: "SpanLink",
      span: args2[0],
      attributes: args2[1] ?? {}
    }];
    return ignore(flatMap8(currentSpan, (span2) => sync(() => span2.addLinks(links))));
  };
  var annotateSpans = /* @__PURE__ */ dual((args2) => isEffect(args2[0]), function() {
    const args2 = arguments;
    return fiberRefLocallyWith(args2[0], currentTracerSpanAnnotations, typeof args2[1] === "string" ? set3(args2[1], args2[2]) : (annotations) => Object.entries(args2[1]).reduce((acc, [key, value]) => set3(acc, key, value), annotations));
  });
  var currentParentSpan = /* @__PURE__ */ serviceOptional(spanTag);
  var currentSpan = /* @__PURE__ */ flatMap8(/* @__PURE__ */ context(), (context4) => {
    const span2 = context4.unsafeMap.get(spanTag.key);
    return span2 !== void 0 && span2._tag === "Span" ? succeed(span2) : fail2(new NoSuchElementException());
  });
  var linkSpans = /* @__PURE__ */ dual((args2) => isEffect(args2[0]), (self, span2, attributes) => fiberRefLocallyWith(self, currentTracerSpanLinks, append2({
    _tag: "SpanLink",
    span: span2,
    attributes: attributes ?? {}
  })));
  var bigint02 = /* @__PURE__ */ BigInt(0);
  var filterDisablePropagation = /* @__PURE__ */ flatMap2((span2) => get3(span2.context, DisablePropagation) ? span2._tag === "Span" ? filterDisablePropagation(span2.parent) : none2() : some2(span2));
  var unsafeMakeSpan = (fiber, name, options) => {
    const disablePropagation = !fiber.getFiberRef(currentTracerEnabled) || options.context && get3(options.context, DisablePropagation);
    const context4 = fiber.getFiberRef(currentContext);
    const parent = options.parent ? some2(options.parent) : options.root ? none2() : filterDisablePropagation(getOption2(context4, spanTag));
    let span2;
    if (disablePropagation) {
      span2 = noopSpan({
        name,
        parent,
        context: add2(options.context ?? empty3(), DisablePropagation, true)
      });
    } else {
      const services = fiber.getFiberRef(currentServices);
      const tracer3 = get3(services, tracerTag);
      const clock3 = get3(services, Clock);
      const timingEnabled = fiber.getFiberRef(currentTracerTimingEnabled);
      const fiberRefs3 = fiber.getFiberRefs();
      const annotationsFromEnv = get10(fiberRefs3, currentTracerSpanAnnotations);
      const linksFromEnv = get10(fiberRefs3, currentTracerSpanLinks);
      const links = linksFromEnv._tag === "Some" ? options.links !== void 0 ? [...toReadonlyArray(linksFromEnv.value), ...options.links ?? []] : toReadonlyArray(linksFromEnv.value) : options.links ?? empty();
      span2 = tracer3.span(name, parent, options.context ?? empty3(), links, timingEnabled ? clock3.unsafeCurrentTimeNanos() : bigint02, options.kind ?? "internal", options);
      if (annotationsFromEnv._tag === "Some") {
        forEach3(annotationsFromEnv.value, (value, key) => span2.attribute(key, value));
      }
      if (options.attributes !== void 0) {
        Object.entries(options.attributes).forEach(([k, v]) => span2.attribute(k, v));
      }
    }
    if (typeof options.captureStackTrace === "function") {
      spanToTrace.set(span2, options.captureStackTrace);
    }
    return span2;
  };
  var makeSpan = (name, options) => {
    options = addSpanStackTrace(options);
    return withFiberRuntime((fiber) => succeed(unsafeMakeSpan(fiber, name, options)));
  };
  var spanAnnotations = /* @__PURE__ */ fiberRefGet(currentTracerSpanAnnotations);
  var spanLinks = /* @__PURE__ */ fiberRefGet(currentTracerSpanLinks);
  var endSpan = (span2, exit4, clock3, timingEnabled) => sync(() => {
    if (span2.status._tag === "Ended") {
      return;
    }
    if (exitIsFailure(exit4) && spanToTrace.has(span2)) {
      span2.attribute("code.stacktrace", spanToTrace.get(span2)());
    }
    span2.end(timingEnabled ? clock3.unsafeCurrentTimeNanos() : bigint02, exit4);
  });
  var useSpan = (name, ...args2) => {
    const options = addSpanStackTrace(args2.length === 1 ? void 0 : args2[0]);
    const evaluate2 = args2[args2.length - 1];
    return withFiberRuntime((fiber) => {
      const span2 = unsafeMakeSpan(fiber, name, options);
      const timingEnabled = fiber.getFiberRef(currentTracerTimingEnabled);
      const clock3 = get3(fiber.getFiberRef(currentServices), clockTag);
      return onExit(evaluate2(span2), (exit4) => endSpan(span2, exit4, clock3, timingEnabled));
    });
  };
  var withParentSpan = /* @__PURE__ */ dual(2, (self, span2) => provideService(self, spanTag, span2));
  var withSpan = function() {
    const dataFirst = typeof arguments[0] !== "string";
    const name = dataFirst ? arguments[1] : arguments[0];
    const options = addSpanStackTrace(dataFirst ? arguments[2] : arguments[1]);
    if (dataFirst) {
      const self = arguments[0];
      return useSpan(name, options, (span2) => withParentSpan(self, span2));
    }
    return (self) => useSpan(name, options, (span2) => withParentSpan(self, span2));
  };
  var functionWithSpan = (options) => function() {
    let captureStackTrace = options.captureStackTrace ?? false;
    if (options.captureStackTrace !== false) {
      const limit = Error.stackTraceLimit;
      Error.stackTraceLimit = 2;
      const error = new Error();
      Error.stackTraceLimit = limit;
      let cache7 = false;
      captureStackTrace = () => {
        if (cache7 !== false) {
          return cache7;
        }
        if (error.stack) {
          const stack = error.stack.trim().split("\n");
          cache7 = stack.slice(2).join("\n").trim();
          return cache7;
        }
      };
    }
    return suspend(() => {
      const opts = typeof options.options === "function" ? options.options.apply(null, arguments) : options.options;
      return withSpan(suspend(() => internalCall(() => options.body.apply(this, arguments))), opts.name, {
        ...opts,
        captureStackTrace
      });
    });
  };
  var fromNullable3 = (value) => value == null ? fail2(new NoSuchElementException()) : succeed(value);
  var optionFromOptional = (self) => catchAll(map9(self, some2), (error) => isNoSuchElementException(error) ? succeedNone : fail2(error));

  // <eztb>/node_modules/effect/dist/esm/internal/executionStrategy.js
  var OP_SEQUENTIAL2 = "Sequential";
  var OP_PARALLEL2 = "Parallel";
  var OP_PARALLEL_N = "ParallelN";
  var sequential2 = {
    _tag: OP_SEQUENTIAL2
  };
  var parallel2 = {
    _tag: OP_PARALLEL2
  };
  var parallelN = (parallelism) => ({
    _tag: OP_PARALLEL_N,
    parallelism
  });
  var isSequential = (self) => self._tag === OP_SEQUENTIAL2;
  var isParallel = (self) => self._tag === OP_PARALLEL2;

  // <eztb>/node_modules/effect/dist/esm/ExecutionStrategy.js
  var sequential3 = sequential2;
  var parallel3 = parallel2;
  var parallelN2 = parallelN;

  // <eztb>/node_modules/effect/dist/esm/FiberRefsPatch.js
  var diff6 = diff5;
  var patch7 = patch6;

  // <eztb>/node_modules/effect/dist/esm/internal/fiberStatus.js
  var FiberStatusSymbolKey = "effect/FiberStatus";
  var FiberStatusTypeId = /* @__PURE__ */ Symbol.for(FiberStatusSymbolKey);
  var OP_DONE = "Done";
  var OP_RUNNING = "Running";
  var OP_SUSPENDED = "Suspended";
  var DoneHash = /* @__PURE__ */ string(`${FiberStatusSymbolKey}-${OP_DONE}`);
  var _a18;
  var Done = class {
    constructor() {
      __publicField(this, _a18, FiberStatusTypeId);
      __publicField(this, "_tag", OP_DONE);
    }
    [(_a18 = FiberStatusTypeId, symbol)]() {
      return DoneHash;
    }
    [symbol2](that) {
      return isFiberStatus(that) && that._tag === OP_DONE;
    }
  };
  var _a19;
  var Running = class {
    constructor(runtimeFlags2) {
      __publicField(this, "runtimeFlags");
      __publicField(this, _a19, FiberStatusTypeId);
      __publicField(this, "_tag", OP_RUNNING);
      this.runtimeFlags = runtimeFlags2;
    }
    [(_a19 = FiberStatusTypeId, symbol)]() {
      return pipe(hash(FiberStatusSymbolKey), combine(hash(this._tag)), combine(hash(this.runtimeFlags)), cached(this));
    }
    [symbol2](that) {
      return isFiberStatus(that) && that._tag === OP_RUNNING && this.runtimeFlags === that.runtimeFlags;
    }
  };
  var _a20;
  var Suspended = class {
    constructor(runtimeFlags2, blockingOn) {
      __publicField(this, "runtimeFlags");
      __publicField(this, "blockingOn");
      __publicField(this, _a20, FiberStatusTypeId);
      __publicField(this, "_tag", OP_SUSPENDED);
      this.runtimeFlags = runtimeFlags2;
      this.blockingOn = blockingOn;
    }
    [(_a20 = FiberStatusTypeId, symbol)]() {
      return pipe(hash(FiberStatusSymbolKey), combine(hash(this._tag)), combine(hash(this.runtimeFlags)), combine(hash(this.blockingOn)), cached(this));
    }
    [symbol2](that) {
      return isFiberStatus(that) && that._tag === OP_SUSPENDED && this.runtimeFlags === that.runtimeFlags && equals(this.blockingOn, that.blockingOn);
    }
  };
  var done3 = /* @__PURE__ */ new Done();
  var running = (runtimeFlags2) => new Running(runtimeFlags2);
  var suspended = (runtimeFlags2, blockingOn) => new Suspended(runtimeFlags2, blockingOn);
  var isFiberStatus = (u) => hasProperty(u, FiberStatusTypeId);
  var isDone = (self) => self._tag === OP_DONE;

  // <eztb>/node_modules/effect/dist/esm/FiberStatus.js
  var done4 = done3;
  var running2 = running;
  var suspended2 = suspended;
  var isDone2 = isDone;

  // <eztb>/node_modules/effect/dist/esm/Micro.js
  var TypeId14 = /* @__PURE__ */ Symbol.for("effect/Micro");
  var MicroExitTypeId = /* @__PURE__ */ Symbol.for("effect/Micro/MicroExit");
  var MicroCauseTypeId = /* @__PURE__ */ Symbol.for("effect/Micro/MicroCause");
  var microCauseVariance = {
    _E: identity
  };
  var _a21;
  var MicroCauseImpl = class extends globalThis.Error {
    constructor(_tag, originalError, traces) {
      const causeName = `MicroCause.${_tag}`;
      let name;
      let message;
      let stack;
      if (originalError instanceof globalThis.Error) {
        name = `(${causeName}) ${originalError.name}`;
        message = originalError.message;
        const messageLines = message.split("\n").length;
        stack = originalError.stack ? `(${causeName}) ${originalError.stack.split("\n").slice(0, messageLines + 3).join("\n")}` : `${name}: ${message}`;
      } else {
        name = causeName;
        message = toStringUnknown(originalError, 0);
        stack = `${name}: ${message}`;
      }
      if (traces.length > 0) {
        stack += `
    ${traces.join("\n    ")}`;
      }
      super(message);
      __publicField(this, "_tag");
      __publicField(this, "traces");
      __publicField(this, _a21);
      this._tag = _tag;
      this.traces = traces;
      this[MicroCauseTypeId] = microCauseVariance;
      this.name = name;
      this.stack = stack;
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
    toString() {
      return this.stack;
    }
    [(_a21 = MicroCauseTypeId, NodeInspectSymbol)]() {
      return this.stack;
    }
  };
  var Die = class extends MicroCauseImpl {
    constructor(defect, traces = []) {
      super("Die", defect, traces);
      __publicField(this, "defect");
      this.defect = defect;
    }
  };
  var causeDie = (defect, traces = []) => new Die(defect, traces);
  var Interrupt = class extends MicroCauseImpl {
    constructor(traces = []) {
      super("Interrupt", "interrupted", traces);
    }
  };
  var causeInterrupt = (traces = []) => new Interrupt(traces);
  var causeIsInterrupt = (self) => self._tag === "Interrupt";
  var MicroFiberTypeId = /* @__PURE__ */ Symbol.for("effect/Micro/MicroFiber");
  var fiberVariance = {
    _A: identity,
    _E: identity
  };
  var _a22;
  _a22 = MicroFiberTypeId;
  var MicroFiberImpl = class {
    constructor(context4, interruptible5 = true) {
      __publicField(this, "context");
      __publicField(this, "interruptible");
      __publicField(this, _a22);
      __publicField(this, "_stack", []);
      __publicField(this, "_observers", []);
      __publicField(this, "_exit");
      __publicField(this, "_children");
      __publicField(this, "currentOpCount", 0);
      __publicField(this, "_interrupted", false);
      // cancel the yielded operation, or for the yielded exit value
      __publicField(this, "_yielded");
      this.context = context4;
      this.interruptible = interruptible5;
      this[MicroFiberTypeId] = fiberVariance;
    }
    getRef(ref) {
      return unsafeGetReference(this.context, ref);
    }
    addObserver(cb) {
      if (this._exit) {
        cb(this._exit);
        return constVoid;
      }
      this._observers.push(cb);
      return () => {
        const index = this._observers.indexOf(cb);
        if (index >= 0) {
          this._observers.splice(index, 1);
        }
      };
    }
    unsafeInterrupt() {
      if (this._exit) {
        return;
      }
      this._interrupted = true;
      if (this.interruptible) {
        this.evaluate(exitInterrupt2);
      }
    }
    unsafePoll() {
      return this._exit;
    }
    evaluate(effect) {
      if (this._exit) {
        return;
      } else if (this._yielded !== void 0) {
        const yielded = this._yielded;
        this._yielded = void 0;
        yielded();
      }
      const exit4 = this.runLoop(effect);
      if (exit4 === Yield) {
        return;
      }
      const interruptChildren = fiberMiddleware.interruptChildren && fiberMiddleware.interruptChildren(this);
      if (interruptChildren !== void 0) {
        return this.evaluate(flatMap9(interruptChildren, () => exit4));
      }
      this._exit = exit4;
      for (let i = 0; i < this._observers.length; i++) {
        this._observers[i](exit4);
      }
      this._observers.length = 0;
    }
    runLoop(effect) {
      let yielding = false;
      let current = effect;
      this.currentOpCount = 0;
      try {
        while (true) {
          this.currentOpCount++;
          if (!yielding && this.getRef(CurrentScheduler).shouldYield(this)) {
            yielding = true;
            const prev = current;
            current = flatMap9(yieldNow2, () => prev);
          }
          current = current[evaluate](this);
          if (current === Yield) {
            const yielded = this._yielded;
            if (MicroExitTypeId in yielded) {
              this._yielded = void 0;
              return yielded;
            }
            return Yield;
          }
        }
      } catch (error) {
        if (!hasProperty(current, evaluate)) {
          return exitDie2(`MicroFiber.runLoop: Not a valid effect: ${String(current)}`);
        }
        return exitDie2(error);
      }
    }
    getCont(symbol4) {
      while (true) {
        const op = this._stack.pop();
        if (!op) return void 0;
        const cont = op[ensureCont] && op[ensureCont](this);
        if (cont) return {
          [symbol4]: cont
        };
        if (op[symbol4]) return op;
      }
    }
    yieldWith(value) {
      this._yielded = value;
      return Yield;
    }
    children() {
      return this._children ?? (this._children = /* @__PURE__ */ new Set());
    }
  };
  var fiberMiddleware = /* @__PURE__ */ globalValue("effect/Micro/fiberMiddleware", () => ({
    interruptChildren: void 0
  }));
  var fiberInterruptAll = (fibers) => suspend2(() => {
    for (const fiber of fibers) fiber.unsafeInterrupt();
    const iter = fibers[Symbol.iterator]();
    const wait = suspend2(() => {
      let result = iter.next();
      while (!result.done) {
        if (result.value.unsafePoll()) {
          result = iter.next();
          continue;
        }
        const fiber = result.value;
        return async((resume2) => {
          fiber.addObserver((_) => {
            resume2(wait);
          });
        });
      }
      return exitVoid2;
    });
    return wait;
  });
  var identifier = /* @__PURE__ */ Symbol.for("effect/Micro/identifier");
  var args = /* @__PURE__ */ Symbol.for("effect/Micro/args");
  var evaluate = /* @__PURE__ */ Symbol.for("effect/Micro/evaluate");
  var successCont = /* @__PURE__ */ Symbol.for("effect/Micro/successCont");
  var failureCont = /* @__PURE__ */ Symbol.for("effect/Micro/failureCont");
  var ensureCont = /* @__PURE__ */ Symbol.for("effect/Micro/ensureCont");
  var Yield = /* @__PURE__ */ Symbol.for("effect/Micro/Yield");
  var microVariance = {
    _A: identity,
    _E: identity,
    _R: identity
  };
  var MicroProto = {
    ...EffectPrototype2,
    _op: "Micro",
    [TypeId14]: microVariance,
    pipe() {
      return pipeArguments(this, arguments);
    },
    [Symbol.iterator]() {
      return new SingleShotGen(new YieldWrap(this));
    },
    toJSON() {
      return {
        _id: "Micro",
        op: this[identifier],
        ...args in this ? {
          args: this[args]
        } : void 0
      };
    },
    toString() {
      return format2(this);
    },
    [NodeInspectSymbol]() {
      return format2(this);
    }
  };
  function defaultEvaluate(_fiber) {
    return exitDie2(`Micro.evaluate: Not implemented`);
  }
  var makePrimitiveProto = (options) => ({
    ...MicroProto,
    [identifier]: options.op,
    [evaluate]: options.eval ?? defaultEvaluate,
    [successCont]: options.contA,
    [failureCont]: options.contE,
    [ensureCont]: options.ensure
  });
  var makePrimitive = (options) => {
    const Proto3 = makePrimitiveProto(options);
    return function() {
      const self = Object.create(Proto3);
      self[args] = options.single === false ? arguments : arguments[0];
      return self;
    };
  };
  var makeExit = (options) => {
    const Proto3 = {
      ...makePrimitiveProto(options),
      [MicroExitTypeId]: MicroExitTypeId,
      _tag: options.op,
      get [options.prop]() {
        return this[args];
      },
      toJSON() {
        return {
          _id: "MicroExit",
          _tag: options.op,
          [options.prop]: this[args]
        };
      },
      [symbol2](that) {
        return isMicroExit(that) && that._tag === options.op && equals(this[args], that[args]);
      },
      [symbol]() {
        return cached(this, combine(string(options.op))(hash(this[args])));
      }
    };
    return function(value) {
      const self = Object.create(Proto3);
      self[args] = value;
      self[successCont] = void 0;
      self[failureCont] = void 0;
      self[ensureCont] = void 0;
      return self;
    };
  };
  var succeed3 = /* @__PURE__ */ makeExit({
    op: "Success",
    prop: "value",
    eval(fiber) {
      const cont = fiber.getCont(successCont);
      return cont ? cont[successCont](this[args], fiber) : fiber.yieldWith(this);
    }
  });
  var failCause2 = /* @__PURE__ */ makeExit({
    op: "Failure",
    prop: "cause",
    eval(fiber) {
      let cont = fiber.getCont(failureCont);
      while (causeIsInterrupt(this[args]) && cont && fiber.interruptible) {
        cont = fiber.getCont(failureCont);
      }
      return cont ? cont[failureCont](this[args], fiber) : fiber.yieldWith(this);
    }
  });
  var sync2 = /* @__PURE__ */ makePrimitive({
    op: "Sync",
    eval(fiber) {
      const value = this[args]();
      const cont = fiber.getCont(successCont);
      return cont ? cont[successCont](value, fiber) : fiber.yieldWith(exitSucceed2(value));
    }
  });
  var suspend2 = /* @__PURE__ */ makePrimitive({
    op: "Suspend",
    eval(_fiber) {
      return this[args]();
    }
  });
  var yieldNowWith = /* @__PURE__ */ makePrimitive({
    op: "Yield",
    eval(fiber) {
      let resumed = false;
      fiber.getRef(CurrentScheduler).scheduleTask(() => {
        if (resumed) return;
        fiber.evaluate(exitVoid2);
      }, this[args] ?? 0);
      return fiber.yieldWith(() => {
        resumed = true;
      });
    }
  });
  var yieldNow2 = /* @__PURE__ */ yieldNowWith(0);
  var void_3 = /* @__PURE__ */ succeed3(void 0);
  var withMicroFiber = /* @__PURE__ */ makePrimitive({
    op: "WithMicroFiber",
    eval(fiber) {
      return this[args](fiber);
    }
  });
  var asyncOptions = /* @__PURE__ */ makePrimitive({
    op: "Async",
    single: false,
    eval(fiber) {
      const register = this[args][0];
      let resumed = false;
      let yielded = false;
      const controller = this[args][1] ? new AbortController() : void 0;
      const onCancel = register((effect) => {
        if (resumed) return;
        resumed = true;
        if (yielded) {
          fiber.evaluate(effect);
        } else {
          yielded = effect;
        }
      }, controller?.signal);
      if (yielded !== false) return yielded;
      yielded = true;
      fiber._yielded = () => {
        resumed = true;
      };
      if (controller === void 0 && onCancel === void 0) {
        return Yield;
      }
      fiber._stack.push(asyncFinalizer(() => {
        resumed = true;
        controller?.abort();
        return onCancel ?? exitVoid2;
      }));
      return Yield;
    }
  });
  var asyncFinalizer = /* @__PURE__ */ makePrimitive({
    op: "AsyncFinalizer",
    ensure(fiber) {
      if (fiber.interruptible) {
        fiber.interruptible = false;
        fiber._stack.push(setInterruptible(true));
      }
    },
    contE(cause3, _fiber) {
      return causeIsInterrupt(cause3) ? flatMap9(this[args](), () => failCause2(cause3)) : failCause2(cause3);
    }
  });
  var async = (register) => asyncOptions(register, register.length >= 2);
  var as2 = /* @__PURE__ */ dual(2, (self, value) => map10(self, (_) => value));
  var exit2 = (self) => matchCause2(self, {
    onFailure: exitFailCause2,
    onSuccess: exitSucceed2
  });
  var flatMap9 = /* @__PURE__ */ dual(2, (self, f) => {
    const onSuccess = Object.create(OnSuccessProto);
    onSuccess[args] = self;
    onSuccess[successCont] = f;
    return onSuccess;
  });
  var OnSuccessProto = /* @__PURE__ */ makePrimitiveProto({
    op: "OnSuccess",
    eval(fiber) {
      fiber._stack.push(this);
      return this[args];
    }
  });
  var map10 = /* @__PURE__ */ dual(2, (self, f) => flatMap9(self, (a) => succeed3(f(a))));
  var isMicroExit = (u) => hasProperty(u, MicroExitTypeId);
  var exitSucceed2 = succeed3;
  var exitFailCause2 = failCause2;
  var exitInterrupt2 = /* @__PURE__ */ exitFailCause2(/* @__PURE__ */ causeInterrupt());
  var exitDie2 = (defect) => exitFailCause2(causeDie(defect));
  var exitVoid2 = /* @__PURE__ */ exitSucceed2(void 0);
  var exitVoidAll = (exits) => {
    for (const exit4 of exits) {
      if (exit4._tag === "Failure") {
        return exit4;
      }
    }
    return exitVoid2;
  };
  var setImmediate = "setImmediate" in globalThis ? globalThis.setImmediate : (f) => setTimeout(f, 0);
  var MicroSchedulerDefault = class {
    constructor() {
      __publicField(this, "tasks", []);
      __publicField(this, "running", false);
      /**
       * @since 3.5.9
       */
      __publicField(this, "afterScheduled", () => {
        this.running = false;
        this.runTasks();
      });
    }
    /**
     * @since 3.5.9
     */
    scheduleTask(task, _priority) {
      this.tasks.push(task);
      if (!this.running) {
        this.running = true;
        setImmediate(this.afterScheduled);
      }
    }
    /**
     * @since 3.5.9
     */
    runTasks() {
      const tasks = this.tasks;
      this.tasks = [];
      for (let i = 0, len = tasks.length; i < len; i++) {
        tasks[i]();
      }
    }
    /**
     * @since 3.5.9
     */
    shouldYield(fiber) {
      return fiber.currentOpCount >= fiber.getRef(MaxOpsBeforeYield);
    }
    /**
     * @since 3.5.9
     */
    flush() {
      while (this.tasks.length > 0) {
        this.runTasks();
      }
    }
  };
  var updateContext = /* @__PURE__ */ dual(2, (self, f) => withMicroFiber((fiber) => {
    const prev = fiber.context;
    fiber.context = f(prev);
    return onExit2(self, () => {
      fiber.context = prev;
      return void_3;
    });
  }));
  var provideContext2 = /* @__PURE__ */ dual(2, (self, provided) => updateContext(self, merge3(provided)));
  var MaxOpsBeforeYield = class extends (/* @__PURE__ */ Reference2()("effect/Micro/currentMaxOpsBeforeYield", {
    defaultValue: () => 2048
  })) {
  };
  var CurrentConcurrency = class extends (/* @__PURE__ */ Reference2()("effect/Micro/currentConcurrency", {
    defaultValue: () => "unbounded"
  })) {
  };
  var CurrentScheduler = class extends (/* @__PURE__ */ Reference2()("effect/Micro/currentScheduler", {
    defaultValue: () => new MicroSchedulerDefault()
  })) {
  };
  var matchCauseEffect2 = /* @__PURE__ */ dual(2, (self, options) => {
    const primitive = Object.create(OnSuccessAndFailureProto);
    primitive[args] = self;
    primitive[successCont] = options.onSuccess;
    primitive[failureCont] = options.onFailure;
    return primitive;
  });
  var OnSuccessAndFailureProto = /* @__PURE__ */ makePrimitiveProto({
    op: "OnSuccessAndFailure",
    eval(fiber) {
      fiber._stack.push(this);
      return this[args];
    }
  });
  var matchCause2 = /* @__PURE__ */ dual(2, (self, options) => matchCauseEffect2(self, {
    onFailure: (cause3) => sync2(() => options.onFailure(cause3)),
    onSuccess: (value) => sync2(() => options.onSuccess(value))
  }));
  var MicroScopeTypeId = /* @__PURE__ */ Symbol.for("effect/Micro/MicroScope");
  var _a23;
  _a23 = MicroScopeTypeId;
  var _MicroScopeImpl = class _MicroScopeImpl {
    constructor() {
      __publicField(this, _a23);
      __publicField(this, "state", {
        _tag: "Open",
        finalizers: /* @__PURE__ */ new Set()
      });
      this[MicroScopeTypeId] = MicroScopeTypeId;
    }
    unsafeAddFinalizer(finalizer) {
      if (this.state._tag === "Open") {
        this.state.finalizers.add(finalizer);
      }
    }
    addFinalizer(finalizer) {
      return suspend2(() => {
        if (this.state._tag === "Open") {
          this.state.finalizers.add(finalizer);
          return void_3;
        }
        return finalizer(this.state.exit);
      });
    }
    unsafeRemoveFinalizer(finalizer) {
      if (this.state._tag === "Open") {
        this.state.finalizers.delete(finalizer);
      }
    }
    close(microExit) {
      return suspend2(() => {
        if (this.state._tag === "Open") {
          const finalizers = Array.from(this.state.finalizers).reverse();
          this.state = {
            _tag: "Closed",
            exit: microExit
          };
          return flatMap9(forEach4(finalizers, (finalizer) => exit2(finalizer(microExit))), exitVoidAll);
        }
        return void_3;
      });
    }
    get fork() {
      return sync2(() => {
        const newScope = new _MicroScopeImpl();
        if (this.state._tag === "Closed") {
          newScope.state = this.state;
          return newScope;
        }
        function fin(exit4) {
          return newScope.close(exit4);
        }
        this.state.finalizers.add(fin);
        newScope.unsafeAddFinalizer((_) => sync2(() => this.unsafeRemoveFinalizer(fin)));
        return newScope;
      });
    }
  };
  var MicroScopeImpl = _MicroScopeImpl;
  var onExit2 = /* @__PURE__ */ dual(2, (self, f) => uninterruptibleMask2((restore) => matchCauseEffect2(restore(self), {
    onFailure: (cause3) => flatMap9(f(exitFailCause2(cause3)), () => failCause2(cause3)),
    onSuccess: (a) => flatMap9(f(exitSucceed2(a)), () => succeed3(a))
  })));
  var setInterruptible = /* @__PURE__ */ makePrimitive({
    op: "SetInterruptible",
    ensure(fiber) {
      fiber.interruptible = this[args];
      if (fiber._interrupted && fiber.interruptible) {
        return () => exitInterrupt2;
      }
    }
  });
  var interruptible3 = (self) => withMicroFiber((fiber) => {
    if (fiber.interruptible) return self;
    fiber.interruptible = true;
    fiber._stack.push(setInterruptible(false));
    if (fiber._interrupted) return exitInterrupt2;
    return self;
  });
  var uninterruptibleMask2 = (f) => withMicroFiber((fiber) => {
    if (!fiber.interruptible) return f(identity);
    fiber.interruptible = false;
    fiber._stack.push(setInterruptible(true));
    return f(interruptible3);
  });
  var whileLoop2 = /* @__PURE__ */ makePrimitive({
    op: "While",
    contA(value, fiber) {
      this[args].step(value);
      if (this[args].while()) {
        fiber._stack.push(this);
        return this[args].body();
      }
      return exitVoid2;
    },
    eval(fiber) {
      if (this[args].while()) {
        fiber._stack.push(this);
        return this[args].body();
      }
      return exitVoid2;
    }
  });
  var forEach4 = (iterable, f, options) => withMicroFiber((parent) => {
    const concurrencyOption = options?.concurrency === "inherit" ? parent.getRef(CurrentConcurrency) : options?.concurrency ?? 1;
    const concurrency = concurrencyOption === "unbounded" ? Number.POSITIVE_INFINITY : Math.max(1, concurrencyOption);
    const items = fromIterable(iterable);
    let length2 = items.length;
    if (length2 === 0) {
      return options?.discard ? void_3 : succeed3([]);
    }
    const out = options?.discard ? void 0 : new Array(length2);
    let index = 0;
    if (concurrency === 1) {
      return as2(whileLoop2({
        while: () => index < items.length,
        body: () => f(items[index], index),
        step: out ? (b) => out[index++] = b : (_) => index++
      }), out);
    }
    return async((resume2) => {
      const fibers = /* @__PURE__ */ new Set();
      let result = void 0;
      let inProgress = 0;
      let doneCount = 0;
      let pumping = false;
      let interrupted = false;
      function pump() {
        pumping = true;
        while (inProgress < concurrency && index < length2) {
          const currentIndex = index;
          const item = items[currentIndex];
          index++;
          inProgress++;
          try {
            const child = unsafeFork(parent, f(item, currentIndex), true, true);
            fibers.add(child);
            child.addObserver((exit4) => {
              fibers.delete(child);
              if (interrupted) {
                return;
              } else if (exit4._tag === "Failure") {
                if (result === void 0) {
                  result = exit4;
                  length2 = index;
                  fibers.forEach((fiber) => fiber.unsafeInterrupt());
                }
              } else if (out !== void 0) {
                out[currentIndex] = exit4.value;
              }
              doneCount++;
              inProgress--;
              if (doneCount === length2) {
                resume2(result ?? succeed3(out));
              } else if (!pumping && inProgress < concurrency) {
                pump();
              }
            });
          } catch (err) {
            result = exitDie2(err);
            length2 = index;
            fibers.forEach((fiber) => fiber.unsafeInterrupt());
          }
        }
        pumping = false;
      }
      pump();
      return suspend2(() => {
        interrupted = true;
        index = length2;
        return fiberInterruptAll(fibers);
      });
    });
  });
  var unsafeFork = (parent, effect, immediate = false, daemon = false) => {
    const child = new MicroFiberImpl(parent.context, parent.interruptible);
    if (!daemon) {
      parent.children().add(child);
      child.addObserver(() => parent.children().delete(child));
    }
    if (immediate) {
      child.evaluate(effect);
    } else {
      parent.getRef(CurrentScheduler).scheduleTask(() => child.evaluate(effect), 0);
    }
    return child;
  };
  var runFork = (effect, options) => {
    const fiber = new MicroFiberImpl(CurrentScheduler.context(options?.scheduler ?? new MicroSchedulerDefault()));
    fiber.evaluate(effect);
    if (options?.signal) {
      if (options.signal.aborted) {
        fiber.unsafeInterrupt();
      } else {
        const abort = () => fiber.unsafeInterrupt();
        options.signal.addEventListener("abort", abort, {
          once: true
        });
        fiber.addObserver(() => options.signal.removeEventListener("abort", abort));
      }
    }
    return fiber;
  };

  // <eztb>/node_modules/effect/dist/esm/Scheduler.js
  var PriorityBuckets = class {
    constructor() {
      /**
       * @since 2.0.0
       */
      __publicField(this, "buckets", []);
    }
    /**
     * @since 2.0.0
     */
    scheduleTask(task, priority) {
      const length2 = this.buckets.length;
      let bucket = void 0;
      let index = 0;
      for (; index < length2; index++) {
        if (this.buckets[index][0] <= priority) {
          bucket = this.buckets[index];
        } else {
          break;
        }
      }
      if (bucket && bucket[0] === priority) {
        bucket[1].push(task);
      } else if (index === length2) {
        this.buckets.push([priority, [task]]);
      } else {
        this.buckets.splice(index, 0, [priority, [task]]);
      }
    }
  };
  var MixedScheduler = class {
    constructor(maxNextTickBeforeTimer) {
      __publicField(this, "maxNextTickBeforeTimer");
      /**
       * @since 2.0.0
       */
      __publicField(this, "running", false);
      /**
       * @since 2.0.0
       */
      __publicField(this, "tasks", /* @__PURE__ */ new PriorityBuckets());
      this.maxNextTickBeforeTimer = maxNextTickBeforeTimer;
    }
    /**
     * @since 2.0.0
     */
    starveInternal(depth) {
      const tasks = this.tasks.buckets;
      this.tasks.buckets = [];
      for (const [_, toRun] of tasks) {
        for (let i = 0; i < toRun.length; i++) {
          toRun[i]();
        }
      }
      if (this.tasks.buckets.length === 0) {
        this.running = false;
      } else {
        this.starve(depth);
      }
    }
    /**
     * @since 2.0.0
     */
    starve(depth = 0) {
      if (depth >= this.maxNextTickBeforeTimer) {
        setTimeout(() => this.starveInternal(0), 0);
      } else {
        Promise.resolve(void 0).then(() => this.starveInternal(depth + 1));
      }
    }
    /**
     * @since 2.0.0
     */
    shouldYield(fiber) {
      return fiber.currentOpCount > fiber.getFiberRef(currentMaxOpsBeforeYield) ? fiber.getFiberRef(currentSchedulingPriority) : false;
    }
    /**
     * @since 2.0.0
     */
    scheduleTask(task, priority) {
      this.tasks.scheduleTask(task, priority);
      if (!this.running) {
        this.running = true;
        this.starve();
      }
    }
  };
  var defaultScheduler = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Scheduler/defaultScheduler"), () => new MixedScheduler(2048));
  var SyncScheduler = class {
    constructor() {
      /**
       * @since 2.0.0
       */
      __publicField(this, "tasks", /* @__PURE__ */ new PriorityBuckets());
      /**
       * @since 2.0.0
       */
      __publicField(this, "deferred", false);
    }
    /**
     * @since 2.0.0
     */
    scheduleTask(task, priority) {
      if (this.deferred) {
        defaultScheduler.scheduleTask(task, priority);
      } else {
        this.tasks.scheduleTask(task, priority);
      }
    }
    /**
     * @since 2.0.0
     */
    shouldYield(fiber) {
      return fiber.currentOpCount > fiber.getFiberRef(currentMaxOpsBeforeYield) ? fiber.getFiberRef(currentSchedulingPriority) : false;
    }
    /**
     * @since 2.0.0
     */
    flush() {
      while (this.tasks.buckets.length > 0) {
        const tasks = this.tasks.buckets;
        this.tasks.buckets = [];
        for (const [_, toRun] of tasks) {
          for (let i = 0; i < toRun.length; i++) {
            toRun[i]();
          }
        }
      }
      this.deferred = true;
    }
  };
  var currentScheduler = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentScheduler"), () => fiberRefUnsafeMake(defaultScheduler));
  var withScheduler = /* @__PURE__ */ dual(2, (self, scheduler) => fiberRefLocally(self, currentScheduler, scheduler));

  // <eztb>/node_modules/effect/dist/esm/internal/completedRequestMap.js
  var currentRequestMap = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentRequestMap"), () => fiberRefUnsafeMake(/* @__PURE__ */ new Map()));

  // <eztb>/node_modules/effect/dist/esm/internal/concurrency.js
  var match8 = (concurrency, sequential4, unbounded2, bounded) => {
    switch (concurrency) {
      case void 0:
        return sequential4();
      case "unbounded":
        return unbounded2();
      case "inherit":
        return fiberRefGetWith(currentConcurrency, (concurrency2) => concurrency2 === "unbounded" ? unbounded2() : concurrency2 > 1 ? bounded(concurrency2) : sequential4());
      default:
        return concurrency > 1 ? bounded(concurrency) : sequential4();
    }
  };
  var matchSimple = (concurrency, sequential4, concurrent) => {
    switch (concurrency) {
      case void 0:
        return sequential4();
      case "unbounded":
        return concurrent();
      case "inherit":
        return fiberRefGetWith(currentConcurrency, (concurrency2) => concurrency2 === "unbounded" || concurrency2 > 1 ? concurrent() : sequential4());
      default:
        return concurrency > 1 ? concurrent() : sequential4();
    }
  };

  // <eztb>/node_modules/effect/dist/esm/internal/fiberMessage.js
  var OP_INTERRUPT_SIGNAL = "InterruptSignal";
  var OP_STATEFUL = "Stateful";
  var OP_RESUME = "Resume";
  var OP_YIELD_NOW = "YieldNow";
  var interruptSignal = (cause3) => ({
    _tag: OP_INTERRUPT_SIGNAL,
    cause: cause3
  });
  var stateful = (onFiber) => ({
    _tag: OP_STATEFUL,
    onFiber
  });
  var resume = (effect) => ({
    _tag: OP_RESUME,
    effect
  });
  var yieldNow3 = () => ({
    _tag: OP_YIELD_NOW
  });

  // <eztb>/node_modules/effect/dist/esm/internal/fiberScope.js
  var FiberScopeSymbolKey = "effect/FiberScope";
  var FiberScopeTypeId = /* @__PURE__ */ Symbol.for(FiberScopeSymbolKey);
  var _a24;
  _a24 = FiberScopeTypeId;
  var Global = class {
    constructor() {
      __publicField(this, _a24, FiberScopeTypeId);
      __publicField(this, "fiberId", none4);
      __publicField(this, "roots", /* @__PURE__ */ new Set());
    }
    add(_runtimeFlags, child) {
      this.roots.add(child);
      child.addObserver(() => {
        this.roots.delete(child);
      });
    }
  };
  var _a25;
  _a25 = FiberScopeTypeId;
  var Local = class {
    constructor(fiberId3, parent) {
      __publicField(this, "fiberId");
      __publicField(this, "parent");
      __publicField(this, _a25, FiberScopeTypeId);
      this.fiberId = fiberId3;
      this.parent = parent;
    }
    add(_runtimeFlags, child) {
      this.parent.tell(stateful((parentFiber) => {
        parentFiber.addChild(child);
        child.addObserver(() => {
          parentFiber.removeChild(child);
        });
      }));
    }
  };
  var unsafeMake6 = (fiber) => {
    return new Local(fiber.id(), fiber);
  };
  var globalScope = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberScope/Global"), () => new Global());

  // <eztb>/node_modules/effect/dist/esm/internal/fiber.js
  var FiberSymbolKey = "effect/Fiber";
  var FiberTypeId = /* @__PURE__ */ Symbol.for(FiberSymbolKey);
  var fiberVariance2 = {
    /* c8 ignore next */
    _E: (_) => _,
    /* c8 ignore next */
    _A: (_) => _
  };
  var fiberProto = {
    [FiberTypeId]: fiberVariance2,
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var RuntimeFiberSymbolKey = "effect/Fiber";
  var RuntimeFiberTypeId = /* @__PURE__ */ Symbol.for(RuntimeFiberSymbolKey);
  var isRuntimeFiber = (self) => RuntimeFiberTypeId in self;
  var _await2 = (self) => self.await;
  var inheritAll = (self) => self.inheritAll;
  var interruptAllAs = /* @__PURE__ */ dual(2, /* @__PURE__ */ fnUntraced(function* (fibers, fiberId3) {
    for (const fiber of fibers) {
      if (isRuntimeFiber(fiber)) {
        fiber.unsafeInterruptAsFork(fiberId3);
        continue;
      }
      yield* fiber.interruptAsFork(fiberId3);
    }
    for (const fiber of fibers) {
      if (isRuntimeFiber(fiber) && fiber.unsafePoll()) {
        continue;
      }
      yield* fiber.await;
    }
  }));
  var interruptAsFork = /* @__PURE__ */ dual(2, (self, fiberId3) => self.interruptAsFork(fiberId3));
  var join2 = (self) => zipLeft(flatten4(self.await), self.inheritAll);
  var _never = {
    ...CommitPrototype,
    commit() {
      return join2(this);
    },
    ...fiberProto,
    id: () => none4,
    await: never,
    children: /* @__PURE__ */ succeed([]),
    inheritAll: never,
    poll: /* @__PURE__ */ succeed(/* @__PURE__ */ none2()),
    interruptAsFork: () => never
  };
  var currentFiberURI = "effect/FiberCurrent";

  // <eztb>/node_modules/effect/dist/esm/internal/logger.js
  var LoggerSymbolKey = "effect/Logger";
  var LoggerTypeId = /* @__PURE__ */ Symbol.for(LoggerSymbolKey);
  var loggerVariance = {
    /* c8 ignore next */
    _Message: (_) => _,
    /* c8 ignore next */
    _Output: (_) => _
  };
  var makeLogger = (log4) => ({
    [LoggerTypeId]: loggerVariance,
    log: log4,
    pipe() {
      return pipeArguments(this, arguments);
    }
  });
  var none7 = {
    [LoggerTypeId]: loggerVariance,
    log: constVoid,
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var textOnly = /^[^\s"=]*$/;
  var format4 = (quoteValue, whitespace) => ({
    annotations,
    cause: cause3,
    date,
    fiberId: fiberId3,
    logLevel,
    message,
    spans
  }) => {
    const formatValue = (value) => value.match(textOnly) ? value : quoteValue(value);
    const format5 = (label, value) => `${formatLabel(label)}=${formatValue(value)}`;
    const append4 = (label, value) => " " + format5(label, value);
    let out = format5("timestamp", date.toISOString());
    out += append4("level", logLevel.label);
    out += append4("fiber", threadName(fiberId3));
    const messages = ensure(message);
    for (let i = 0; i < messages.length; i++) {
      out += append4("message", toStringUnknown(messages[i], whitespace));
    }
    if (!isEmptyType(cause3)) {
      out += append4("cause", pretty(cause3, {
        renderErrorCause: true
      }));
    }
    for (const span2 of spans) {
      out += " " + render(date.getTime())(span2);
    }
    for (const [label, value] of annotations) {
      out += append4(label, toStringUnknown(value, whitespace));
    }
    return out;
  };
  var escapeDoubleQuotes = (s) => `"${s.replace(/\\([\s\S])|(")/g, "\\$1$2")}"`;
  var stringLogger = /* @__PURE__ */ makeLogger(/* @__PURE__ */ format4(escapeDoubleQuotes));
  var colors = {
    bold: "1",
    red: "31",
    green: "32",
    yellow: "33",
    blue: "34",
    cyan: "36",
    white: "37",
    gray: "90",
    black: "30",
    bgBrightRed: "101"
  };
  var logLevelColors = {
    None: [],
    All: [],
    Trace: [colors.gray],
    Debug: [colors.blue],
    Info: [colors.green],
    Warning: [colors.yellow],
    Error: [colors.red],
    Fatal: [colors.bgBrightRed, colors.black]
  };
  var hasProcessStdout = typeof process === "object" && process !== null && typeof process.stdout === "object" && process.stdout !== null;
  var processStdoutIsTTY = hasProcessStdout && process.stdout.isTTY === true;
  var hasProcessStdoutOrDeno = hasProcessStdout || "Deno" in globalThis;

  // <eztb>/node_modules/effect/dist/esm/internal/metric/boundaries.js
  var MetricBoundariesSymbolKey = "effect/MetricBoundaries";
  var MetricBoundariesTypeId = /* @__PURE__ */ Symbol.for(MetricBoundariesSymbolKey);
  var _a26;
  var MetricBoundariesImpl = class {
    constructor(values3) {
      __publicField(this, "values");
      __publicField(this, _a26, MetricBoundariesTypeId);
      __publicField(this, "_hash");
      this.values = values3;
      this._hash = pipe(string(MetricBoundariesSymbolKey), combine(array2(this.values)));
    }
    [(_a26 = MetricBoundariesTypeId, symbol)]() {
      return this._hash;
    }
    [symbol2](u) {
      return isMetricBoundaries(u) && equals(this.values, u.values);
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var isMetricBoundaries = (u) => hasProperty(u, MetricBoundariesTypeId);
  var fromIterable7 = (iterable) => {
    const values3 = pipe(iterable, appendAll(of2(Number.POSITIVE_INFINITY)), dedupe);
    return new MetricBoundariesImpl(values3);
  };
  var exponential = (options) => pipe(makeBy(options.count - 1, (i) => options.start * Math.pow(options.factor, i)), unsafeFromArray, fromIterable7);

  // <eztb>/node_modules/effect/dist/esm/internal/metric/keyType.js
  var MetricKeyTypeSymbolKey = "effect/MetricKeyType";
  var MetricKeyTypeTypeId = /* @__PURE__ */ Symbol.for(MetricKeyTypeSymbolKey);
  var CounterKeyTypeSymbolKey = "effect/MetricKeyType/Counter";
  var CounterKeyTypeTypeId = /* @__PURE__ */ Symbol.for(CounterKeyTypeSymbolKey);
  var FrequencyKeyTypeSymbolKey = "effect/MetricKeyType/Frequency";
  var FrequencyKeyTypeTypeId = /* @__PURE__ */ Symbol.for(FrequencyKeyTypeSymbolKey);
  var GaugeKeyTypeSymbolKey = "effect/MetricKeyType/Gauge";
  var GaugeKeyTypeTypeId = /* @__PURE__ */ Symbol.for(GaugeKeyTypeSymbolKey);
  var HistogramKeyTypeSymbolKey = "effect/MetricKeyType/Histogram";
  var HistogramKeyTypeTypeId = /* @__PURE__ */ Symbol.for(HistogramKeyTypeSymbolKey);
  var SummaryKeyTypeSymbolKey = "effect/MetricKeyType/Summary";
  var SummaryKeyTypeTypeId = /* @__PURE__ */ Symbol.for(SummaryKeyTypeSymbolKey);
  var metricKeyTypeVariance = {
    /* c8 ignore next */
    _In: (_) => _,
    /* c8 ignore next */
    _Out: (_) => _
  };
  var _a27, _b2;
  var CounterKeyType = class {
    constructor(incremental, bigint) {
      __publicField(this, "incremental");
      __publicField(this, "bigint");
      __publicField(this, _b2, metricKeyTypeVariance);
      __publicField(this, _a27, CounterKeyTypeTypeId);
      __publicField(this, "_hash");
      this.incremental = incremental;
      this.bigint = bigint;
      this._hash = string(CounterKeyTypeSymbolKey);
    }
    [(_b2 = MetricKeyTypeTypeId, _a27 = CounterKeyTypeTypeId, symbol)]() {
      return this._hash;
    }
    [symbol2](that) {
      return isCounterKey(that);
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var FrequencyKeyTypeHash = /* @__PURE__ */ string(FrequencyKeyTypeSymbolKey);
  var _a28, _b3;
  var FrequencyKeyType = class {
    constructor(preregisteredWords) {
      __publicField(this, "preregisteredWords");
      __publicField(this, _b3, metricKeyTypeVariance);
      __publicField(this, _a28, FrequencyKeyTypeTypeId);
      this.preregisteredWords = preregisteredWords;
    }
    [(_b3 = MetricKeyTypeTypeId, _a28 = FrequencyKeyTypeTypeId, symbol)]() {
      return FrequencyKeyTypeHash;
    }
    [symbol2](that) {
      return isFrequencyKey(that);
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var GaugeKeyTypeHash = /* @__PURE__ */ string(GaugeKeyTypeSymbolKey);
  var _a29, _b4;
  var GaugeKeyType = class {
    constructor(bigint) {
      __publicField(this, "bigint");
      __publicField(this, _b4, metricKeyTypeVariance);
      __publicField(this, _a29, GaugeKeyTypeTypeId);
      this.bigint = bigint;
    }
    [(_b4 = MetricKeyTypeTypeId, _a29 = GaugeKeyTypeTypeId, symbol)]() {
      return GaugeKeyTypeHash;
    }
    [symbol2](that) {
      return isGaugeKey(that);
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var _a30, _b5;
  var HistogramKeyType = class {
    constructor(boundaries) {
      __publicField(this, "boundaries");
      __publicField(this, _b5, metricKeyTypeVariance);
      __publicField(this, _a30, HistogramKeyTypeTypeId);
      __publicField(this, "_hash");
      this.boundaries = boundaries;
      this._hash = pipe(string(HistogramKeyTypeSymbolKey), combine(hash(this.boundaries)));
    }
    [(_b5 = MetricKeyTypeTypeId, _a30 = HistogramKeyTypeTypeId, symbol)]() {
      return this._hash;
    }
    [symbol2](that) {
      return isHistogramKey(that) && equals(this.boundaries, that.boundaries);
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var _a31, _b6;
  var SummaryKeyType = class {
    constructor(maxAge, maxSize, error, quantiles) {
      __publicField(this, "maxAge");
      __publicField(this, "maxSize");
      __publicField(this, "error");
      __publicField(this, "quantiles");
      __publicField(this, _b6, metricKeyTypeVariance);
      __publicField(this, _a31, SummaryKeyTypeTypeId);
      __publicField(this, "_hash");
      this.maxAge = maxAge;
      this.maxSize = maxSize;
      this.error = error;
      this.quantiles = quantiles;
      this._hash = pipe(string(SummaryKeyTypeSymbolKey), combine(hash(this.maxAge)), combine(hash(this.maxSize)), combine(hash(this.error)), combine(array2(this.quantiles)));
    }
    [(_b6 = MetricKeyTypeTypeId, _a31 = SummaryKeyTypeTypeId, symbol)]() {
      return this._hash;
    }
    [symbol2](that) {
      return isSummaryKey(that) && equals(this.maxAge, that.maxAge) && this.maxSize === that.maxSize && this.error === that.error && equals(this.quantiles, that.quantiles);
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var counter = (options) => new CounterKeyType(options?.incremental ?? false, options?.bigint ?? false);
  var histogram = (boundaries) => {
    return new HistogramKeyType(boundaries);
  };
  var isCounterKey = (u) => hasProperty(u, CounterKeyTypeTypeId);
  var isFrequencyKey = (u) => hasProperty(u, FrequencyKeyTypeTypeId);
  var isGaugeKey = (u) => hasProperty(u, GaugeKeyTypeTypeId);
  var isHistogramKey = (u) => hasProperty(u, HistogramKeyTypeTypeId);
  var isSummaryKey = (u) => hasProperty(u, SummaryKeyTypeTypeId);

  // <eztb>/node_modules/effect/dist/esm/internal/metric/key.js
  var MetricKeySymbolKey = "effect/MetricKey";
  var MetricKeyTypeId = /* @__PURE__ */ Symbol.for(MetricKeySymbolKey);
  var metricKeyVariance = {
    /* c8 ignore next */
    _Type: (_) => _
  };
  var arrayEquivilence = /* @__PURE__ */ getEquivalence2(equals);
  var _a32;
  var MetricKeyImpl = class {
    constructor(name, keyType, description, tags = []) {
      __publicField(this, "name");
      __publicField(this, "keyType");
      __publicField(this, "description");
      __publicField(this, "tags");
      __publicField(this, _a32, metricKeyVariance);
      __publicField(this, "_hash");
      this.name = name;
      this.keyType = keyType;
      this.description = description;
      this.tags = tags;
      this._hash = pipe(string(this.name + this.description), combine(hash(this.keyType)), combine(array2(this.tags)));
    }
    [(_a32 = MetricKeyTypeId, symbol)]() {
      return this._hash;
    }
    [symbol2](u) {
      return isMetricKey(u) && this.name === u.name && equals(this.keyType, u.keyType) && equals(this.description, u.description) && arrayEquivilence(this.tags, u.tags);
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var isMetricKey = (u) => hasProperty(u, MetricKeyTypeId);
  var counter2 = (name, options) => new MetricKeyImpl(name, counter(options), fromNullable2(options?.description));
  var histogram2 = (name, boundaries, description) => new MetricKeyImpl(name, histogram(boundaries), fromNullable2(description));
  var taggedWithLabels = /* @__PURE__ */ dual(2, (self, extraTags) => extraTags.length === 0 ? self : new MetricKeyImpl(self.name, self.keyType, self.description, union(self.tags, extraTags)));

  // <eztb>/node_modules/effect/dist/esm/internal/metric/state.js
  var MetricStateSymbolKey = "effect/MetricState";
  var MetricStateTypeId = /* @__PURE__ */ Symbol.for(MetricStateSymbolKey);
  var CounterStateSymbolKey = "effect/MetricState/Counter";
  var CounterStateTypeId = /* @__PURE__ */ Symbol.for(CounterStateSymbolKey);
  var FrequencyStateSymbolKey = "effect/MetricState/Frequency";
  var FrequencyStateTypeId = /* @__PURE__ */ Symbol.for(FrequencyStateSymbolKey);
  var GaugeStateSymbolKey = "effect/MetricState/Gauge";
  var GaugeStateTypeId = /* @__PURE__ */ Symbol.for(GaugeStateSymbolKey);
  var HistogramStateSymbolKey = "effect/MetricState/Histogram";
  var HistogramStateTypeId = /* @__PURE__ */ Symbol.for(HistogramStateSymbolKey);
  var SummaryStateSymbolKey = "effect/MetricState/Summary";
  var SummaryStateTypeId = /* @__PURE__ */ Symbol.for(SummaryStateSymbolKey);
  var metricStateVariance = {
    /* c8 ignore next */
    _A: (_) => _
  };
  var _a33, _b7;
  var CounterState = class {
    constructor(count3) {
      __publicField(this, "count");
      __publicField(this, _b7, metricStateVariance);
      __publicField(this, _a33, CounterStateTypeId);
      this.count = count3;
    }
    [(_b7 = MetricStateTypeId, _a33 = CounterStateTypeId, symbol)]() {
      return pipe(hash(CounterStateSymbolKey), combine(hash(this.count)), cached(this));
    }
    [symbol2](that) {
      return isCounterState(that) && this.count === that.count;
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var arrayEquals = /* @__PURE__ */ getEquivalence2(equals);
  var _a34, _b8;
  var FrequencyState = class {
    constructor(occurrences) {
      __publicField(this, "occurrences");
      __publicField(this, _b8, metricStateVariance);
      __publicField(this, _a34, FrequencyStateTypeId);
      __publicField(this, "_hash");
      this.occurrences = occurrences;
    }
    [(_b8 = MetricStateTypeId, _a34 = FrequencyStateTypeId, symbol)]() {
      return pipe(string(FrequencyStateSymbolKey), combine(array2(fromIterable(this.occurrences.entries()))), cached(this));
    }
    [symbol2](that) {
      return isFrequencyState(that) && arrayEquals(fromIterable(this.occurrences.entries()), fromIterable(that.occurrences.entries()));
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var _a35, _b9;
  var GaugeState = class {
    constructor(value) {
      __publicField(this, "value");
      __publicField(this, _b9, metricStateVariance);
      __publicField(this, _a35, GaugeStateTypeId);
      this.value = value;
    }
    [(_b9 = MetricStateTypeId, _a35 = GaugeStateTypeId, symbol)]() {
      return pipe(hash(GaugeStateSymbolKey), combine(hash(this.value)), cached(this));
    }
    [symbol2](u) {
      return isGaugeState(u) && this.value === u.value;
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var _a36, _b10;
  var HistogramState = class {
    constructor(buckets, count3, min4, max6, sum2) {
      __publicField(this, "buckets");
      __publicField(this, "count");
      __publicField(this, "min");
      __publicField(this, "max");
      __publicField(this, "sum");
      __publicField(this, _b10, metricStateVariance);
      __publicField(this, _a36, HistogramStateTypeId);
      this.buckets = buckets;
      this.count = count3;
      this.min = min4;
      this.max = max6;
      this.sum = sum2;
    }
    [(_b10 = MetricStateTypeId, _a36 = HistogramStateTypeId, symbol)]() {
      return pipe(hash(HistogramStateSymbolKey), combine(hash(this.buckets)), combine(hash(this.count)), combine(hash(this.min)), combine(hash(this.max)), combine(hash(this.sum)), cached(this));
    }
    [symbol2](that) {
      return isHistogramState(that) && equals(this.buckets, that.buckets) && this.count === that.count && this.min === that.min && this.max === that.max && this.sum === that.sum;
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var _a37, _b11;
  var SummaryState = class {
    constructor(error, quantiles, count3, min4, max6, sum2) {
      __publicField(this, "error");
      __publicField(this, "quantiles");
      __publicField(this, "count");
      __publicField(this, "min");
      __publicField(this, "max");
      __publicField(this, "sum");
      __publicField(this, _b11, metricStateVariance);
      __publicField(this, _a37, SummaryStateTypeId);
      this.error = error;
      this.quantiles = quantiles;
      this.count = count3;
      this.min = min4;
      this.max = max6;
      this.sum = sum2;
    }
    [(_b11 = MetricStateTypeId, _a37 = SummaryStateTypeId, symbol)]() {
      return pipe(hash(SummaryStateSymbolKey), combine(hash(this.error)), combine(hash(this.quantiles)), combine(hash(this.count)), combine(hash(this.min)), combine(hash(this.max)), combine(hash(this.sum)), cached(this));
    }
    [symbol2](that) {
      return isSummaryState(that) && this.error === that.error && equals(this.quantiles, that.quantiles) && this.count === that.count && this.min === that.min && this.max === that.max && this.sum === that.sum;
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var counter3 = (count3) => new CounterState(count3);
  var frequency2 = (occurrences) => {
    return new FrequencyState(occurrences);
  };
  var gauge2 = (count3) => new GaugeState(count3);
  var histogram3 = (options) => new HistogramState(options.buckets, options.count, options.min, options.max, options.sum);
  var summary2 = (options) => new SummaryState(options.error, options.quantiles, options.count, options.min, options.max, options.sum);
  var isCounterState = (u) => hasProperty(u, CounterStateTypeId);
  var isFrequencyState = (u) => hasProperty(u, FrequencyStateTypeId);
  var isGaugeState = (u) => hasProperty(u, GaugeStateTypeId);
  var isHistogramState = (u) => hasProperty(u, HistogramStateTypeId);
  var isSummaryState = (u) => hasProperty(u, SummaryStateTypeId);

  // <eztb>/node_modules/effect/dist/esm/internal/metric/hook.js
  var MetricHookSymbolKey = "effect/MetricHook";
  var MetricHookTypeId = /* @__PURE__ */ Symbol.for(MetricHookSymbolKey);
  var metricHookVariance = {
    /* c8 ignore next */
    _In: (_) => _,
    /* c8 ignore next */
    _Out: (_) => _
  };
  var make29 = (options) => ({
    [MetricHookTypeId]: metricHookVariance,
    pipe() {
      return pipeArguments(this, arguments);
    },
    ...options
  });
  var bigint03 = /* @__PURE__ */ BigInt(0);
  var counter4 = (key) => {
    let sum2 = key.keyType.bigint ? bigint03 : 0;
    const canUpdate = key.keyType.incremental ? key.keyType.bigint ? (value) => value >= bigint03 : (value) => value >= 0 : (_value2) => true;
    const update5 = (value) => {
      if (canUpdate(value)) {
        sum2 = sum2 + value;
      }
    };
    return make29({
      get: () => counter3(sum2),
      update: update5,
      modify: update5
    });
  };
  var frequency3 = (key) => {
    const values3 = /* @__PURE__ */ new Map();
    for (const word of key.keyType.preregisteredWords) {
      values3.set(word, 0);
    }
    const update5 = (word) => {
      const slotCount = values3.get(word) ?? 0;
      values3.set(word, slotCount + 1);
    };
    return make29({
      get: () => frequency2(values3),
      update: update5,
      modify: update5
    });
  };
  var gauge3 = (_key, startAt) => {
    let value = startAt;
    return make29({
      get: () => gauge2(value),
      update: (v) => {
        value = v;
      },
      modify: (v) => {
        value = value + v;
      }
    });
  };
  var histogram4 = (key) => {
    const bounds = key.keyType.boundaries.values;
    const size9 = bounds.length;
    const values3 = new Uint32Array(size9 + 1);
    const boundaries = new Float64Array(size9);
    let count3 = 0;
    let sum2 = 0;
    let min4 = Number.MAX_VALUE;
    let max6 = Number.MIN_VALUE;
    pipe(bounds, sort(Order), map3((n, i) => {
      boundaries[i] = n;
    }));
    const update5 = (value) => {
      let from = 0;
      let to = size9;
      while (from !== to) {
        const mid = Math.floor(from + (to - from) / 2);
        const boundary = boundaries[mid];
        if (value <= boundary) {
          to = mid;
        } else {
          from = mid;
        }
        if (to === from + 1) {
          if (value <= boundaries[from]) {
            to = from;
          } else {
            from = to;
          }
        }
      }
      values3[from] = values3[from] + 1;
      count3 = count3 + 1;
      sum2 = sum2 + value;
      if (value < min4) {
        min4 = value;
      }
      if (value > max6) {
        max6 = value;
      }
    };
    const getBuckets = () => {
      const builder = allocate(size9);
      let cumulated = 0;
      for (let i = 0; i < size9; i++) {
        const boundary = boundaries[i];
        const value = values3[i];
        cumulated = cumulated + value;
        builder[i] = [boundary, cumulated];
      }
      return builder;
    };
    return make29({
      get: () => histogram3({
        buckets: getBuckets(),
        count: count3,
        min: min4,
        max: max6,
        sum: sum2
      }),
      update: update5,
      modify: update5
    });
  };
  var summary3 = (key) => {
    const {
      error,
      maxAge,
      maxSize,
      quantiles
    } = key.keyType;
    const sortedQuantiles = pipe(quantiles, sort(Order));
    const values3 = allocate(maxSize);
    let head5 = 0;
    let count3 = 0;
    let sum2 = 0;
    let min4 = 0;
    let max6 = 0;
    const snapshot = (now) => {
      const builder = [];
      let i = 0;
      while (i !== maxSize - 1) {
        const item = values3[i];
        if (item != null) {
          const [t, v] = item;
          const age = millis(now - t);
          if (greaterThanOrEqualTo2(age, zero) && lessThanOrEqualTo2(age, maxAge)) {
            builder.push(v);
          }
        }
        i = i + 1;
      }
      return calculateQuantiles(error, sortedQuantiles, sort(builder, Order));
    };
    const observe = (value, timestamp) => {
      if (maxSize > 0) {
        head5 = head5 + 1;
        const target = head5 % maxSize;
        values3[target] = [timestamp, value];
      }
      min4 = count3 === 0 ? value : Math.min(min4, value);
      max6 = count3 === 0 ? value : Math.max(max6, value);
      count3 = count3 + 1;
      sum2 = sum2 + value;
    };
    return make29({
      get: () => summary2({
        error,
        quantiles: snapshot(Date.now()),
        count: count3,
        min: min4,
        max: max6,
        sum: sum2
      }),
      update: ([value, timestamp]) => observe(value, timestamp),
      modify: ([value, timestamp]) => observe(value, timestamp)
    });
  };
  var calculateQuantiles = (error, sortedQuantiles, sortedSamples) => {
    const sampleCount = sortedSamples.length;
    if (!isNonEmptyReadonlyArray(sortedQuantiles)) {
      return empty();
    }
    const head5 = sortedQuantiles[0];
    const tail = sortedQuantiles.slice(1);
    const resolvedHead = resolveQuantile(error, sampleCount, none2(), 0, head5, sortedSamples);
    const resolved = of(resolvedHead);
    tail.forEach((quantile) => {
      resolved.push(resolveQuantile(error, sampleCount, resolvedHead.value, resolvedHead.consumed, quantile, resolvedHead.rest));
    });
    return map3(resolved, (rq) => [rq.quantile, rq.value]);
  };
  var resolveQuantile = (error, sampleCount, current, consumed, quantile, rest) => {
    let error_1 = error;
    let sampleCount_1 = sampleCount;
    let current_1 = current;
    let consumed_1 = consumed;
    let quantile_1 = quantile;
    let rest_1 = rest;
    let error_2 = error;
    let sampleCount_2 = sampleCount;
    let current_2 = current;
    let consumed_2 = consumed;
    let quantile_2 = quantile;
    let rest_2 = rest;
    while (1) {
      if (!isNonEmptyReadonlyArray(rest_1)) {
        return {
          quantile: quantile_1,
          value: none2(),
          consumed: consumed_1,
          rest: []
        };
      }
      if (quantile_1 === 1) {
        return {
          quantile: quantile_1,
          value: some2(lastNonEmpty(rest_1)),
          consumed: consumed_1 + rest_1.length,
          rest: []
        };
      }
      const headValue = headNonEmpty(rest_1);
      const sameHead = span(rest_1, (n) => n === headValue);
      const desired = quantile_1 * sampleCount_1;
      const allowedError = error_1 / 2 * desired;
      const candConsumed = consumed_1 + sameHead[0].length;
      const candError = Math.abs(candConsumed - desired);
      if (candConsumed < desired - allowedError) {
        error_2 = error_1;
        sampleCount_2 = sampleCount_1;
        current_2 = head(rest_1);
        consumed_2 = candConsumed;
        quantile_2 = quantile_1;
        rest_2 = sameHead[1];
        error_1 = error_2;
        sampleCount_1 = sampleCount_2;
        current_1 = current_2;
        consumed_1 = consumed_2;
        quantile_1 = quantile_2;
        rest_1 = rest_2;
        continue;
      }
      if (candConsumed > desired + allowedError) {
        const valueToReturn = isNone2(current_1) ? some2(headValue) : current_1;
        return {
          quantile: quantile_1,
          value: valueToReturn,
          consumed: consumed_1,
          rest: rest_1
        };
      }
      switch (current_1._tag) {
        case "None": {
          error_2 = error_1;
          sampleCount_2 = sampleCount_1;
          current_2 = head(rest_1);
          consumed_2 = candConsumed;
          quantile_2 = quantile_1;
          rest_2 = sameHead[1];
          error_1 = error_2;
          sampleCount_1 = sampleCount_2;
          current_1 = current_2;
          consumed_1 = consumed_2;
          quantile_1 = quantile_2;
          rest_1 = rest_2;
          continue;
        }
        case "Some": {
          const prevError = Math.abs(desired - current_1.value);
          if (candError < prevError) {
            error_2 = error_1;
            sampleCount_2 = sampleCount_1;
            current_2 = head(rest_1);
            consumed_2 = candConsumed;
            quantile_2 = quantile_1;
            rest_2 = sameHead[1];
            error_1 = error_2;
            sampleCount_1 = sampleCount_2;
            current_1 = current_2;
            consumed_1 = consumed_2;
            quantile_1 = quantile_2;
            rest_1 = rest_2;
            continue;
          }
          return {
            quantile: quantile_1,
            value: some2(current_1.value),
            consumed: consumed_1,
            rest: rest_1
          };
        }
      }
    }
    throw new Error("BUG: MetricHook.resolveQuantiles - please report an issue at https://github.com/Effect-TS/effect/issues");
  };

  // <eztb>/node_modules/effect/dist/esm/internal/metric/pair.js
  var MetricPairSymbolKey = "effect/MetricPair";
  var MetricPairTypeId = /* @__PURE__ */ Symbol.for(MetricPairSymbolKey);
  var metricPairVariance = {
    /* c8 ignore next */
    _Type: (_) => _
  };
  var unsafeMake7 = (metricKey, metricState) => {
    return {
      [MetricPairTypeId]: metricPairVariance,
      metricKey,
      metricState,
      pipe() {
        return pipeArguments(this, arguments);
      }
    };
  };

  // <eztb>/node_modules/effect/dist/esm/internal/metric/registry.js
  var MetricRegistrySymbolKey = "effect/MetricRegistry";
  var MetricRegistryTypeId = /* @__PURE__ */ Symbol.for(MetricRegistrySymbolKey);
  var _a38;
  _a38 = MetricRegistryTypeId;
  var MetricRegistryImpl = class {
    constructor() {
      __publicField(this, _a38, MetricRegistryTypeId);
      __publicField(this, "map", /* @__PURE__ */ empty17());
    }
    snapshot() {
      const result = [];
      for (const [key, hook] of this.map) {
        result.push(unsafeMake7(key, hook.get()));
      }
      return result;
    }
    get(key) {
      const hook = pipe(this.map, get8(key), getOrUndefined2);
      if (hook == null) {
        if (isCounterKey(key.keyType)) {
          return this.getCounter(key);
        }
        if (isGaugeKey(key.keyType)) {
          return this.getGauge(key);
        }
        if (isFrequencyKey(key.keyType)) {
          return this.getFrequency(key);
        }
        if (isHistogramKey(key.keyType)) {
          return this.getHistogram(key);
        }
        if (isSummaryKey(key.keyType)) {
          return this.getSummary(key);
        }
        throw new Error("BUG: MetricRegistry.get - unknown MetricKeyType - please report an issue at https://github.com/Effect-TS/effect/issues");
      } else {
        return hook;
      }
    }
    getCounter(key) {
      let value = pipe(this.map, get8(key), getOrUndefined2);
      if (value == null) {
        const counter6 = counter4(key);
        if (!pipe(this.map, has4(key))) {
          pipe(this.map, set4(key, counter6));
        }
        value = counter6;
      }
      return value;
    }
    getFrequency(key) {
      let value = pipe(this.map, get8(key), getOrUndefined2);
      if (value == null) {
        const frequency5 = frequency3(key);
        if (!pipe(this.map, has4(key))) {
          pipe(this.map, set4(key, frequency5));
        }
        value = frequency5;
      }
      return value;
    }
    getGauge(key) {
      let value = pipe(this.map, get8(key), getOrUndefined2);
      if (value == null) {
        const gauge5 = gauge3(key, key.keyType.bigint ? BigInt(0) : 0);
        if (!pipe(this.map, has4(key))) {
          pipe(this.map, set4(key, gauge5));
        }
        value = gauge5;
      }
      return value;
    }
    getHistogram(key) {
      let value = pipe(this.map, get8(key), getOrUndefined2);
      if (value == null) {
        const histogram6 = histogram4(key);
        if (!pipe(this.map, has4(key))) {
          pipe(this.map, set4(key, histogram6));
        }
        value = histogram6;
      }
      return value;
    }
    getSummary(key) {
      let value = pipe(this.map, get8(key), getOrUndefined2);
      if (value == null) {
        const summary5 = summary3(key);
        if (!pipe(this.map, has4(key))) {
          pipe(this.map, set4(key, summary5));
        }
        value = summary5;
      }
      return value;
    }
  };
  var make30 = () => {
    return new MetricRegistryImpl();
  };

  // <eztb>/node_modules/effect/dist/esm/internal/metric.js
  var MetricSymbolKey = "effect/Metric";
  var MetricTypeId = /* @__PURE__ */ Symbol.for(MetricSymbolKey);
  var metricVariance = {
    /* c8 ignore next */
    _Type: (_) => _,
    /* c8 ignore next */
    _In: (_) => _,
    /* c8 ignore next */
    _Out: (_) => _
  };
  var globalMetricRegistry = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Metric/globalMetricRegistry"), () => make30());
  var make31 = function(keyType, unsafeUpdate, unsafeValue, unsafeModify) {
    const metric = Object.assign((effect) => tap(effect, (a) => update4(metric, a)), {
      [MetricTypeId]: metricVariance,
      keyType,
      unsafeUpdate,
      unsafeValue,
      unsafeModify,
      register() {
        this.unsafeValue([]);
        return this;
      },
      pipe() {
        return pipeArguments(this, arguments);
      }
    });
    return metric;
  };
  var counter5 = (name, options) => fromMetricKey(counter2(name, options));
  var fromMetricKey = (key) => {
    let untaggedHook;
    const hookCache = /* @__PURE__ */ new WeakMap();
    const hook = (extraTags) => {
      if (extraTags.length === 0) {
        if (untaggedHook !== void 0) {
          return untaggedHook;
        }
        untaggedHook = globalMetricRegistry.get(key);
        return untaggedHook;
      }
      let hook2 = hookCache.get(extraTags);
      if (hook2 !== void 0) {
        return hook2;
      }
      hook2 = globalMetricRegistry.get(taggedWithLabels(key, extraTags));
      hookCache.set(extraTags, hook2);
      return hook2;
    };
    return make31(key.keyType, (input, extraTags) => hook(extraTags).update(input), (extraTags) => hook(extraTags).get(), (input, extraTags) => hook(extraTags).modify(input));
  };
  var histogram5 = (name, boundaries, description) => fromMetricKey(histogram2(name, boundaries, description));
  var tagged = /* @__PURE__ */ dual(3, (self, key, value) => taggedWithLabels2(self, [make28(key, value)]));
  var taggedWithLabels2 = /* @__PURE__ */ dual(2, (self, extraTags) => {
    return make31(self.keyType, (input, extraTags1) => self.unsafeUpdate(input, union(extraTags, extraTags1)), (extraTags1) => self.unsafeValue(union(extraTags, extraTags1)), (input, extraTags1) => self.unsafeModify(input, union(extraTags, extraTags1)));
  });
  var update4 = /* @__PURE__ */ dual(2, (self, input) => fiberRefGetWith(currentMetricLabels, (tags) => sync(() => self.unsafeUpdate(input, tags))));

  // <eztb>/node_modules/effect/dist/esm/internal/request.js
  var RequestSymbolKey = "effect/Request";
  var RequestTypeId = /* @__PURE__ */ Symbol.for(RequestSymbolKey);
  var requestVariance = {
    /* c8 ignore next */
    _E: (_) => _,
    /* c8 ignore next */
    _A: (_) => _
  };
  var RequestPrototype = {
    ...StructuralPrototype,
    [RequestTypeId]: requestVariance
  };
  var isRequest = (u) => hasProperty(u, RequestTypeId);
  var complete = /* @__PURE__ */ dual(2, (self, result) => fiberRefGetWith(currentRequestMap, (map14) => sync(() => {
    if (map14.has(self)) {
      const entry = map14.get(self);
      if (!entry.state.completed) {
        entry.state.completed = true;
        deferredUnsafeDone(entry.result, result);
      }
    }
  })));
  var Listeners = class {
    constructor() {
      __publicField(this, "count", 0);
      __publicField(this, "observers", /* @__PURE__ */ new Set());
      __publicField(this, "interrupted", false);
    }
    addObserver(f) {
      this.observers.add(f);
    }
    removeObserver(f) {
      this.observers.delete(f);
    }
    increment() {
      this.count++;
      this.observers.forEach((f) => f(this.count));
    }
    decrement() {
      this.count--;
      this.observers.forEach((f) => f(this.count));
    }
  };

  // <eztb>/node_modules/effect/dist/esm/internal/redBlackTree/iterator.js
  var Direction = {
    Forward: 0,
    Backward: 1 << 0
  };
  var RedBlackTreeIterator = class _RedBlackTreeIterator {
    constructor(self, stack, direction) {
      __publicField(this, "self");
      __publicField(this, "stack");
      __publicField(this, "direction");
      __publicField(this, "count", 0);
      this.self = self;
      this.stack = stack;
      this.direction = direction;
    }
    /**
     * Clones the iterator
     */
    clone() {
      return new _RedBlackTreeIterator(this.self, this.stack.slice(), this.direction);
    }
    /**
     * Reverse the traversal direction
     */
    reversed() {
      return new _RedBlackTreeIterator(this.self, this.stack.slice(), this.direction === Direction.Forward ? Direction.Backward : Direction.Forward);
    }
    /**
     * Iterator next
     */
    next() {
      const entry = this.entry;
      this.count++;
      if (this.direction === Direction.Forward) {
        this.moveNext();
      } else {
        this.movePrev();
      }
      switch (entry._tag) {
        case "None": {
          return {
            done: true,
            value: this.count
          };
        }
        case "Some": {
          return {
            done: false,
            value: entry.value
          };
        }
      }
    }
    /**
     * Returns the key
     */
    get key() {
      if (this.stack.length > 0) {
        return some2(this.stack[this.stack.length - 1].key);
      }
      return none2();
    }
    /**
     * Returns the value
     */
    get value() {
      if (this.stack.length > 0) {
        return some2(this.stack[this.stack.length - 1].value);
      }
      return none2();
    }
    /**
     * Returns the key
     */
    get entry() {
      return map2(last(this.stack), (node) => [node.key, node.value]);
    }
    /**
     * Returns the position of this iterator in the sorted list
     */
    get index() {
      let idx = 0;
      const stack = this.stack;
      if (stack.length === 0) {
        const r = this.self._root;
        if (r != null) {
          return r.count;
        }
        return 0;
      } else if (stack[stack.length - 1].left != null) {
        idx = stack[stack.length - 1].left.count;
      }
      for (let s = stack.length - 2; s >= 0; --s) {
        if (stack[s + 1] === stack[s].right) {
          ++idx;
          if (stack[s].left != null) {
            idx += stack[s].left.count;
          }
        }
      }
      return idx;
    }
    /**
     * Advances iterator to next element in list
     */
    moveNext() {
      const stack = this.stack;
      if (stack.length === 0) {
        return;
      }
      let n = stack[stack.length - 1];
      if (n.right != null) {
        n = n.right;
        while (n != null) {
          stack.push(n);
          n = n.left;
        }
      } else {
        stack.pop();
        while (stack.length > 0 && stack[stack.length - 1].right === n) {
          n = stack[stack.length - 1];
          stack.pop();
        }
      }
    }
    /**
     * Checks if there is a next element
     */
    get hasNext() {
      const stack = this.stack;
      if (stack.length === 0) {
        return false;
      }
      if (stack[stack.length - 1].right != null) {
        return true;
      }
      for (let s = stack.length - 1; s > 0; --s) {
        if (stack[s - 1].left === stack[s]) {
          return true;
        }
      }
      return false;
    }
    /**
     * Advances iterator to previous element in list
     */
    movePrev() {
      const stack = this.stack;
      if (stack.length === 0) {
        return;
      }
      let n = stack[stack.length - 1];
      if (n != null && n.left != null) {
        n = n.left;
        while (n != null) {
          stack.push(n);
          n = n.right;
        }
      } else {
        stack.pop();
        while (stack.length > 0 && stack[stack.length - 1].left === n) {
          n = stack[stack.length - 1];
          stack.pop();
        }
      }
    }
    /**
     * Checks if there is a previous element
     */
    get hasPrev() {
      const stack = this.stack;
      if (stack.length === 0) {
        return false;
      }
      if (stack[stack.length - 1].left != null) {
        return true;
      }
      for (let s = stack.length - 1; s > 0; --s) {
        if (stack[s - 1].right === stack[s]) {
          return true;
        }
      }
      return false;
    }
  };

  // <eztb>/node_modules/effect/dist/esm/internal/redBlackTree/node.js
  var Color = {
    Red: 0,
    Black: 1 << 0
  };
  var clone = ({
    color,
    count: count3,
    key,
    left: left3,
    right: right3,
    value
  }) => ({
    color,
    key,
    value,
    left: left3,
    right: right3,
    count: count3
  });
  function swap2(n, v) {
    n.key = v.key;
    n.value = v.value;
    n.left = v.left;
    n.right = v.right;
    n.color = v.color;
    n.count = v.count;
  }
  var repaint = ({
    count: count3,
    key,
    left: left3,
    right: right3,
    value
  }, color) => ({
    color,
    key,
    value,
    left: left3,
    right: right3,
    count: count3
  });
  var recount = (node) => {
    node.count = 1 + (node.left?.count ?? 0) + (node.right?.count ?? 0);
  };

  // <eztb>/node_modules/effect/dist/esm/internal/redBlackTree.js
  var RedBlackTreeSymbolKey = "effect/RedBlackTree";
  var RedBlackTreeTypeId = /* @__PURE__ */ Symbol.for(RedBlackTreeSymbolKey);
  var redBlackTreeVariance = {
    /* c8 ignore next */
    _Key: (_) => _,
    /* c8 ignore next */
    _Value: (_) => _
  };
  var RedBlackTreeProto = {
    [RedBlackTreeTypeId]: redBlackTreeVariance,
    [symbol]() {
      let hash2 = hash(RedBlackTreeSymbolKey);
      for (const item of this) {
        hash2 ^= pipe(hash(item[0]), combine(hash(item[1])));
      }
      return cached(this, hash2);
    },
    [symbol2](that) {
      if (isRedBlackTree(that)) {
        if ((this._root?.count ?? 0) !== (that._root?.count ?? 0)) {
          return false;
        }
        const entries2 = Array.from(that);
        return Array.from(this).every((itemSelf, i) => {
          const itemThat = entries2[i];
          return equals(itemSelf[0], itemThat[0]) && equals(itemSelf[1], itemThat[1]);
        });
      }
      return false;
    },
    [Symbol.iterator]() {
      const stack = [];
      let n = this._root;
      while (n != null) {
        stack.push(n);
        n = n.left;
      }
      return new RedBlackTreeIterator(this, stack, Direction.Forward);
    },
    toString() {
      return format2(this.toJSON());
    },
    toJSON() {
      return {
        _id: "RedBlackTree",
        values: Array.from(this).map(toJSON)
      };
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var makeImpl3 = (ord, root) => {
    const tree = Object.create(RedBlackTreeProto);
    tree._ord = ord;
    tree._root = root;
    return tree;
  };
  var isRedBlackTree = (u) => hasProperty(u, RedBlackTreeTypeId);
  var findFirst4 = /* @__PURE__ */ dual(2, (self, key) => {
    const cmp = self._ord;
    let node = self._root;
    while (node !== void 0) {
      const d = cmp(key, node.key);
      if (equals(key, node.key)) {
        return some2(node.value);
      }
      if (d <= 0) {
        node = node.left;
      } else {
        node = node.right;
      }
    }
    return none2();
  });
  var has5 = /* @__PURE__ */ dual(2, (self, key) => isSome2(findFirst4(self, key)));
  var insert = /* @__PURE__ */ dual(3, (self, key, value) => {
    const cmp = self._ord;
    let n = self._root;
    const n_stack = [];
    const d_stack = [];
    while (n != null) {
      const d = cmp(key, n.key);
      n_stack.push(n);
      d_stack.push(d);
      if (d <= 0) {
        n = n.left;
      } else {
        n = n.right;
      }
    }
    n_stack.push({
      color: Color.Red,
      key,
      value,
      left: void 0,
      right: void 0,
      count: 1
    });
    for (let s = n_stack.length - 2; s >= 0; --s) {
      const n2 = n_stack[s];
      if (d_stack[s] <= 0) {
        n_stack[s] = {
          color: n2.color,
          key: n2.key,
          value: n2.value,
          left: n_stack[s + 1],
          right: n2.right,
          count: n2.count + 1
        };
      } else {
        n_stack[s] = {
          color: n2.color,
          key: n2.key,
          value: n2.value,
          left: n2.left,
          right: n_stack[s + 1],
          count: n2.count + 1
        };
      }
    }
    for (let s = n_stack.length - 1; s > 1; --s) {
      const p = n_stack[s - 1];
      const n3 = n_stack[s];
      if (p.color === Color.Black || n3.color === Color.Black) {
        break;
      }
      const pp = n_stack[s - 2];
      if (pp.left === p) {
        if (p.left === n3) {
          const y = pp.right;
          if (y && y.color === Color.Red) {
            p.color = Color.Black;
            pp.right = repaint(y, Color.Black);
            pp.color = Color.Red;
            s -= 1;
          } else {
            pp.color = Color.Red;
            pp.left = p.right;
            p.color = Color.Black;
            p.right = pp;
            n_stack[s - 2] = p;
            n_stack[s - 1] = n3;
            recount(pp);
            recount(p);
            if (s >= 3) {
              const ppp = n_stack[s - 3];
              if (ppp.left === pp) {
                ppp.left = p;
              } else {
                ppp.right = p;
              }
            }
            break;
          }
        } else {
          const y = pp.right;
          if (y && y.color === Color.Red) {
            p.color = Color.Black;
            pp.right = repaint(y, Color.Black);
            pp.color = Color.Red;
            s -= 1;
          } else {
            p.right = n3.left;
            pp.color = Color.Red;
            pp.left = n3.right;
            n3.color = Color.Black;
            n3.left = p;
            n3.right = pp;
            n_stack[s - 2] = n3;
            n_stack[s - 1] = p;
            recount(pp);
            recount(p);
            recount(n3);
            if (s >= 3) {
              const ppp = n_stack[s - 3];
              if (ppp.left === pp) {
                ppp.left = n3;
              } else {
                ppp.right = n3;
              }
            }
            break;
          }
        }
      } else {
        if (p.right === n3) {
          const y = pp.left;
          if (y && y.color === Color.Red) {
            p.color = Color.Black;
            pp.left = repaint(y, Color.Black);
            pp.color = Color.Red;
            s -= 1;
          } else {
            pp.color = Color.Red;
            pp.right = p.left;
            p.color = Color.Black;
            p.left = pp;
            n_stack[s - 2] = p;
            n_stack[s - 1] = n3;
            recount(pp);
            recount(p);
            if (s >= 3) {
              const ppp = n_stack[s - 3];
              if (ppp.right === pp) {
                ppp.right = p;
              } else {
                ppp.left = p;
              }
            }
            break;
          }
        } else {
          const y = pp.left;
          if (y && y.color === Color.Red) {
            p.color = Color.Black;
            pp.left = repaint(y, Color.Black);
            pp.color = Color.Red;
            s -= 1;
          } else {
            p.left = n3.right;
            pp.color = Color.Red;
            pp.right = n3.left;
            n3.color = Color.Black;
            n3.right = p;
            n3.left = pp;
            n_stack[s - 2] = n3;
            n_stack[s - 1] = p;
            recount(pp);
            recount(p);
            recount(n3);
            if (s >= 3) {
              const ppp = n_stack[s - 3];
              if (ppp.right === pp) {
                ppp.right = n3;
              } else {
                ppp.left = n3;
              }
            }
            break;
          }
        }
      }
    }
    n_stack[0].color = Color.Black;
    return makeImpl3(self._ord, n_stack[0]);
  });
  var keysForward = (self) => keys3(self, Direction.Forward);
  var keys3 = (self, direction) => {
    const begin = self[Symbol.iterator]();
    let count3 = 0;
    return {
      [Symbol.iterator]: () => keys3(self, direction),
      next: () => {
        count3++;
        const entry = begin.key;
        if (direction === Direction.Forward) {
          begin.moveNext();
        } else {
          begin.movePrev();
        }
        switch (entry._tag) {
          case "None": {
            return {
              done: true,
              value: count3
            };
          }
          case "Some": {
            return {
              done: false,
              value: entry.value
            };
          }
        }
      }
    };
  };
  var removeFirst = /* @__PURE__ */ dual(2, (self, key) => {
    if (!has5(self, key)) {
      return self;
    }
    const ord = self._ord;
    const cmp = ord;
    let node = self._root;
    const stack = [];
    while (node !== void 0) {
      const d = cmp(key, node.key);
      stack.push(node);
      if (equals(key, node.key)) {
        node = void 0;
      } else if (d <= 0) {
        node = node.left;
      } else {
        node = node.right;
      }
    }
    if (stack.length === 0) {
      return self;
    }
    const cstack = new Array(stack.length);
    let n = stack[stack.length - 1];
    cstack[cstack.length - 1] = {
      color: n.color,
      key: n.key,
      value: n.value,
      left: n.left,
      right: n.right,
      count: n.count
    };
    for (let i = stack.length - 2; i >= 0; --i) {
      n = stack[i];
      if (n.left === stack[i + 1]) {
        cstack[i] = {
          color: n.color,
          key: n.key,
          value: n.value,
          left: cstack[i + 1],
          right: n.right,
          count: n.count
        };
      } else {
        cstack[i] = {
          color: n.color,
          key: n.key,
          value: n.value,
          left: n.left,
          right: cstack[i + 1],
          count: n.count
        };
      }
    }
    n = cstack[cstack.length - 1];
    if (n.left !== void 0 && n.right !== void 0) {
      const split = cstack.length;
      n = n.left;
      while (n.right != null) {
        cstack.push(n);
        n = n.right;
      }
      const v = cstack[split - 1];
      cstack.push({
        color: n.color,
        key: v.key,
        value: v.value,
        left: n.left,
        right: n.right,
        count: n.count
      });
      cstack[split - 1].key = n.key;
      cstack[split - 1].value = n.value;
      for (let i = cstack.length - 2; i >= split; --i) {
        n = cstack[i];
        cstack[i] = {
          color: n.color,
          key: n.key,
          value: n.value,
          left: n.left,
          right: cstack[i + 1],
          count: n.count
        };
      }
      cstack[split - 1].left = cstack[split];
    }
    n = cstack[cstack.length - 1];
    if (n.color === Color.Red) {
      const p = cstack[cstack.length - 2];
      if (p.left === n) {
        p.left = void 0;
      } else if (p.right === n) {
        p.right = void 0;
      }
      cstack.pop();
      for (let i = 0; i < cstack.length; ++i) {
        cstack[i].count--;
      }
      return makeImpl3(ord, cstack[0]);
    } else {
      if (n.left !== void 0 || n.right !== void 0) {
        if (n.left !== void 0) {
          swap2(n, n.left);
        } else if (n.right !== void 0) {
          swap2(n, n.right);
        }
        n.color = Color.Black;
        for (let i = 0; i < cstack.length - 1; ++i) {
          cstack[i].count--;
        }
        return makeImpl3(ord, cstack[0]);
      } else if (cstack.length === 1) {
        return makeImpl3(ord, void 0);
      } else {
        for (let i = 0; i < cstack.length; ++i) {
          cstack[i].count--;
        }
        const parent = cstack[cstack.length - 2];
        fixDoubleBlack(cstack);
        if (parent.left === n) {
          parent.left = void 0;
        } else {
          parent.right = void 0;
        }
      }
    }
    return makeImpl3(ord, cstack[0]);
  });
  var fixDoubleBlack = (stack) => {
    let n, p, s, z;
    for (let i = stack.length - 1; i >= 0; --i) {
      n = stack[i];
      if (i === 0) {
        n.color = Color.Black;
        return;
      }
      p = stack[i - 1];
      if (p.left === n) {
        s = p.right;
        if (s !== void 0 && s.right !== void 0 && s.right.color === Color.Red) {
          s = p.right = clone(s);
          z = s.right = clone(s.right);
          p.right = s.left;
          s.left = p;
          s.right = z;
          s.color = p.color;
          n.color = Color.Black;
          p.color = Color.Black;
          z.color = Color.Black;
          recount(p);
          recount(s);
          if (i > 1) {
            const pp = stack[i - 2];
            if (pp.left === p) {
              pp.left = s;
            } else {
              pp.right = s;
            }
          }
          stack[i - 1] = s;
          return;
        } else if (s !== void 0 && s.left !== void 0 && s.left.color === Color.Red) {
          s = p.right = clone(s);
          z = s.left = clone(s.left);
          p.right = z.left;
          s.left = z.right;
          z.left = p;
          z.right = s;
          z.color = p.color;
          p.color = Color.Black;
          s.color = Color.Black;
          n.color = Color.Black;
          recount(p);
          recount(s);
          recount(z);
          if (i > 1) {
            const pp = stack[i - 2];
            if (pp.left === p) {
              pp.left = z;
            } else {
              pp.right = z;
            }
          }
          stack[i - 1] = z;
          return;
        }
        if (s !== void 0 && s.color === Color.Black) {
          if (p.color === Color.Red) {
            p.color = Color.Black;
            p.right = repaint(s, Color.Red);
            return;
          } else {
            p.right = repaint(s, Color.Red);
            continue;
          }
        } else if (s !== void 0) {
          s = clone(s);
          p.right = s.left;
          s.left = p;
          s.color = p.color;
          p.color = Color.Red;
          recount(p);
          recount(s);
          if (i > 1) {
            const pp = stack[i - 2];
            if (pp.left === p) {
              pp.left = s;
            } else {
              pp.right = s;
            }
          }
          stack[i - 1] = s;
          stack[i] = p;
          if (i + 1 < stack.length) {
            stack[i + 1] = n;
          } else {
            stack.push(n);
          }
          i = i + 2;
        }
      } else {
        s = p.left;
        if (s !== void 0 && s.left !== void 0 && s.left.color === Color.Red) {
          s = p.left = clone(s);
          z = s.left = clone(s.left);
          p.left = s.right;
          s.right = p;
          s.left = z;
          s.color = p.color;
          n.color = Color.Black;
          p.color = Color.Black;
          z.color = Color.Black;
          recount(p);
          recount(s);
          if (i > 1) {
            const pp = stack[i - 2];
            if (pp.right === p) {
              pp.right = s;
            } else {
              pp.left = s;
            }
          }
          stack[i - 1] = s;
          return;
        } else if (s !== void 0 && s.right !== void 0 && s.right.color === Color.Red) {
          s = p.left = clone(s);
          z = s.right = clone(s.right);
          p.left = z.right;
          s.right = z.left;
          z.right = p;
          z.left = s;
          z.color = p.color;
          p.color = Color.Black;
          s.color = Color.Black;
          n.color = Color.Black;
          recount(p);
          recount(s);
          recount(z);
          if (i > 1) {
            const pp = stack[i - 2];
            if (pp.right === p) {
              pp.right = z;
            } else {
              pp.left = z;
            }
          }
          stack[i - 1] = z;
          return;
        }
        if (s !== void 0 && s.color === Color.Black) {
          if (p.color === Color.Red) {
            p.color = Color.Black;
            p.left = repaint(s, Color.Red);
            return;
          } else {
            p.left = repaint(s, Color.Red);
            continue;
          }
        } else if (s !== void 0) {
          s = clone(s);
          p.left = s.right;
          s.right = p;
          s.color = p.color;
          p.color = Color.Red;
          recount(p);
          recount(s);
          if (i > 1) {
            const pp = stack[i - 2];
            if (pp.right === p) {
              pp.right = s;
            } else {
              pp.left = s;
            }
          }
          stack[i - 1] = s;
          stack[i] = p;
          if (i + 1 < stack.length) {
            stack[i + 1] = n;
          } else {
            stack.push(n);
          }
          i = i + 2;
        }
      }
    }
  };

  // <eztb>/node_modules/effect/dist/esm/RedBlackTree.js
  var has6 = has5;
  var insert2 = insert;
  var keys4 = keysForward;
  var removeFirst2 = removeFirst;

  // <eztb>/node_modules/effect/dist/esm/SortedSet.js
  var TypeId15 = /* @__PURE__ */ Symbol.for("effect/SortedSet");
  var SortedSetProto = {
    [TypeId15]: {
      _A: (_) => _
    },
    [symbol]() {
      return pipe(hash(this.keyTree), combine(hash(TypeId15)), cached(this));
    },
    [symbol2](that) {
      return isSortedSet(that) && equals(this.keyTree, that.keyTree);
    },
    [Symbol.iterator]() {
      return keys4(this.keyTree);
    },
    toString() {
      return format2(this.toJSON());
    },
    toJSON() {
      return {
        _id: "SortedSet",
        values: Array.from(this).map(toJSON)
      };
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var fromTree = (keyTree) => {
    const a = Object.create(SortedSetProto);
    a.keyTree = keyTree;
    return a;
  };
  var isSortedSet = (u) => hasProperty(u, TypeId15);
  var add5 = /* @__PURE__ */ dual(2, (self, value) => has6(self.keyTree, value) ? self : fromTree(insert2(self.keyTree, value, true)));
  var remove7 = /* @__PURE__ */ dual(2, (self, value) => fromTree(removeFirst2(self.keyTree, value)));

  // <eztb>/node_modules/effect/dist/esm/internal/supervisor.js
  var SupervisorSymbolKey = "effect/Supervisor";
  var SupervisorTypeId = /* @__PURE__ */ Symbol.for(SupervisorSymbolKey);
  var supervisorVariance = {
    /* c8 ignore next */
    _T: (_) => _
  };
  var _a39;
  _a39 = SupervisorTypeId;
  var _ProxySupervisor = class _ProxySupervisor {
    constructor(underlying, value0) {
      __publicField(this, "underlying");
      __publicField(this, "value0");
      __publicField(this, _a39, supervisorVariance);
      this.underlying = underlying;
      this.value0 = value0;
    }
    get value() {
      return this.value0;
    }
    onStart(context4, effect, parent, fiber) {
      this.underlying.onStart(context4, effect, parent, fiber);
    }
    onEnd(value, fiber) {
      this.underlying.onEnd(value, fiber);
    }
    onEffect(fiber, effect) {
      this.underlying.onEffect(fiber, effect);
    }
    onSuspend(fiber) {
      this.underlying.onSuspend(fiber);
    }
    onResume(fiber) {
      this.underlying.onResume(fiber);
    }
    map(f) {
      return new _ProxySupervisor(this, pipe(this.value, map9(f)));
    }
    zip(right3) {
      return new Zip(this, right3);
    }
  };
  var ProxySupervisor = _ProxySupervisor;
  var _a40;
  _a40 = SupervisorTypeId;
  var _Zip = class _Zip {
    constructor(left3, right3) {
      __publicField(this, "left");
      __publicField(this, "right");
      __publicField(this, "_tag", "Zip");
      __publicField(this, _a40, supervisorVariance);
      this.left = left3;
      this.right = right3;
    }
    get value() {
      return zip2(this.left.value, this.right.value);
    }
    onStart(context4, effect, parent, fiber) {
      this.left.onStart(context4, effect, parent, fiber);
      this.right.onStart(context4, effect, parent, fiber);
    }
    onEnd(value, fiber) {
      this.left.onEnd(value, fiber);
      this.right.onEnd(value, fiber);
    }
    onEffect(fiber, effect) {
      this.left.onEffect(fiber, effect);
      this.right.onEffect(fiber, effect);
    }
    onSuspend(fiber) {
      this.left.onSuspend(fiber);
      this.right.onSuspend(fiber);
    }
    onResume(fiber) {
      this.left.onResume(fiber);
      this.right.onResume(fiber);
    }
    map(f) {
      return new ProxySupervisor(this, pipe(this.value, map9(f)));
    }
    zip(right3) {
      return new _Zip(this, right3);
    }
  };
  var Zip = _Zip;
  var isZip = (self) => hasProperty(self, SupervisorTypeId) && isTagged(self, "Zip");
  var _a41;
  _a41 = SupervisorTypeId;
  var Track = class {
    constructor() {
      __publicField(this, _a41, supervisorVariance);
      __publicField(this, "fibers", /* @__PURE__ */ new Set());
    }
    get value() {
      return sync(() => Array.from(this.fibers));
    }
    onStart(_context, _effect, _parent, fiber) {
      this.fibers.add(fiber);
    }
    onEnd(_value2, fiber) {
      this.fibers.delete(fiber);
    }
    onEffect(_fiber, _effect) {
    }
    onSuspend(_fiber) {
    }
    onResume(_fiber) {
    }
    map(f) {
      return new ProxySupervisor(this, pipe(this.value, map9(f)));
    }
    zip(right3) {
      return new Zip(this, right3);
    }
    onRun(execution, _fiber) {
      return execution();
    }
  };
  var _a42;
  _a42 = SupervisorTypeId;
  var Const = class {
    constructor(effect) {
      __publicField(this, "effect");
      __publicField(this, _a42, supervisorVariance);
      this.effect = effect;
    }
    get value() {
      return this.effect;
    }
    onStart(_context, _effect, _parent, _fiber) {
    }
    onEnd(_value2, _fiber) {
    }
    onEffect(_fiber, _effect) {
    }
    onSuspend(_fiber) {
    }
    onResume(_fiber) {
    }
    map(f) {
      return new ProxySupervisor(this, pipe(this.value, map9(f)));
    }
    zip(right3) {
      return new Zip(this, right3);
    }
    onRun(execution, _fiber) {
      return execution();
    }
  };
  var _a43;
  _a43 = SupervisorTypeId;
  var FibersIn = class {
    constructor(ref) {
      __publicField(this, "ref");
      __publicField(this, _a43, supervisorVariance);
      this.ref = ref;
    }
    get value() {
      return sync(() => get6(this.ref));
    }
    onStart(_context, _effect, _parent, fiber) {
      pipe(this.ref, set2(pipe(get6(this.ref), add5(fiber))));
    }
    onEnd(_value2, fiber) {
      pipe(this.ref, set2(pipe(get6(this.ref), remove7(fiber))));
    }
    onEffect(_fiber, _effect) {
    }
    onSuspend(_fiber) {
    }
    onResume(_fiber) {
    }
    map(f) {
      return new ProxySupervisor(this, pipe(this.value, map9(f)));
    }
    zip(right3) {
      return new Zip(this, right3);
    }
    onRun(execution, _fiber) {
      return execution();
    }
  };
  var unsafeTrack = () => {
    return new Track();
  };
  var track = /* @__PURE__ */ sync(unsafeTrack);
  var fromEffect = (effect) => {
    return new Const(effect);
  };
  var none8 = /* @__PURE__ */ globalValue("effect/Supervisor/none", () => fromEffect(void_2));

  // <eztb>/node_modules/effect/dist/esm/Differ.js
  var make33 = make14;

  // <eztb>/node_modules/effect/dist/esm/internal/supervisor/patch.js
  var OP_EMPTY3 = "Empty";
  var OP_ADD_SUPERVISOR = "AddSupervisor";
  var OP_REMOVE_SUPERVISOR = "RemoveSupervisor";
  var OP_AND_THEN2 = "AndThen";
  var empty25 = {
    _tag: OP_EMPTY3
  };
  var combine8 = (self, that) => {
    return {
      _tag: OP_AND_THEN2,
      first: self,
      second: that
    };
  };
  var patch8 = (self, supervisor) => {
    return patchLoop(supervisor, of2(self));
  };
  var patchLoop = (_supervisor, _patches) => {
    let supervisor = _supervisor;
    let patches = _patches;
    while (isNonEmpty(patches)) {
      const head5 = headNonEmpty2(patches);
      switch (head5._tag) {
        case OP_EMPTY3: {
          patches = tailNonEmpty2(patches);
          break;
        }
        case OP_ADD_SUPERVISOR: {
          supervisor = supervisor.zip(head5.supervisor);
          patches = tailNonEmpty2(patches);
          break;
        }
        case OP_REMOVE_SUPERVISOR: {
          supervisor = removeSupervisor(supervisor, head5.supervisor);
          patches = tailNonEmpty2(patches);
          break;
        }
        case OP_AND_THEN2: {
          patches = prepend2(head5.first)(prepend2(head5.second)(tailNonEmpty2(patches)));
          break;
        }
      }
    }
    return supervisor;
  };
  var removeSupervisor = (self, that) => {
    if (equals(self, that)) {
      return none8;
    } else {
      if (isZip(self)) {
        return removeSupervisor(self.left, that).zip(removeSupervisor(self.right, that));
      } else {
        return self;
      }
    }
  };
  var toSet2 = (self) => {
    if (equals(self, none8)) {
      return empty7();
    } else {
      if (isZip(self)) {
        return pipe(toSet2(self.left), union3(toSet2(self.right)));
      } else {
        return make10(self);
      }
    }
  };
  var diff7 = (oldValue, newValue) => {
    if (equals(oldValue, newValue)) {
      return empty25;
    }
    const oldSupervisors = toSet2(oldValue);
    const newSupervisors = toSet2(newValue);
    const added = pipe(newSupervisors, difference3(oldSupervisors), reduce4(empty25, (patch9, supervisor) => combine8(patch9, {
      _tag: OP_ADD_SUPERVISOR,
      supervisor
    })));
    const removed = pipe(oldSupervisors, difference3(newSupervisors), reduce4(empty25, (patch9, supervisor) => combine8(patch9, {
      _tag: OP_REMOVE_SUPERVISOR,
      supervisor
    })));
    return combine8(added, removed);
  };
  var differ2 = /* @__PURE__ */ make33({
    empty: empty25,
    patch: patch8,
    combine: combine8,
    diff: diff7
  });

  // <eztb>/node_modules/effect/dist/esm/internal/fiberRuntime.js
  var fiberStarted = /* @__PURE__ */ counter5("effect_fiber_started", {
    incremental: true
  });
  var fiberActive = /* @__PURE__ */ counter5("effect_fiber_active");
  var fiberSuccesses = /* @__PURE__ */ counter5("effect_fiber_successes", {
    incremental: true
  });
  var fiberFailures = /* @__PURE__ */ counter5("effect_fiber_failures", {
    incremental: true
  });
  var fiberLifetimes = /* @__PURE__ */ tagged(/* @__PURE__ */ histogram5("effect_fiber_lifetimes", /* @__PURE__ */ exponential({
    start: 0.5,
    factor: 2,
    count: 35
  })), "time_unit", "milliseconds");
  var EvaluationSignalContinue = "Continue";
  var EvaluationSignalDone = "Done";
  var EvaluationSignalYieldNow = "Yield";
  var runtimeFiberVariance = {
    /* c8 ignore next */
    _E: (_) => _,
    /* c8 ignore next */
    _A: (_) => _
  };
  var absurd = (_) => {
    throw new Error(`BUG: FiberRuntime - ${toStringUnknown(_)} - please report an issue at https://github.com/Effect-TS/effect/issues`);
  };
  var YieldedOp = /* @__PURE__ */ Symbol.for("effect/internal/fiberRuntime/YieldedOp");
  var yieldedOpChannel = /* @__PURE__ */ globalValue("effect/internal/fiberRuntime/yieldedOpChannel", () => ({
    currentOp: null
  }));
  var contOpSuccess = {
    [OP_ON_SUCCESS]: (_, cont, value) => {
      return internalCall(() => cont.effect_instruction_i1(value));
    },
    ["OnStep"]: (_, _cont, value) => {
      return exitSucceed(exitSucceed(value));
    },
    [OP_ON_SUCCESS_AND_FAILURE]: (_, cont, value) => {
      return internalCall(() => cont.effect_instruction_i2(value));
    },
    [OP_REVERT_FLAGS]: (self, cont, value) => {
      self.patchRuntimeFlags(self.currentRuntimeFlags, cont.patch);
      if (interruptible(self.currentRuntimeFlags) && self.isInterrupted()) {
        return exitFailCause(self.getInterruptedCause());
      } else {
        return exitSucceed(value);
      }
    },
    [OP_WHILE]: (self, cont, value) => {
      internalCall(() => cont.effect_instruction_i2(value));
      if (internalCall(() => cont.effect_instruction_i0())) {
        self.pushStack(cont);
        return internalCall(() => cont.effect_instruction_i1());
      } else {
        return void_2;
      }
    },
    [OP_ITERATOR]: (self, cont, value) => {
      while (true) {
        const state = internalCall(() => cont.effect_instruction_i0.next(value));
        if (state.done) {
          return exitSucceed(state.value);
        }
        const primitive = yieldWrapGet(state.value);
        if (!exitIsExit(primitive)) {
          self.pushStack(cont);
          return primitive;
        } else if (primitive._tag === "Failure") {
          return primitive;
        }
        value = primitive.value;
      }
    }
  };
  var drainQueueWhileRunningTable = {
    [OP_INTERRUPT_SIGNAL]: (self, runtimeFlags2, cur, message) => {
      self.processNewInterruptSignal(message.cause);
      return interruptible(runtimeFlags2) ? exitFailCause(message.cause) : cur;
    },
    [OP_RESUME]: (_self, _runtimeFlags, _cur, _message) => {
      throw new Error("It is illegal to have multiple concurrent run loops in a single fiber");
    },
    [OP_STATEFUL]: (self, runtimeFlags2, cur, message) => {
      message.onFiber(self, running2(runtimeFlags2));
      return cur;
    },
    [OP_YIELD_NOW]: (_self, _runtimeFlags, cur, _message) => {
      return flatMap8(yieldNow(), () => cur);
    }
  };
  var runBlockedRequests = (self) => forEachSequentialDiscard(flatten2(self), (requestsByRequestResolver) => forEachConcurrentDiscard(sequentialCollectionToChunk(requestsByRequestResolver), ([dataSource, sequential4]) => {
    const map14 = /* @__PURE__ */ new Map();
    const arr = [];
    for (const block of sequential4) {
      arr.push(toReadonlyArray(block));
      for (const entry of block) {
        map14.set(entry.request, entry);
      }
    }
    const flat = arr.flat();
    return fiberRefLocally(invokeWithInterrupt(dataSource.runAll(arr), flat, () => flat.forEach((entry) => {
      entry.listeners.interrupted = true;
    })), currentRequestMap, map14);
  }, false, false));
  var _version = /* @__PURE__ */ getCurrentVersion();
  var _a44, _b12;
  var FiberRuntime = class extends Class2 {
    constructor(fiberId3, fiberRefs0, runtimeFlags0) {
      super();
      __publicField(this, _b12, fiberVariance2);
      __publicField(this, _a44, runtimeFiberVariance);
      __publicField(this, "_fiberRefs");
      __publicField(this, "_fiberId");
      __publicField(this, "_queue", /* @__PURE__ */ new Array());
      __publicField(this, "_children", null);
      __publicField(this, "_observers", /* @__PURE__ */ new Array());
      __publicField(this, "_running", false);
      __publicField(this, "_stack", []);
      __publicField(this, "_asyncInterruptor", null);
      __publicField(this, "_asyncBlockingOn", null);
      __publicField(this, "_exitValue", null);
      __publicField(this, "_steps", []);
      __publicField(this, "_isYielding", false);
      __publicField(this, "currentRuntimeFlags");
      __publicField(this, "currentOpCount", 0);
      __publicField(this, "currentSupervisor");
      __publicField(this, "currentScheduler");
      __publicField(this, "currentTracer");
      __publicField(this, "currentSpan");
      __publicField(this, "currentContext");
      __publicField(this, "currentDefaultServices");
      __publicField(this, "run", () => {
        this.drainQueueOnCurrentThread();
      });
      this.currentRuntimeFlags = runtimeFlags0;
      this._fiberId = fiberId3;
      this._fiberRefs = fiberRefs0;
      if (runtimeMetrics(runtimeFlags0)) {
        const tags = this.getFiberRef(currentMetricLabels);
        fiberStarted.unsafeUpdate(1, tags);
        fiberActive.unsafeUpdate(1, tags);
      }
      this.refreshRefCache();
    }
    commit() {
      return join2(this);
    }
    /**
     * The identity of the fiber.
     */
    id() {
      return this._fiberId;
    }
    /**
     * Begins execution of the effect associated with this fiber on in the
     * background. This can be called to "kick off" execution of a fiber after
     * it has been created.
     */
    resume(effect) {
      this.tell(resume(effect));
    }
    /**
     * The status of the fiber.
     */
    get status() {
      return this.ask((_, status) => status);
    }
    /**
     * Gets the fiber runtime flags.
     */
    get runtimeFlags() {
      return this.ask((state, status) => {
        if (isDone2(status)) {
          return state.currentRuntimeFlags;
        }
        return status.runtimeFlags;
      });
    }
    /**
     * Returns the current `FiberScope` for the fiber.
     */
    scope() {
      return unsafeMake6(this);
    }
    /**
     * Retrieves the immediate children of the fiber.
     */
    get children() {
      return this.ask((fiber) => Array.from(fiber.getChildren()));
    }
    /**
     * Gets the fiber's set of children.
     */
    getChildren() {
      if (this._children === null) {
        this._children = /* @__PURE__ */ new Set();
      }
      return this._children;
    }
    /**
     * Retrieves the interrupted cause of the fiber, which will be `Cause.empty`
     * if the fiber has not been interrupted.
     *
     * **NOTE**: This method is safe to invoke on any fiber, but if not invoked
     * on this fiber, then values derived from the fiber's state (including the
     * log annotations and log level) may not be up-to-date.
     */
    getInterruptedCause() {
      return this.getFiberRef(currentInterruptedCause);
    }
    /**
     * Retrieves the whole set of fiber refs.
     */
    fiberRefs() {
      return this.ask((fiber) => fiber.getFiberRefs());
    }
    /**
     * Returns an effect that will contain information computed from the fiber
     * state and status while running on the fiber.
     *
     * This allows the outside world to interact safely with mutable fiber state
     * without locks or immutable data.
     */
    ask(f) {
      return suspend(() => {
        const deferred = deferredUnsafeMake(this._fiberId);
        this.tell(stateful((fiber, status) => {
          deferredUnsafeDone(deferred, sync(() => f(fiber, status)));
        }));
        return deferredAwait(deferred);
      });
    }
    /**
     * Adds a message to be processed by the fiber on the fiber.
     */
    tell(message) {
      this._queue.push(message);
      if (!this._running) {
        this._running = true;
        this.drainQueueLaterOnExecutor();
      }
    }
    get await() {
      return async_((resume2) => {
        const cb = (exit4) => resume2(succeed(exit4));
        this.tell(stateful((fiber, _) => {
          if (fiber._exitValue !== null) {
            cb(this._exitValue);
          } else {
            fiber.addObserver(cb);
          }
        }));
        return sync(() => this.tell(stateful((fiber, _) => {
          fiber.removeObserver(cb);
        })));
      }, this.id());
    }
    get inheritAll() {
      return withFiberRuntime((parentFiber, parentStatus) => {
        const parentFiberId = parentFiber.id();
        const parentFiberRefs = parentFiber.getFiberRefs();
        const parentRuntimeFlags = parentStatus.runtimeFlags;
        const childFiberRefs = this.getFiberRefs();
        const updatedFiberRefs = joinAs(parentFiberRefs, parentFiberId, childFiberRefs);
        parentFiber.setFiberRefs(updatedFiberRefs);
        const updatedRuntimeFlags = parentFiber.getFiberRef(currentRuntimeFlags);
        const patch9 = pipe(
          diff4(parentRuntimeFlags, updatedRuntimeFlags),
          // Do not inherit WindDown or Interruption!
          exclude2(Interruption),
          exclude2(WindDown)
        );
        return updateRuntimeFlags(patch9);
      });
    }
    /**
     * Tentatively observes the fiber, but returns immediately if it is not
     * already done.
     */
    get poll() {
      return sync(() => fromNullable2(this._exitValue));
    }
    /**
     * Unsafely observes the fiber, but returns immediately if it is not
     * already done.
     */
    unsafePoll() {
      return this._exitValue;
    }
    /**
     * In the background, interrupts the fiber as if interrupted from the specified fiber.
     */
    interruptAsFork(fiberId3) {
      return sync(() => this.tell(interruptSignal(interrupt(fiberId3))));
    }
    /**
     * In the background, interrupts the fiber as if interrupted from the specified fiber.
     */
    unsafeInterruptAsFork(fiberId3) {
      this.tell(interruptSignal(interrupt(fiberId3)));
    }
    /**
     * Adds an observer to the list of observers.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    addObserver(observer) {
      if (this._exitValue !== null) {
        observer(this._exitValue);
      } else {
        this._observers.push(observer);
      }
    }
    /**
     * Removes the specified observer from the list of observers that will be
     * notified when the fiber exits.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    removeObserver(observer) {
      this._observers = this._observers.filter((o) => o !== observer);
    }
    /**
     * Retrieves all fiber refs of the fiber.
     *
     * **NOTE**: This method is safe to invoke on any fiber, but if not invoked
     * on this fiber, then values derived from the fiber's state (including the
     * log annotations and log level) may not be up-to-date.
     */
    getFiberRefs() {
      this.setFiberRef(currentRuntimeFlags, this.currentRuntimeFlags);
      return this._fiberRefs;
    }
    /**
     * Deletes the specified fiber ref.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    unsafeDeleteFiberRef(fiberRef) {
      this._fiberRefs = delete_(this._fiberRefs, fiberRef);
    }
    /**
     * Retrieves the state of the fiber ref, or else its initial value.
     *
     * **NOTE**: This method is safe to invoke on any fiber, but if not invoked
     * on this fiber, then values derived from the fiber's state (including the
     * log annotations and log level) may not be up-to-date.
     */
    getFiberRef(fiberRef) {
      if (this._fiberRefs.locals.has(fiberRef)) {
        return this._fiberRefs.locals.get(fiberRef)[0][1];
      }
      return fiberRef.initial;
    }
    /**
     * Sets the fiber ref to the specified value.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    setFiberRef(fiberRef, value) {
      this._fiberRefs = updateAs(this._fiberRefs, {
        fiberId: this._fiberId,
        fiberRef,
        value
      });
      this.refreshRefCache();
    }
    refreshRefCache() {
      this.currentDefaultServices = this.getFiberRef(currentServices);
      this.currentTracer = this.currentDefaultServices.unsafeMap.get(tracerTag.key);
      this.currentSupervisor = this.getFiberRef(currentSupervisor);
      this.currentScheduler = this.getFiberRef(currentScheduler);
      this.currentContext = this.getFiberRef(currentContext);
      this.currentSpan = this.currentContext.unsafeMap.get(spanTag.key);
    }
    /**
     * Wholesale replaces all fiber refs of this fiber.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    setFiberRefs(fiberRefs3) {
      this._fiberRefs = fiberRefs3;
      this.refreshRefCache();
    }
    /**
     * Adds a reference to the specified fiber inside the children set.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    addChild(child) {
      this.getChildren().add(child);
    }
    /**
     * Removes a reference to the specified fiber inside the children set.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    removeChild(child) {
      this.getChildren().delete(child);
    }
    /**
     * Transfers all children of this fiber that are currently running to the
     * specified fiber scope.
     *
     * **NOTE**: This method must be invoked by the fiber itself after it has
     * evaluated the effects but prior to exiting.
     */
    transferChildren(scope3) {
      const children = this._children;
      this._children = null;
      if (children !== null && children.size > 0) {
        for (const child of children) {
          if (child._exitValue === null) {
            scope3.add(this.currentRuntimeFlags, child);
          }
        }
      }
    }
    /**
     * On the current thread, executes all messages in the fiber's inbox. This
     * method may return before all work is done, in the event the fiber executes
     * an asynchronous operation.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    drainQueueOnCurrentThread() {
      let recurse = true;
      while (recurse) {
        let evaluationSignal = EvaluationSignalContinue;
        const prev = globalThis[currentFiberURI];
        globalThis[currentFiberURI] = this;
        try {
          while (evaluationSignal === EvaluationSignalContinue) {
            evaluationSignal = this._queue.length === 0 ? EvaluationSignalDone : this.evaluateMessageWhileSuspended(this._queue.splice(0, 1)[0]);
          }
        } finally {
          this._running = false;
          globalThis[currentFiberURI] = prev;
        }
        if (this._queue.length > 0 && !this._running) {
          this._running = true;
          if (evaluationSignal === EvaluationSignalYieldNow) {
            this.drainQueueLaterOnExecutor();
            recurse = false;
          } else {
            recurse = true;
          }
        } else {
          recurse = false;
        }
      }
    }
    /**
     * Schedules the execution of all messages in the fiber's inbox.
     *
     * This method will return immediately after the scheduling
     * operation is completed, but potentially before such messages have been
     * executed.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    drainQueueLaterOnExecutor() {
      this.currentScheduler.scheduleTask(this.run, this.getFiberRef(currentSchedulingPriority));
    }
    /**
     * Drains the fiber's message queue while the fiber is actively running,
     * returning the next effect to execute, which may be the input effect if no
     * additional effect needs to be executed.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    drainQueueWhileRunning(runtimeFlags2, cur0) {
      let cur = cur0;
      while (this._queue.length > 0) {
        const message = this._queue.splice(0, 1)[0];
        cur = drainQueueWhileRunningTable[message._tag](this, runtimeFlags2, cur, message);
      }
      return cur;
    }
    /**
     * Determines if the fiber is interrupted.
     *
     * **NOTE**: This method is safe to invoke on any fiber, but if not invoked
     * on this fiber, then values derived from the fiber's state (including the
     * log annotations and log level) may not be up-to-date.
     */
    isInterrupted() {
      return !isEmpty5(this.getFiberRef(currentInterruptedCause));
    }
    /**
     * Adds an interruptor to the set of interruptors that are interrupting this
     * fiber.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    addInterruptedCause(cause3) {
      const oldSC = this.getFiberRef(currentInterruptedCause);
      this.setFiberRef(currentInterruptedCause, sequential(oldSC, cause3));
    }
    /**
     * Processes a new incoming interrupt signal.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    processNewInterruptSignal(cause3) {
      this.addInterruptedCause(cause3);
      this.sendInterruptSignalToAllChildren();
    }
    /**
     * Interrupts all children of the current fiber, returning an effect that will
     * await the exit of the children. This method will return null if the fiber
     * has no children.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    sendInterruptSignalToAllChildren() {
      if (this._children === null || this._children.size === 0) {
        return false;
      }
      let told = false;
      for (const child of this._children) {
        child.tell(interruptSignal(interrupt(this.id())));
        told = true;
      }
      return told;
    }
    /**
     * Interrupts all children of the current fiber, returning an effect that will
     * await the exit of the children. This method will return null if the fiber
     * has no children.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    interruptAllChildren() {
      if (this.sendInterruptSignalToAllChildren()) {
        const it = this._children.values();
        this._children = null;
        let isDone5 = false;
        const body = () => {
          const next4 = it.next();
          if (!next4.done) {
            return asVoid(next4.value.await);
          } else {
            return sync(() => {
              isDone5 = true;
            });
          }
        };
        return whileLoop({
          while: () => !isDone5,
          body,
          step: () => {
          }
        });
      }
      return null;
    }
    reportExitValue(exit4) {
      if (runtimeMetrics(this.currentRuntimeFlags)) {
        const tags = this.getFiberRef(currentMetricLabels);
        const startTimeMillis = this.id().startTimeMillis;
        const endTimeMillis = Date.now();
        fiberLifetimes.unsafeUpdate(endTimeMillis - startTimeMillis, tags);
        fiberActive.unsafeUpdate(-1, tags);
        switch (exit4._tag) {
          case OP_SUCCESS: {
            fiberSuccesses.unsafeUpdate(1, tags);
            break;
          }
          case OP_FAILURE: {
            fiberFailures.unsafeUpdate(1, tags);
            break;
          }
        }
      }
      if (exit4._tag === "Failure") {
        const level = this.getFiberRef(currentUnhandledErrorLogLevel);
        if (!isInterruptedOnly(exit4.cause) && level._tag === "Some") {
          this.log("Fiber terminated with an unhandled error", exit4.cause, level);
        }
      }
    }
    setExitValue(exit4) {
      this._exitValue = exit4;
      this.reportExitValue(exit4);
      for (let i = this._observers.length - 1; i >= 0; i--) {
        this._observers[i](exit4);
      }
      this._observers = [];
    }
    getLoggers() {
      return this.getFiberRef(currentLoggers);
    }
    log(message, cause3, overrideLogLevel) {
      const logLevel = isSome2(overrideLogLevel) ? overrideLogLevel.value : this.getFiberRef(currentLogLevel);
      const minimumLogLevel = this.getFiberRef(currentMinimumLogLevel);
      if (greaterThan3(minimumLogLevel, logLevel)) {
        return;
      }
      const spans = this.getFiberRef(currentLogSpan);
      const annotations = this.getFiberRef(currentLogAnnotations);
      const loggers = this.getLoggers();
      const contextMap = this.getFiberRefs();
      if (size3(loggers) > 0) {
        const clockService = get3(this.getFiberRef(currentServices), clockTag);
        const date = new Date(clockService.unsafeCurrentTimeMillis());
        withRedactableContext(contextMap, () => {
          for (const logger of loggers) {
            logger.log({
              fiberId: this.id(),
              logLevel,
              message,
              cause: cause3,
              context: contextMap,
              spans,
              annotations,
              date
            });
          }
        });
      }
    }
    /**
     * Evaluates a single message on the current thread, while the fiber is
     * suspended. This method should only be called while evaluation of the
     * fiber's effect is suspended due to an asynchronous operation.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    evaluateMessageWhileSuspended(message) {
      switch (message._tag) {
        case OP_YIELD_NOW: {
          return EvaluationSignalYieldNow;
        }
        case OP_INTERRUPT_SIGNAL: {
          this.processNewInterruptSignal(message.cause);
          if (this._asyncInterruptor !== null) {
            this._asyncInterruptor(exitFailCause(message.cause));
            this._asyncInterruptor = null;
          }
          return EvaluationSignalContinue;
        }
        case OP_RESUME: {
          this._asyncInterruptor = null;
          this._asyncBlockingOn = null;
          this.evaluateEffect(message.effect);
          return EvaluationSignalContinue;
        }
        case OP_STATEFUL: {
          message.onFiber(this, this._exitValue !== null ? done4 : suspended2(this.currentRuntimeFlags, this._asyncBlockingOn));
          return EvaluationSignalContinue;
        }
        default: {
          return absurd(message);
        }
      }
    }
    /**
     * Evaluates an effect until completion, potentially asynchronously.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    evaluateEffect(effect0) {
      this.currentSupervisor.onResume(this);
      try {
        let effect = interruptible(this.currentRuntimeFlags) && this.isInterrupted() ? exitFailCause(this.getInterruptedCause()) : effect0;
        while (effect !== null) {
          const eff = effect;
          const exit4 = this.runLoop(eff);
          if (exit4 === YieldedOp) {
            const op = yieldedOpChannel.currentOp;
            yieldedOpChannel.currentOp = null;
            if (op._op === OP_YIELD) {
              if (cooperativeYielding(this.currentRuntimeFlags)) {
                this.tell(yieldNow3());
                this.tell(resume(exitVoid));
                effect = null;
              } else {
                effect = exitVoid;
              }
            } else if (op._op === OP_ASYNC) {
              effect = null;
            }
          } else {
            this.currentRuntimeFlags = pipe(this.currentRuntimeFlags, enable2(WindDown));
            const interruption2 = this.interruptAllChildren();
            if (interruption2 !== null) {
              effect = flatMap8(interruption2, () => exit4);
            } else {
              if (this._queue.length === 0) {
                this.setExitValue(exit4);
              } else {
                this.tell(resume(exit4));
              }
              effect = null;
            }
          }
        }
      } finally {
        this.currentSupervisor.onSuspend(this);
      }
    }
    /**
     * Begins execution of the effect associated with this fiber on the current
     * thread. This can be called to "kick off" execution of a fiber after it has
     * been created, in hopes that the effect can be executed synchronously.
     *
     * This is not the normal way of starting a fiber, but it is useful when the
     * express goal of executing the fiber is to synchronously produce its exit.
     */
    start(effect) {
      if (!this._running) {
        this._running = true;
        const prev = globalThis[currentFiberURI];
        globalThis[currentFiberURI] = this;
        try {
          this.evaluateEffect(effect);
        } finally {
          this._running = false;
          globalThis[currentFiberURI] = prev;
          if (this._queue.length > 0) {
            this.drainQueueLaterOnExecutor();
          }
        }
      } else {
        this.tell(resume(effect));
      }
    }
    /**
     * Begins execution of the effect associated with this fiber on in the
     * background, and on the correct thread pool. This can be called to "kick
     * off" execution of a fiber after it has been created, in hopes that the
     * effect can be executed synchronously.
     */
    startFork(effect) {
      this.tell(resume(effect));
    }
    /**
     * Takes the current runtime flags, patches them to return the new runtime
     * flags, and then makes any changes necessary to fiber state based on the
     * specified patch.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    patchRuntimeFlags(oldRuntimeFlags, patch9) {
      const newRuntimeFlags = patch4(oldRuntimeFlags, patch9);
      globalThis[currentFiberURI] = this;
      this.currentRuntimeFlags = newRuntimeFlags;
      return newRuntimeFlags;
    }
    /**
     * Initiates an asynchronous operation, by building a callback that will
     * resume execution, and then feeding that callback to the registration
     * function, handling error cases and repeated resumptions appropriately.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    initiateAsync(runtimeFlags2, asyncRegister) {
      let alreadyCalled = false;
      const callback = (effect) => {
        if (!alreadyCalled) {
          alreadyCalled = true;
          this.tell(resume(effect));
        }
      };
      if (interruptible(runtimeFlags2)) {
        this._asyncInterruptor = callback;
      }
      try {
        asyncRegister(callback);
      } catch (e) {
        callback(failCause(die(e)));
      }
    }
    pushStack(cont) {
      this._stack.push(cont);
      if (cont._op === "OnStep") {
        this._steps.push({
          refs: this.getFiberRefs(),
          flags: this.currentRuntimeFlags
        });
      }
    }
    popStack() {
      const item = this._stack.pop();
      if (item) {
        if (item._op === "OnStep") {
          this._steps.pop();
        }
        return item;
      }
      return;
    }
    getNextSuccessCont() {
      let frame = this.popStack();
      while (frame) {
        if (frame._op !== OP_ON_FAILURE) {
          return frame;
        }
        frame = this.popStack();
      }
    }
    getNextFailCont() {
      let frame = this.popStack();
      while (frame) {
        if (frame._op !== OP_ON_SUCCESS && frame._op !== OP_WHILE && frame._op !== OP_ITERATOR) {
          return frame;
        }
        frame = this.popStack();
      }
    }
    [(_b12 = FiberTypeId, _a44 = RuntimeFiberTypeId, OP_TAG)](op) {
      return sync(() => unsafeGet3(this.currentContext, op));
    }
    ["Left"](op) {
      return fail2(op.left);
    }
    ["None"](_) {
      return fail2(new NoSuchElementException());
    }
    ["Right"](op) {
      return exitSucceed(op.right);
    }
    ["Some"](op) {
      return exitSucceed(op.value);
    }
    ["Micro"](op) {
      return unsafeAsync((microResume) => {
        let resume2 = microResume;
        const fiber = runFork(provideContext2(op, this.currentContext));
        fiber.addObserver((exit4) => {
          if (exit4._tag === "Success") {
            return resume2(exitSucceed(exit4.value));
          }
          switch (exit4.cause._tag) {
            case "Interrupt": {
              return resume2(exitFailCause(interrupt(none4)));
            }
            case "Fail": {
              return resume2(fail2(exit4.cause.error));
            }
            case "Die": {
              return resume2(die2(exit4.cause.defect));
            }
          }
        });
        return unsafeAsync((abortResume) => {
          resume2 = (_) => {
            abortResume(void_2);
          };
          fiber.unsafeInterrupt();
        });
      });
    }
    [OP_SYNC](op) {
      const value = internalCall(() => op.effect_instruction_i0());
      const cont = this.getNextSuccessCont();
      if (cont !== void 0) {
        if (!(cont._op in contOpSuccess)) {
          absurd(cont);
        }
        return contOpSuccess[cont._op](this, cont, value);
      } else {
        yieldedOpChannel.currentOp = exitSucceed(value);
        return YieldedOp;
      }
    }
    [OP_SUCCESS](op) {
      const oldCur = op;
      const cont = this.getNextSuccessCont();
      if (cont !== void 0) {
        if (!(cont._op in contOpSuccess)) {
          absurd(cont);
        }
        return contOpSuccess[cont._op](this, cont, oldCur.effect_instruction_i0);
      } else {
        yieldedOpChannel.currentOp = oldCur;
        return YieldedOp;
      }
    }
    [OP_FAILURE](op) {
      const cause3 = op.effect_instruction_i0;
      const cont = this.getNextFailCont();
      if (cont !== void 0) {
        switch (cont._op) {
          case OP_ON_FAILURE:
          case OP_ON_SUCCESS_AND_FAILURE: {
            if (!(interruptible(this.currentRuntimeFlags) && this.isInterrupted())) {
              return internalCall(() => cont.effect_instruction_i1(cause3));
            } else {
              return exitFailCause(stripFailures(cause3));
            }
          }
          case "OnStep": {
            if (!(interruptible(this.currentRuntimeFlags) && this.isInterrupted())) {
              return exitSucceed(exitFailCause(cause3));
            } else {
              return exitFailCause(stripFailures(cause3));
            }
          }
          case OP_REVERT_FLAGS: {
            this.patchRuntimeFlags(this.currentRuntimeFlags, cont.patch);
            if (interruptible(this.currentRuntimeFlags) && this.isInterrupted()) {
              return exitFailCause(sequential(cause3, this.getInterruptedCause()));
            } else {
              return exitFailCause(cause3);
            }
          }
          default: {
            absurd(cont);
          }
        }
      } else {
        yieldedOpChannel.currentOp = exitFailCause(cause3);
        return YieldedOp;
      }
    }
    [OP_WITH_RUNTIME](op) {
      return internalCall(() => op.effect_instruction_i0(this, running2(this.currentRuntimeFlags)));
    }
    ["Blocked"](op) {
      const refs = this.getFiberRefs();
      const flags = this.currentRuntimeFlags;
      if (this._steps.length > 0) {
        const frames = [];
        const snap = this._steps[this._steps.length - 1];
        let frame = this.popStack();
        while (frame && frame._op !== "OnStep") {
          frames.push(frame);
          frame = this.popStack();
        }
        this.setFiberRefs(snap.refs);
        this.currentRuntimeFlags = snap.flags;
        const patchRefs = diff6(snap.refs, refs);
        const patchFlags = diff4(snap.flags, flags);
        return exitSucceed(blocked(op.effect_instruction_i0, withFiberRuntime((newFiber) => {
          while (frames.length > 0) {
            newFiber.pushStack(frames.pop());
          }
          newFiber.setFiberRefs(patch7(newFiber.id(), newFiber.getFiberRefs())(patchRefs));
          newFiber.currentRuntimeFlags = patch4(patchFlags)(newFiber.currentRuntimeFlags);
          return op.effect_instruction_i1;
        })));
      }
      return uninterruptibleMask((restore) => flatMap8(forkDaemon(runRequestBlock(op.effect_instruction_i0)), () => restore(op.effect_instruction_i1)));
    }
    ["RunBlocked"](op) {
      return runBlockedRequests(op.effect_instruction_i0);
    }
    [OP_UPDATE_RUNTIME_FLAGS](op) {
      const updateFlags = op.effect_instruction_i0;
      const oldRuntimeFlags = this.currentRuntimeFlags;
      const newRuntimeFlags = patch4(oldRuntimeFlags, updateFlags);
      if (interruptible(newRuntimeFlags) && this.isInterrupted()) {
        return exitFailCause(this.getInterruptedCause());
      } else {
        this.patchRuntimeFlags(this.currentRuntimeFlags, updateFlags);
        if (op.effect_instruction_i1) {
          const revertFlags = diff4(newRuntimeFlags, oldRuntimeFlags);
          this.pushStack(new RevertFlags(revertFlags, op));
          return internalCall(() => op.effect_instruction_i1(oldRuntimeFlags));
        } else {
          return exitVoid;
        }
      }
    }
    [OP_ON_SUCCESS](op) {
      this.pushStack(op);
      return op.effect_instruction_i0;
    }
    ["OnStep"](op) {
      this.pushStack(op);
      return op.effect_instruction_i0;
    }
    [OP_ON_FAILURE](op) {
      this.pushStack(op);
      return op.effect_instruction_i0;
    }
    [OP_ON_SUCCESS_AND_FAILURE](op) {
      this.pushStack(op);
      return op.effect_instruction_i0;
    }
    [OP_ASYNC](op) {
      this._asyncBlockingOn = op.effect_instruction_i1;
      this.initiateAsync(this.currentRuntimeFlags, op.effect_instruction_i0);
      yieldedOpChannel.currentOp = op;
      return YieldedOp;
    }
    [OP_YIELD](op) {
      this._isYielding = false;
      yieldedOpChannel.currentOp = op;
      return YieldedOp;
    }
    [OP_WHILE](op) {
      const check3 = op.effect_instruction_i0;
      const body = op.effect_instruction_i1;
      if (check3()) {
        this.pushStack(op);
        return body();
      } else {
        return exitVoid;
      }
    }
    [OP_ITERATOR](op) {
      return contOpSuccess[OP_ITERATOR](this, op, void 0);
    }
    [OP_COMMIT](op) {
      return internalCall(() => op.commit());
    }
    /**
     * The main run-loop for evaluating effects.
     *
     * **NOTE**: This method must be invoked by the fiber itself.
     */
    runLoop(effect0) {
      let cur = effect0;
      this.currentOpCount = 0;
      while (true) {
        if ((this.currentRuntimeFlags & OpSupervision) !== 0) {
          this.currentSupervisor.onEffect(this, cur);
        }
        if (this._queue.length > 0) {
          cur = this.drainQueueWhileRunning(this.currentRuntimeFlags, cur);
        }
        if (!this._isYielding) {
          this.currentOpCount += 1;
          const shouldYield = this.currentScheduler.shouldYield(this);
          if (shouldYield !== false) {
            this._isYielding = true;
            this.currentOpCount = 0;
            const oldCur = cur;
            cur = flatMap8(yieldNow({
              priority: shouldYield
            }), () => oldCur);
          }
        }
        try {
          cur = this.currentTracer.context(() => {
            if (_version !== cur[EffectTypeId2]._V) {
              const level = this.getFiberRef(currentVersionMismatchErrorLogLevel);
              if (level._tag === "Some") {
                const effectVersion = cur[EffectTypeId2]._V;
                this.log(`Executing an Effect versioned ${effectVersion} with a Runtime of version ${getCurrentVersion()}, you may want to dedupe the effect dependencies, you can use the language service plugin to detect this at compile time: https://github.com/Effect-TS/language-service`, empty16, level);
              }
            }
            return this[cur._op](cur);
          }, this);
          if (cur === YieldedOp) {
            const op = yieldedOpChannel.currentOp;
            if (op._op === OP_YIELD || op._op === OP_ASYNC) {
              return YieldedOp;
            }
            yieldedOpChannel.currentOp = null;
            return op._op === OP_SUCCESS || op._op === OP_FAILURE ? op : exitFailCause(die(op));
          }
        } catch (e) {
          if (cur !== YieldedOp && !hasProperty(cur, "_op") || !(cur._op in this)) {
            cur = dieMessage(`Not a valid effect: ${toStringUnknown(cur)}`);
          } else if (isInterruptedException(e)) {
            cur = exitFailCause(sequential(die(e), interrupt(none4)));
          } else {
            cur = die2(e);
          }
        }
      }
    }
  };
  var currentMinimumLogLevel = /* @__PURE__ */ globalValue("effect/FiberRef/currentMinimumLogLevel", () => fiberRefUnsafeMake(fromLiteral("Info")));
  var loggerWithConsoleLog = (self) => makeLogger((opts) => {
    const services = getOrDefault2(opts.context, currentServices);
    get3(services, consoleTag).unsafe.log(self.log(opts));
  });
  var defaultLogger = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Logger/defaultLogger"), () => loggerWithConsoleLog(stringLogger));
  var tracerLogger = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/Logger/tracerLogger"), () => makeLogger(({
    annotations,
    cause: cause3,
    context: context4,
    fiberId: fiberId3,
    logLevel,
    message
  }) => {
    const span2 = getOption2(getOrDefault(context4, currentContext), spanTag);
    if (span2._tag === "None" || span2.value._tag === "ExternalSpan") {
      return;
    }
    const clockService = unsafeGet3(getOrDefault(context4, currentServices), clockTag);
    const attributes = {};
    for (const [key, value] of annotations) {
      attributes[key] = value;
    }
    attributes["effect.fiberId"] = threadName2(fiberId3);
    attributes["effect.logLevel"] = logLevel.label;
    if (cause3 !== null && cause3._tag !== "Empty") {
      attributes["effect.cause"] = pretty(cause3, {
        renderErrorCause: true
      });
    }
    span2.value.event(toStringUnknown(Array.isArray(message) && message.length === 1 ? message[0] : message), clockService.unsafeCurrentTimeNanos(), attributes);
  }));
  var currentLoggers = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentLoggers"), () => fiberRefUnsafeMakeHashSet(make10(defaultLogger, tracerLogger)));
  var annotateLogsScoped = function() {
    if (typeof arguments[0] === "string") {
      return fiberRefLocallyScopedWith(currentLogAnnotations, set3(arguments[0], arguments[1]));
    }
    const entries2 = Object.entries(arguments[0]);
    return fiberRefLocallyScopedWith(currentLogAnnotations, mutate3((annotations) => {
      for (let i = 0; i < entries2.length; i++) {
        const [key, value] = entries2[i];
        set3(annotations, key, value);
      }
      return annotations;
    }));
  };
  var whenLogLevel = /* @__PURE__ */ dual(2, (effect, level) => {
    const requiredLogLevel = typeof level === "string" ? fromLiteral(level) : level;
    return withFiberRuntime((fiberState) => {
      const minimumLogLevel = fiberState.getFiberRef(currentMinimumLogLevel);
      if (greaterThan3(minimumLogLevel, requiredLogLevel)) {
        return succeed(none2());
      }
      return map9(effect, some2);
    });
  });
  var acquireRelease = /* @__PURE__ */ dual((args2) => isEffect(args2[0]), (acquire, release) => uninterruptible(tap(acquire, (a) => addFinalizer((exit4) => release(a, exit4)))));
  var acquireReleaseInterruptible = /* @__PURE__ */ dual((args2) => isEffect(args2[0]), (acquire, release) => ensuring(acquire, addFinalizer((exit4) => release(exit4))));
  var addFinalizer = (finalizer) => withFiberRuntime((runtime4) => {
    const acquireRefs = runtime4.getFiberRefs();
    const acquireFlags = disable2(runtime4.currentRuntimeFlags, Interruption);
    return flatMap8(scope, (scope3) => scopeAddFinalizerExit(scope3, (exit4) => withFiberRuntime((runtimeFinalizer) => {
      const preRefs = runtimeFinalizer.getFiberRefs();
      const preFlags = runtimeFinalizer.currentRuntimeFlags;
      const patchRefs = diff6(preRefs, acquireRefs);
      const patchFlags = diff4(preFlags, acquireFlags);
      const inverseRefs = diff6(acquireRefs, preRefs);
      runtimeFinalizer.setFiberRefs(patch7(patchRefs, runtimeFinalizer.id(), acquireRefs));
      return ensuring(withRuntimeFlags(finalizer(exit4), patchFlags), sync(() => {
        runtimeFinalizer.setFiberRefs(patch7(inverseRefs, runtimeFinalizer.id(), runtimeFinalizer.getFiberRefs()));
      }));
    })));
  });
  var daemonChildren = (self) => {
    const forkScope = fiberRefLocally(currentForkScopeOverride, some2(globalScope));
    return forkScope(self);
  };
  var _existsParFound = /* @__PURE__ */ Symbol.for("effect/Effect/existsPar/found");
  var exists = /* @__PURE__ */ dual((args2) => isIterable(args2[0]) && !isEffect(args2[0]), (elements, predicate, options) => matchSimple(options?.concurrency, () => suspend(() => existsLoop(elements[Symbol.iterator](), 0, predicate)), () => matchEffect(forEach7(elements, (a, i) => if_(predicate(a, i), {
    onTrue: () => fail2(_existsParFound),
    onFalse: () => void_2
  }), options), {
    onFailure: (e) => e === _existsParFound ? succeed(true) : fail2(e),
    onSuccess: () => succeed(false)
  })));
  var existsLoop = (iterator, index, f) => {
    const next4 = iterator.next();
    if (next4.done) {
      return succeed(false);
    }
    return flatMap8(f(next4.value, index), (b) => b ? succeed(b) : existsLoop(iterator, index + 1, f));
  };
  var filter4 = /* @__PURE__ */ dual((args2) => isIterable(args2[0]) && !isEffect(args2[0]), (elements, predicate, options) => {
    const predicate_ = options?.negate ? (a, i) => map9(predicate(a, i), not) : predicate;
    return matchSimple(options?.concurrency, () => suspend(() => fromIterable(elements).reduceRight((effect, a, i) => zipWith3(effect, suspend(() => predicate_(a, i)), (list, b) => b ? [a, ...list] : list), sync(() => new Array()))), () => map9(forEach7(elements, (a, i) => map9(predicate_(a, i), (b) => b ? some2(a) : none2()), options), getSomes));
  });
  var allResolveInput = (input) => {
    if (Array.isArray(input) || isIterable(input)) {
      return [input, none2()];
    }
    const keys5 = Object.keys(input);
    const size9 = keys5.length;
    return [keys5.map((k) => input[k]), some2((values3) => {
      const res = {};
      for (let i = 0; i < size9; i++) {
        ;
        res[keys5[i]] = values3[i];
      }
      return res;
    })];
  };
  var allValidate = (effects, reconcile, options) => {
    const eitherEffects = [];
    for (const effect of effects) {
      eitherEffects.push(either2(effect));
    }
    return flatMap8(forEach7(eitherEffects, identity, {
      concurrency: options?.concurrency,
      batching: options?.batching,
      concurrentFinalizers: options?.concurrentFinalizers
    }), (eithers) => {
      const none10 = none2();
      const size9 = eithers.length;
      const errors = new Array(size9);
      const successes = new Array(size9);
      let errored = false;
      for (let i = 0; i < size9; i++) {
        const either6 = eithers[i];
        if (either6._tag === "Left") {
          errors[i] = some2(either6.left);
          errored = true;
        } else {
          successes[i] = either6.right;
          errors[i] = none10;
        }
      }
      if (errored) {
        return reconcile._tag === "Some" ? fail2(reconcile.value(errors)) : fail2(errors);
      } else if (options?.discard) {
        return void_2;
      }
      return reconcile._tag === "Some" ? succeed(reconcile.value(successes)) : succeed(successes);
    });
  };
  var allEither = (effects, reconcile, options) => {
    const eitherEffects = [];
    for (const effect of effects) {
      eitherEffects.push(either2(effect));
    }
    if (options?.discard) {
      return forEach7(eitherEffects, identity, {
        concurrency: options?.concurrency,
        batching: options?.batching,
        discard: true,
        concurrentFinalizers: options?.concurrentFinalizers
      });
    }
    return map9(forEach7(eitherEffects, identity, {
      concurrency: options?.concurrency,
      batching: options?.batching,
      concurrentFinalizers: options?.concurrentFinalizers
    }), (eithers) => reconcile._tag === "Some" ? reconcile.value(eithers) : eithers);
  };
  var all3 = (arg, options) => {
    const [effects, reconcile] = allResolveInput(arg);
    if (options?.mode === "validate") {
      return allValidate(effects, reconcile, options);
    } else if (options?.mode === "either") {
      return allEither(effects, reconcile, options);
    }
    return options?.discard !== true && reconcile._tag === "Some" ? map9(forEach7(effects, identity, options), reconcile.value) : forEach7(effects, identity, options);
  };
  var allWith = (options) => (arg) => all3(arg, options);
  var allSuccesses = (elements, options) => map9(all3(fromIterable(elements).map(exit), options), filterMap((exit4) => exitIsSuccess(exit4) ? some2(exit4.effect_instruction_i0) : none2()));
  var replicate = /* @__PURE__ */ dual(2, (self, n) => Array.from({
    length: n
  }, () => self));
  var replicateEffect = /* @__PURE__ */ dual((args2) => isEffect(args2[0]), (self, n, options) => all3(replicate(self, n), options));
  var forEach7 = /* @__PURE__ */ dual((args2) => isIterable(args2[0]), (self, f, options) => withFiberRuntime((r) => {
    const isRequestBatchingEnabled = options?.batching === true || options?.batching === "inherit" && r.getFiberRef(currentRequestBatching);
    if (options?.discard) {
      return match8(options.concurrency, () => finalizersMaskInternal(sequential3, options?.concurrentFinalizers)((restore) => isRequestBatchingEnabled ? forEachConcurrentDiscard(self, (a, i) => restore(f(a, i)), true, false, 1) : forEachSequentialDiscard(self, (a, i) => restore(f(a, i)))), () => finalizersMaskInternal(parallel3, options?.concurrentFinalizers)((restore) => forEachConcurrentDiscard(self, (a, i) => restore(f(a, i)), isRequestBatchingEnabled, false)), (n) => finalizersMaskInternal(parallelN2(n), options?.concurrentFinalizers)((restore) => forEachConcurrentDiscard(self, (a, i) => restore(f(a, i)), isRequestBatchingEnabled, false, n)));
    }
    return match8(options?.concurrency, () => finalizersMaskInternal(sequential3, options?.concurrentFinalizers)((restore) => isRequestBatchingEnabled ? forEachParN(self, 1, (a, i) => restore(f(a, i)), true) : forEachSequential(self, (a, i) => restore(f(a, i)))), () => finalizersMaskInternal(parallel3, options?.concurrentFinalizers)((restore) => forEachParUnbounded(self, (a, i) => restore(f(a, i)), isRequestBatchingEnabled)), (n) => finalizersMaskInternal(parallelN2(n), options?.concurrentFinalizers)((restore) => forEachParN(self, n, (a, i) => restore(f(a, i)), isRequestBatchingEnabled)));
  }));
  var forEachParUnbounded = (self, f, batching) => suspend(() => {
    const as6 = fromIterable(self);
    const array3 = new Array(as6.length);
    const fn2 = (a, i) => flatMap8(f(a, i), (b) => sync(() => array3[i] = b));
    return zipRight(forEachConcurrentDiscard(as6, fn2, batching, false), succeed(array3));
  });
  var forEachConcurrentDiscard = (self, f, batching, processAll, n) => uninterruptibleMask((restore) => transplant((graft) => withFiberRuntime((parent) => {
    let todos = Array.from(self).reverse();
    let target = todos.length;
    if (target === 0) {
      return void_2;
    }
    let counter6 = 0;
    let interrupted = false;
    const fibersCount = n ? Math.min(todos.length, n) : todos.length;
    const fibers = /* @__PURE__ */ new Set();
    const results = new Array();
    const interruptAll = () => fibers.forEach((fiber) => {
      fiber.currentScheduler.scheduleTask(() => {
        fiber.unsafeInterruptAsFork(parent.id());
      }, 0);
    });
    const startOrder = new Array();
    const joinOrder = new Array();
    const residual = new Array();
    const collectExits = () => {
      const exits = results.filter(({
        exit: exit4
      }) => exit4._tag === "Failure").sort((a, b) => a.index < b.index ? -1 : a.index === b.index ? 0 : 1).map(({
        exit: exit4
      }) => exit4);
      if (exits.length === 0) {
        exits.push(exitVoid);
      }
      return exits;
    };
    const runFiber = (eff, interruptImmediately = false) => {
      const runnable = uninterruptible(graft(eff));
      const fiber = unsafeForkUnstarted(runnable, parent, parent.currentRuntimeFlags, globalScope);
      parent.currentScheduler.scheduleTask(() => {
        if (interruptImmediately) {
          fiber.unsafeInterruptAsFork(parent.id());
        }
        fiber.resume(runnable);
      }, 0);
      return fiber;
    };
    const onInterruptSignal = () => {
      if (!processAll) {
        target -= todos.length;
        todos = [];
      }
      interrupted = true;
      interruptAll();
    };
    const stepOrExit = batching ? step2 : exit;
    const processingFiber = runFiber(async_((resume2) => {
      const pushResult = (res, index) => {
        if (res._op === "Blocked") {
          residual.push(res);
        } else {
          results.push({
            index,
            exit: res
          });
          if (res._op === "Failure" && !interrupted) {
            onInterruptSignal();
          }
        }
      };
      const next4 = () => {
        if (todos.length > 0) {
          const a = todos.pop();
          let index = counter6++;
          const returnNextElement = () => {
            const a2 = todos.pop();
            index = counter6++;
            return flatMap8(yieldNow(), () => flatMap8(stepOrExit(restore(f(a2, index))), onRes));
          };
          const onRes = (res) => {
            if (todos.length > 0) {
              pushResult(res, index);
              if (todos.length > 0) {
                return returnNextElement();
              }
            }
            return succeed(res);
          };
          const todo = flatMap8(stepOrExit(restore(f(a, index))), onRes);
          const fiber = runFiber(todo);
          startOrder.push(fiber);
          fibers.add(fiber);
          if (interrupted) {
            fiber.currentScheduler.scheduleTask(() => {
              fiber.unsafeInterruptAsFork(parent.id());
            }, 0);
          }
          fiber.addObserver((wrapped) => {
            let exit4;
            if (wrapped._op === "Failure") {
              exit4 = wrapped;
            } else {
              exit4 = wrapped.effect_instruction_i0;
            }
            joinOrder.push(fiber);
            fibers.delete(fiber);
            pushResult(exit4, index);
            if (results.length === target) {
              resume2(succeed(getOrElse2(exitCollectAll(collectExits(), {
                parallel: true
              }), () => exitVoid)));
            } else if (residual.length + results.length === target) {
              const exits = collectExits();
              const requests = residual.map((blocked3) => blocked3.effect_instruction_i0).reduce(par);
              resume2(succeed(blocked(requests, forEachConcurrentDiscard([getOrElse2(exitCollectAll(exits, {
                parallel: true
              }), () => exitVoid), ...residual.map((blocked3) => blocked3.effect_instruction_i1)], (i) => i, batching, true, n))));
            } else {
              next4();
            }
          });
        }
      };
      for (let i = 0; i < fibersCount; i++) {
        next4();
      }
    }));
    return asVoid(onExit(flatten4(restore(join2(processingFiber))), exitMatch({
      onFailure: (cause3) => {
        onInterruptSignal();
        const target2 = residual.length + 1;
        const concurrency = Math.min(typeof n === "number" ? n : residual.length, residual.length);
        const toPop = Array.from(residual);
        return async_((cb) => {
          const exits = [];
          let count3 = 0;
          let index = 0;
          const check3 = (index2, hitNext) => (exit4) => {
            exits[index2] = exit4;
            count3++;
            if (count3 === target2) {
              cb(exitSucceed(exitFailCause(cause3)));
            }
            if (toPop.length > 0 && hitNext) {
              next4();
            }
          };
          const next4 = () => {
            runFiber(toPop.pop(), true).addObserver(check3(index, true));
            index++;
          };
          processingFiber.addObserver(check3(index, false));
          index++;
          for (let i = 0; i < concurrency; i++) {
            next4();
          }
        });
      },
      onSuccess: () => forEachSequential(joinOrder, (f2) => f2.inheritAll)
    })));
  })));
  var forEachParN = (self, n, f, batching) => suspend(() => {
    const as6 = fromIterable(self);
    const array3 = new Array(as6.length);
    const fn2 = (a, i) => map9(f(a, i), (b) => array3[i] = b);
    return zipRight(forEachConcurrentDiscard(as6, fn2, batching, false, n), succeed(array3));
  });
  var fork = (self) => withFiberRuntime((state, status) => succeed(unsafeFork2(self, state, status.runtimeFlags)));
  var forkDaemon = (self) => forkWithScopeOverride(self, globalScope);
  var forkWithErrorHandler = /* @__PURE__ */ dual(2, (self, handler) => fork(onError(self, (cause3) => {
    const either6 = failureOrCause(cause3);
    switch (either6._tag) {
      case "Left":
        return handler(either6.left);
      case "Right":
        return failCause(either6.right);
    }
  })));
  var unsafeFork2 = (effect, parentFiber, parentRuntimeFlags, overrideScope = null) => {
    const childFiber = unsafeMakeChildFiber(effect, parentFiber, parentRuntimeFlags, overrideScope);
    childFiber.resume(effect);
    return childFiber;
  };
  var unsafeForkUnstarted = (effect, parentFiber, parentRuntimeFlags, overrideScope = null) => {
    const childFiber = unsafeMakeChildFiber(effect, parentFiber, parentRuntimeFlags, overrideScope);
    return childFiber;
  };
  var unsafeMakeChildFiber = (effect, parentFiber, parentRuntimeFlags, overrideScope = null) => {
    const childId = unsafeMake2();
    const parentFiberRefs = parentFiber.getFiberRefs();
    const childFiberRefs = forkAs(parentFiberRefs, childId);
    const childFiber = new FiberRuntime(childId, childFiberRefs, parentRuntimeFlags);
    const childContext = getOrDefault(childFiberRefs, currentContext);
    const supervisor = childFiber.currentSupervisor;
    supervisor.onStart(childContext, effect, some2(parentFiber), childFiber);
    childFiber.addObserver((exit4) => supervisor.onEnd(exit4, childFiber));
    const parentScope = overrideScope !== null ? overrideScope : pipe(parentFiber.getFiberRef(currentForkScopeOverride), getOrElse2(() => parentFiber.scope()));
    parentScope.add(parentRuntimeFlags, childFiber);
    return childFiber;
  };
  var forkWithScopeOverride = (self, scopeOverride) => withFiberRuntime((parentFiber, parentStatus) => succeed(unsafeFork2(self, parentFiber, parentStatus.runtimeFlags, scopeOverride)));
  var mergeAll3 = /* @__PURE__ */ dual((args2) => isFunction2(args2[2]), (elements, zero2, f, options) => matchSimple(options?.concurrency, () => fromIterable(elements).reduce((acc, a, i) => zipWith3(acc, a, (acc2, a2) => f(acc2, a2, i)), succeed(zero2)), () => flatMap8(make27(zero2), (acc) => flatMap8(forEach7(elements, (effect, i) => flatMap8(effect, (a) => update3(acc, (b) => f(b, a, i))), options), () => get12(acc)))));
  var partition3 = /* @__PURE__ */ dual((args2) => isIterable(args2[0]), (elements, f, options) => pipe(forEach7(elements, (a, i) => either2(f(a, i)), options), map9((chunk2) => partitionMap2(chunk2, identity))));
  var validateAll = /* @__PURE__ */ dual((args2) => isIterable(args2[0]), (elements, f, options) => flatMap8(partition3(elements, f, {
    concurrency: options?.concurrency,
    batching: options?.batching,
    concurrentFinalizers: options?.concurrentFinalizers
  }), ([es, bs]) => isNonEmptyArray2(es) ? fail2(es) : options?.discard ? void_2 : succeed(bs)));
  var raceAll = (all5) => withFiberRuntime((state, status) => async_((resume2) => {
    const fibers = /* @__PURE__ */ new Set();
    let winner;
    let failures2 = empty16;
    const interruptAll = () => {
      for (const fiber of fibers) {
        fiber.unsafeInterruptAsFork(state.id());
      }
    };
    let latch = false;
    let empty29 = true;
    for (const self of all5) {
      empty29 = false;
      const fiber = unsafeFork2(interruptible2(self), state, status.runtimeFlags);
      fibers.add(fiber);
      fiber.addObserver((exit4) => {
        fibers.delete(fiber);
        if (!winner) {
          if (exit4._tag === "Success") {
            latch = true;
            winner = fiber;
            failures2 = empty16;
            interruptAll();
          } else {
            failures2 = parallel(exit4.cause, failures2);
          }
        }
        if (latch && fibers.size === 0) {
          resume2(winner ? zipRight(inheritAll(winner), winner.unsafePoll()) : failCause(failures2));
        }
      });
      if (winner) break;
    }
    if (empty29) {
      return resume2(dieSync(() => new IllegalArgumentException(`Received an empty collection of effects`)));
    }
    latch = true;
    return interruptAllAs(fibers, state.id());
  }));
  var reduceEffect = /* @__PURE__ */ dual((args2) => isIterable(args2[0]) && !isEffect(args2[0]), (elements, zero2, f, options) => matchSimple(options?.concurrency, () => fromIterable(elements).reduce((acc, a, i) => zipWith3(acc, a, (acc2, a2) => f(acc2, a2, i)), zero2), () => suspend(() => pipe(mergeAll3([zero2, ...elements], none2(), (acc, elem, i) => {
    switch (acc._tag) {
      case "None": {
        return some2(elem);
      }
      case "Some": {
        return some2(f(acc.value, elem, i));
      }
    }
  }, options), map9((option3) => {
    switch (option3._tag) {
      case "None": {
        throw new Error("BUG: Effect.reduceEffect - please report an issue at https://github.com/Effect-TS/effect/issues");
      }
      case "Some": {
        return option3.value;
      }
    }
  })))));
  var parallelFinalizers = (self) => contextWithEffect((context4) => match2(getOption2(context4, scopeTag), {
    onNone: () => self,
    onSome: (scope3) => {
      switch (scope3.strategy._tag) {
        case "Parallel":
          return self;
        case "Sequential":
        case "ParallelN":
          return flatMap8(scopeFork(scope3, parallel3), (inner) => scopeExtend(self, inner));
      }
    }
  }));
  var parallelNFinalizers = (parallelism) => (self) => contextWithEffect((context4) => match2(getOption2(context4, scopeTag), {
    onNone: () => self,
    onSome: (scope3) => {
      if (scope3.strategy._tag === "ParallelN" && scope3.strategy.parallelism === parallelism) {
        return self;
      }
      return flatMap8(scopeFork(scope3, parallelN2(parallelism)), (inner) => scopeExtend(self, inner));
    }
  }));
  var finalizersMask = (strategy) => (self) => finalizersMaskInternal(strategy, true)(self);
  var finalizersMaskInternal = (strategy, concurrentFinalizers) => (self) => contextWithEffect((context4) => match2(getOption2(context4, scopeTag), {
    onNone: () => self(identity),
    onSome: (scope3) => {
      if (concurrentFinalizers === true) {
        const patch9 = strategy._tag === "Parallel" ? parallelFinalizers : strategy._tag === "Sequential" ? sequentialFinalizers : parallelNFinalizers(strategy.parallelism);
        switch (scope3.strategy._tag) {
          case "Parallel":
            return patch9(self(parallelFinalizers));
          case "Sequential":
            return patch9(self(sequentialFinalizers));
          case "ParallelN":
            return patch9(self(parallelNFinalizers(scope3.strategy.parallelism)));
        }
      } else {
        return self(identity);
      }
    }
  }));
  var scopeWith = (f) => flatMap8(scopeTag, f);
  var scopedWith = (f) => flatMap8(scopeMake(), (scope3) => onExit(f(scope3), (exit4) => scope3.close(exit4)));
  var scopedEffect = (effect) => flatMap8(scopeMake(), (scope3) => scopeUse(effect, scope3));
  var sequentialFinalizers = (self) => contextWithEffect((context4) => match2(getOption2(context4, scopeTag), {
    onNone: () => self,
    onSome: (scope3) => {
      switch (scope3.strategy._tag) {
        case "Sequential":
          return self;
        case "Parallel":
        case "ParallelN":
          return flatMap8(scopeFork(scope3, sequential3), (inner) => scopeExtend(self, inner));
      }
    }
  }));
  var tagMetricsScoped = (key, value) => labelMetricsScoped([make28(key, value)]);
  var labelMetricsScoped = (labels) => fiberRefLocallyScopedWith(currentMetricLabels, (old) => union(old, labels));
  var using = /* @__PURE__ */ dual(2, (self, use) => scopedWith((scope3) => flatMap8(scopeExtend(self, scope3), use)));
  var validate = /* @__PURE__ */ dual((args2) => isEffect(args2[1]), (self, that, options) => validateWith(self, that, (a, b) => [a, b], options));
  var validateWith = /* @__PURE__ */ dual((args2) => isEffect(args2[1]), (self, that, f, options) => flatten4(zipWithOptions(exit(self), exit(that), (ea, eb) => exitZipWith(ea, eb, {
    onSuccess: f,
    onFailure: (ca, cb) => options?.concurrent ? parallel(ca, cb) : sequential(ca, cb)
  }), options)));
  var validateFirst = /* @__PURE__ */ dual((args2) => isIterable(args2[0]), (elements, f, options) => flip2(forEach7(elements, (a, i) => flip2(f(a, i)), options)));
  var withClockScoped = (c) => fiberRefLocallyScopedWith(currentServices, add2(clockTag, c));
  var withRandomScoped = (value) => fiberRefLocallyScopedWith(currentServices, add2(randomTag, value));
  var withConfigProviderScoped = (provider) => fiberRefLocallyScopedWith(currentServices, add2(configProviderTag, provider));
  var withEarlyRelease = (self) => scopeWith((parent) => flatMap8(scopeFork(parent, sequential2), (child) => pipe(self, scopeExtend(child), map9((value) => [fiberIdWith((fiberId3) => scopeClose(child, exitInterrupt(fiberId3))), value]))));
  var zipOptions = /* @__PURE__ */ dual((args2) => isEffect(args2[1]), (self, that, options) => zipWithOptions(self, that, (a, b) => [a, b], options));
  var zipLeftOptions = /* @__PURE__ */ dual((args2) => isEffect(args2[1]), (self, that, options) => {
    if (options?.concurrent !== true && (options?.batching === void 0 || options.batching === false)) {
      return zipLeft(self, that);
    }
    return zipWithOptions(self, that, (a, _) => a, options);
  });
  var zipRightOptions = /* @__PURE__ */ dual((args2) => isEffect(args2[1]), (self, that, options) => {
    if (options?.concurrent !== true && (options?.batching === void 0 || options.batching === false)) {
      return zipRight(self, that);
    }
    return zipWithOptions(self, that, (_, b) => b, options);
  });
  var zipWithOptions = /* @__PURE__ */ dual((args2) => isEffect(args2[1]), (self, that, f, options) => map9(all3([self, that], {
    concurrency: options?.concurrent ? 2 : 1,
    batching: options?.batching,
    concurrentFinalizers: options?.concurrentFinalizers
  }), ([a, a2]) => f(a, a2)));
  var withRuntimeFlagsScoped = (update5) => {
    if (update5 === empty14) {
      return void_2;
    }
    return pipe(runtimeFlags, flatMap8((runtimeFlags2) => {
      const updatedRuntimeFlags = patch4(runtimeFlags2, update5);
      const revertRuntimeFlags = diff4(updatedRuntimeFlags, runtimeFlags2);
      return pipe(updateRuntimeFlags(update5), zipRight(addFinalizer(() => updateRuntimeFlags(revertRuntimeFlags))), asVoid);
    }), uninterruptible);
  };
  var scopeTag = /* @__PURE__ */ GenericTag("effect/Scope");
  var scope = scopeTag;
  var scopeUnsafeAddFinalizer = (scope3, fin) => {
    if (scope3.state._tag === "Open") {
      scope3.state.finalizers.set({}, fin);
    }
  };
  var ScopeImplProto = {
    [ScopeTypeId]: ScopeTypeId,
    [CloseableScopeTypeId]: CloseableScopeTypeId,
    pipe() {
      return pipeArguments(this, arguments);
    },
    fork(strategy) {
      return sync(() => {
        const newScope = scopeUnsafeMake(strategy);
        if (this.state._tag === "Closed") {
          newScope.state = this.state;
          return newScope;
        }
        const key = {};
        const fin = (exit4) => newScope.close(exit4);
        this.state.finalizers.set(key, fin);
        scopeUnsafeAddFinalizer(newScope, (_) => sync(() => {
          if (this.state._tag === "Open") {
            this.state.finalizers.delete(key);
          }
        }));
        return newScope;
      });
    },
    close(exit4) {
      return suspend(() => {
        if (this.state._tag === "Closed") {
          return void_2;
        }
        const finalizers = Array.from(this.state.finalizers.values()).reverse();
        this.state = {
          _tag: "Closed",
          exit: exit4
        };
        if (finalizers.length === 0) {
          return void_2;
        }
        return isSequential(this.strategy) ? pipe(forEachSequential(finalizers, (fin) => exit(fin(exit4))), flatMap8((results) => pipe(exitCollectAll(results), map2(exitAsVoid), getOrElse2(() => exitVoid)))) : isParallel(this.strategy) ? pipe(forEachParUnbounded(finalizers, (fin) => exit(fin(exit4)), false), flatMap8((results) => pipe(exitCollectAll(results, {
          parallel: true
        }), map2(exitAsVoid), getOrElse2(() => exitVoid)))) : pipe(forEachParN(finalizers, this.strategy.parallelism, (fin) => exit(fin(exit4)), false), flatMap8((results) => pipe(exitCollectAll(results, {
          parallel: true
        }), map2(exitAsVoid), getOrElse2(() => exitVoid))));
      });
    },
    addFinalizer(fin) {
      return suspend(() => {
        if (this.state._tag === "Closed") {
          return fin(this.state.exit);
        }
        this.state.finalizers.set({}, fin);
        return void_2;
      });
    }
  };
  var scopeUnsafeMake = (strategy = sequential2) => {
    const scope3 = Object.create(ScopeImplProto);
    scope3.strategy = strategy;
    scope3.state = {
      _tag: "Open",
      finalizers: /* @__PURE__ */ new Map()
    };
    return scope3;
  };
  var scopeMake = (strategy = sequential2) => sync(() => scopeUnsafeMake(strategy));
  var scopeExtend = /* @__PURE__ */ dual(2, (effect, scope3) => mapInputContext(
    effect,
    // @ts-expect-error
    merge3(make5(scopeTag, scope3))
  ));
  var scopeUse = /* @__PURE__ */ dual(2, (effect, scope3) => pipe(effect, scopeExtend(scope3), onExit((exit4) => scope3.close(exit4))));
  var fiberRefUnsafeMakeSupervisor = (initial) => fiberRefUnsafeMakePatch(initial, {
    differ: differ2,
    fork: empty25
  });
  var fiberRefLocallyScoped = /* @__PURE__ */ dual(2, (self, value) => asVoid(acquireRelease(flatMap8(fiberRefGet(self), (oldValue) => as(fiberRefSet(self, value), oldValue)), (oldValue) => fiberRefSet(self, oldValue))));
  var fiberRefLocallyScopedWith = /* @__PURE__ */ dual(2, (self, f) => fiberRefGetWith(self, (a) => fiberRefLocallyScoped(self, f(a))));
  var currentRuntimeFlags = /* @__PURE__ */ fiberRefUnsafeMakeRuntimeFlags(none5);
  var currentSupervisor = /* @__PURE__ */ fiberRefUnsafeMakeSupervisor(none8);
  var fiberAwaitAll = (fibers) => forEach7(fibers, _await2);
  var fiberAll = (fibers) => {
    const _fiberAll = {
      ...CommitPrototype2,
      commit() {
        return join2(this);
      },
      [FiberTypeId]: fiberVariance2,
      id: () => fromIterable(fibers).reduce((id, fiber) => combine3(id, fiber.id()), none4),
      await: exit(forEachParUnbounded(fibers, (fiber) => flatten4(fiber.await), false)),
      children: map9(forEachParUnbounded(fibers, (fiber) => fiber.children, false), flatten),
      inheritAll: forEachSequentialDiscard(fibers, (fiber) => fiber.inheritAll),
      poll: map9(forEachSequential(fibers, (fiber) => fiber.poll), reduceRight(some2(exitSucceed(new Array())), (optionB, optionA) => {
        switch (optionA._tag) {
          case "None": {
            return none2();
          }
          case "Some": {
            switch (optionB._tag) {
              case "None": {
                return none2();
              }
              case "Some": {
                return some2(exitZipWith(optionA.value, optionB.value, {
                  onSuccess: (a, chunk2) => [a, ...chunk2],
                  onFailure: parallel
                }));
              }
            }
          }
        }
      })),
      interruptAsFork: (fiberId3) => forEachSequentialDiscard(fibers, (fiber) => fiber.interruptAsFork(fiberId3))
    };
    return _fiberAll;
  };
  var raceWith = /* @__PURE__ */ dual(3, (self, other, options) => raceFibersWith(self, other, {
    onSelfWin: (winner, loser) => flatMap8(winner.await, (exit4) => {
      switch (exit4._tag) {
        case OP_SUCCESS: {
          return flatMap8(winner.inheritAll, () => options.onSelfDone(exit4, loser));
        }
        case OP_FAILURE: {
          return options.onSelfDone(exit4, loser);
        }
      }
    }),
    onOtherWin: (winner, loser) => flatMap8(winner.await, (exit4) => {
      switch (exit4._tag) {
        case OP_SUCCESS: {
          return flatMap8(winner.inheritAll, () => options.onOtherDone(exit4, loser));
        }
        case OP_FAILURE: {
          return options.onOtherDone(exit4, loser);
        }
      }
    })
  }));
  var disconnect = (self) => uninterruptibleMask((restore) => fiberIdWith((fiberId3) => flatMap8(forkDaemon(restore(self)), (fiber) => pipe(restore(join2(fiber)), onInterrupt(() => pipe(fiber, interruptAsFork(fiberId3)))))));
  var race = /* @__PURE__ */ dual(2, (self, that) => fiberIdWith((parentFiberId) => raceWith(self, that, {
    onSelfDone: (exit4, right3) => exitMatchEffect(exit4, {
      onFailure: (cause3) => pipe(join2(right3), mapErrorCause((cause22) => parallel(cause3, cause22))),
      onSuccess: (value) => pipe(right3, interruptAsFiber(parentFiberId), as(value))
    }),
    onOtherDone: (exit4, left3) => exitMatchEffect(exit4, {
      onFailure: (cause3) => pipe(join2(left3), mapErrorCause((cause22) => parallel(cause22, cause3))),
      onSuccess: (value) => pipe(left3, interruptAsFiber(parentFiberId), as(value))
    })
  })));
  var raceFibersWith = /* @__PURE__ */ dual(3, (self, other, options) => withFiberRuntime((parentFiber, parentStatus) => {
    const parentRuntimeFlags = parentStatus.runtimeFlags;
    const raceIndicator = make11(true);
    const leftFiber = unsafeMakeChildFiber(self, parentFiber, parentRuntimeFlags, options.selfScope);
    const rightFiber = unsafeMakeChildFiber(other, parentFiber, parentRuntimeFlags, options.otherScope);
    return async_((cb) => {
      leftFiber.addObserver(() => completeRace(leftFiber, rightFiber, options.onSelfWin, raceIndicator, cb));
      rightFiber.addObserver(() => completeRace(rightFiber, leftFiber, options.onOtherWin, raceIndicator, cb));
      leftFiber.startFork(self);
      rightFiber.startFork(other);
    }, combine3(leftFiber.id(), rightFiber.id()));
  }));
  var completeRace = (winner, loser, cont, ab, cb) => {
    if (compareAndSet(true, false)(ab)) {
      cb(cont(winner, loser));
    }
  };
  var ensuring = /* @__PURE__ */ dual(2, (self, finalizer) => uninterruptibleMask((restore) => matchCauseEffect(restore(self), {
    onFailure: (cause1) => matchCauseEffect(finalizer, {
      onFailure: (cause22) => failCause(sequential(cause1, cause22)),
      onSuccess: () => failCause(cause1)
    }),
    onSuccess: (a) => as(finalizer, a)
  })));
  var invokeWithInterrupt = (self, entries2, onInterrupt3) => fiberIdWith((id) => flatMap8(flatMap8(forkDaemon(interruptible2(self)), (processing) => async_((cb) => {
    const counts = entries2.map((_) => _.listeners.count);
    const checkDone = () => {
      if (counts.every((count3) => count3 === 0)) {
        if (entries2.every((_) => {
          if (_.result.state.current._tag === "Pending") {
            return true;
          } else if (_.result.state.current._tag === "Done" && exitIsExit(_.result.state.current.effect) && _.result.state.current.effect._tag === "Failure" && isInterrupted(_.result.state.current.effect.cause)) {
            return true;
          } else {
            return false;
          }
        })) {
          cleanup.forEach((f) => f());
          onInterrupt3?.();
          cb(interruptFiber(processing));
        }
      }
    };
    processing.addObserver((exit4) => {
      cleanup.forEach((f) => f());
      cb(exit4);
    });
    const cleanup = entries2.map((r, i) => {
      const observer = (count3) => {
        counts[i] = count3;
        checkDone();
      };
      r.listeners.addObserver(observer);
      return () => r.listeners.removeObserver(observer);
    });
    checkDone();
    return sync(() => {
      cleanup.forEach((f) => f());
    });
  })), () => suspend(() => {
    const residual = entries2.flatMap((entry) => {
      if (!entry.state.completed) {
        return [entry];
      }
      return [];
    });
    return forEachSequentialDiscard(residual, (entry) => complete(entry.request, exitInterrupt(id)));
  })));
  var makeSpanScoped = (name, options) => {
    options = addSpanStackTrace(options);
    return uninterruptible(withFiberRuntime((fiber) => {
      const scope3 = unsafeGet3(fiber.getFiberRef(currentContext), scopeTag);
      const span2 = unsafeMakeSpan(fiber, name, options);
      const timingEnabled = fiber.getFiberRef(currentTracerTimingEnabled);
      const clock_ = get3(fiber.getFiberRef(currentServices), clockTag);
      return as(scopeAddFinalizerExit(scope3, (exit4) => endSpan(span2, exit4, clock_, timingEnabled)), span2);
    }));
  };
  var withTracerScoped = (value) => fiberRefLocallyScopedWith(currentServices, add2(tracerTag, value));
  var withSpanScoped = function() {
    const dataFirst = typeof arguments[0] !== "string";
    const name = dataFirst ? arguments[1] : arguments[0];
    const options = addSpanStackTrace(dataFirst ? arguments[2] : arguments[1]);
    if (dataFirst) {
      const self = arguments[0];
      return flatMap8(makeSpanScoped(name, addSpanStackTrace(options)), (span2) => provideService(self, spanTag, span2));
    }
    return (self) => flatMap8(makeSpanScoped(name, addSpanStackTrace(options)), (span2) => provideService(self, spanTag, span2));
  };

  // <eztb>/node_modules/effect/dist/esm/internal/cache.js
  var complete2 = (key, exit4, entryStats, timeToLiveMillis) => struct({
    _tag: "Complete",
    key,
    exit: exit4,
    entryStats,
    timeToLiveMillis
  });
  var pending2 = (key, deferred) => struct({
    _tag: "Pending",
    key,
    deferred
  });
  var refreshing = (deferred, complete3) => struct({
    _tag: "Refreshing",
    deferred,
    complete: complete3
  });
  var MapKeyTypeId = /* @__PURE__ */ Symbol.for("effect/Cache/MapKey");
  var _a45;
  var MapKeyImpl = class {
    constructor(current) {
      __publicField(this, "current");
      __publicField(this, _a45, MapKeyTypeId);
      __publicField(this, "previous");
      __publicField(this, "next");
      this.current = current;
    }
    [(_a45 = MapKeyTypeId, symbol)]() {
      return pipe(hash(this.current), combine(hash(this.previous)), combine(hash(this.next)), cached(this));
    }
    [symbol2](that) {
      if (this === that) {
        return true;
      }
      return isMapKey(that) && equals(this.current, that.current) && equals(this.previous, that.previous) && equals(this.next, that.next);
    }
  };
  var makeMapKey = (current) => new MapKeyImpl(current);
  var isMapKey = (u) => hasProperty(u, MapKeyTypeId);
  var KeySetImpl = class {
    constructor() {
      __publicField(this, "head");
      __publicField(this, "tail");
    }
    add(key) {
      if (key !== this.tail) {
        if (this.tail === void 0) {
          this.head = key;
          this.tail = key;
        } else {
          const previous = key.previous;
          const next4 = key.next;
          if (next4 !== void 0) {
            key.next = void 0;
            if (previous !== void 0) {
              previous.next = next4;
              next4.previous = previous;
            } else {
              this.head = next4;
              this.head.previous = void 0;
            }
          }
          this.tail.next = key;
          key.previous = this.tail;
          this.tail = key;
        }
      }
    }
    remove() {
      const key = this.head;
      if (key !== void 0) {
        const next4 = key.next;
        if (next4 !== void 0) {
          key.next = void 0;
          this.head = next4;
          this.head.previous = void 0;
        } else {
          this.head = void 0;
          this.tail = void 0;
        }
      }
      return key;
    }
  };
  var makeKeySet = () => new KeySetImpl();
  var makeCacheState = (map14, keys5, accesses, updating, hits, misses) => ({
    map: map14,
    keys: keys5,
    accesses,
    updating,
    hits,
    misses
  });
  var initialCacheState = () => makeCacheState(empty17(), makeKeySet(), unbounded(), make11(false), 0, 0);
  var CacheSymbolKey = "effect/Cache";
  var CacheTypeId = /* @__PURE__ */ Symbol.for(CacheSymbolKey);
  var cacheVariance = {
    /* c8 ignore next */
    _Key: (_) => _,
    /* c8 ignore next */
    _Error: (_) => _,
    /* c8 ignore next */
    _Value: (_) => _
  };
  var ConsumerCacheSymbolKey = "effect/ConsumerCache";
  var ConsumerCacheTypeId = /* @__PURE__ */ Symbol.for(ConsumerCacheSymbolKey);
  var consumerCacheVariance = {
    /* c8 ignore next */
    _Key: (_) => _,
    /* c8 ignore next */
    _Error: (_) => _,
    /* c8 ignore next */
    _Value: (_) => _
  };
  var makeCacheStats = (options) => options;
  var makeEntryStats = (loadedMillis) => ({
    loadedMillis
  });
  var _a46, _b13;
  _b13 = CacheTypeId, _a46 = ConsumerCacheTypeId;
  var CacheImpl = class {
    constructor(capacity, context4, fiberId3, lookup, timeToLive) {
      __publicField(this, "capacity");
      __publicField(this, "context");
      __publicField(this, "fiberId");
      __publicField(this, "lookup");
      __publicField(this, "timeToLive");
      __publicField(this, _b13, cacheVariance);
      __publicField(this, _a46, consumerCacheVariance);
      __publicField(this, "cacheState");
      this.capacity = capacity;
      this.context = context4;
      this.fiberId = fiberId3;
      this.lookup = lookup;
      this.timeToLive = timeToLive;
      this.cacheState = initialCacheState();
    }
    get(key) {
      return map9(this.getEither(key), merge);
    }
    get cacheStats() {
      return sync(() => makeCacheStats({
        hits: this.cacheState.hits,
        misses: this.cacheState.misses,
        size: size4(this.cacheState.map)
      }));
    }
    getOption(key) {
      return suspend(() => match2(get8(this.cacheState.map, key), {
        onNone: () => {
          const mapKey = makeMapKey(key);
          this.trackAccess(mapKey);
          this.trackMiss();
          return succeed(none2());
        },
        onSome: (value) => this.resolveMapValue(value)
      }));
    }
    getOptionComplete(key) {
      return suspend(() => match2(get8(this.cacheState.map, key), {
        onNone: () => {
          const mapKey = makeMapKey(key);
          this.trackAccess(mapKey);
          this.trackMiss();
          return succeed(none2());
        },
        onSome: (value) => this.resolveMapValue(value, true)
      }));
    }
    contains(key) {
      return sync(() => has4(this.cacheState.map, key));
    }
    entryStats(key) {
      return sync(() => {
        const option3 = get8(this.cacheState.map, key);
        if (isSome2(option3)) {
          switch (option3.value._tag) {
            case "Complete": {
              const loaded = option3.value.entryStats.loadedMillis;
              return some2(makeEntryStats(loaded));
            }
            case "Pending": {
              return none2();
            }
            case "Refreshing": {
              const loaded = option3.value.complete.entryStats.loadedMillis;
              return some2(makeEntryStats(loaded));
            }
          }
        }
        return none2();
      });
    }
    getEither(key) {
      return suspend(() => {
        const k = key;
        let mapKey = void 0;
        let deferred = void 0;
        let value = getOrUndefined2(get8(this.cacheState.map, k));
        if (value === void 0) {
          deferred = unsafeMake3(this.fiberId);
          mapKey = makeMapKey(k);
          if (has4(this.cacheState.map, k)) {
            value = getOrUndefined2(get8(this.cacheState.map, k));
          } else {
            set4(this.cacheState.map, k, pending2(mapKey, deferred));
          }
        }
        if (value === void 0) {
          this.trackAccess(mapKey);
          this.trackMiss();
          return map9(this.lookupValueOf(key, deferred), right2);
        } else {
          return flatMap8(this.resolveMapValue(value), match2({
            onNone: () => this.getEither(key),
            onSome: (value2) => succeed(left2(value2))
          }));
        }
      });
    }
    invalidate(key) {
      return sync(() => {
        remove5(this.cacheState.map, key);
      });
    }
    invalidateWhen(key, when3) {
      return sync(() => {
        const value = get8(this.cacheState.map, key);
        if (isSome2(value) && value.value._tag === "Complete") {
          if (value.value.exit._tag === "Success") {
            if (when3(value.value.exit.value)) {
              remove5(this.cacheState.map, key);
            }
          }
        }
      });
    }
    get invalidateAll() {
      return sync(() => {
        this.cacheState.map = empty17();
      });
    }
    refresh(key) {
      return clockWith3((clock3) => suspend(() => {
        const k = key;
        const deferred = unsafeMake3(this.fiberId);
        let value = getOrUndefined2(get8(this.cacheState.map, k));
        if (value === void 0) {
          if (has4(this.cacheState.map, k)) {
            value = getOrUndefined2(get8(this.cacheState.map, k));
          } else {
            set4(this.cacheState.map, k, pending2(makeMapKey(k), deferred));
          }
        }
        if (value === void 0) {
          return asVoid(this.lookupValueOf(key, deferred));
        } else {
          switch (value._tag) {
            case "Complete": {
              if (this.hasExpired(clock3, value.timeToLiveMillis)) {
                const found = getOrUndefined2(get8(this.cacheState.map, k));
                if (equals(found, value)) {
                  remove5(this.cacheState.map, k);
                }
                return asVoid(this.get(key));
              }
              return pipe(this.lookupValueOf(key, deferred), when(() => {
                const current = getOrUndefined2(get8(this.cacheState.map, k));
                if (equals(current, value)) {
                  const mapValue = refreshing(deferred, value);
                  set4(this.cacheState.map, k, mapValue);
                  return true;
                }
                return false;
              }), asVoid);
            }
            case "Pending": {
              return _await(value.deferred);
            }
            case "Refreshing": {
              return _await(value.deferred);
            }
          }
        }
      }));
    }
    set(key, value) {
      return clockWith3((clock3) => sync(() => {
        const now = clock3.unsafeCurrentTimeMillis();
        const k = key;
        const lookupResult = succeed2(value);
        const mapValue = complete2(makeMapKey(k), lookupResult, makeEntryStats(now), now + toMillis(decode(this.timeToLive(lookupResult))));
        set4(this.cacheState.map, k, mapValue);
      }));
    }
    get size() {
      return sync(() => {
        return size4(this.cacheState.map);
      });
    }
    get values() {
      return sync(() => {
        const values3 = [];
        for (const entry of this.cacheState.map) {
          if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
            values3.push(entry[1].exit.value);
          }
        }
        return values3;
      });
    }
    get entries() {
      return sync(() => {
        const values3 = [];
        for (const entry of this.cacheState.map) {
          if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
            values3.push([entry[0], entry[1].exit.value]);
          }
        }
        return values3;
      });
    }
    get keys() {
      return sync(() => {
        const keys5 = [];
        for (const entry of this.cacheState.map) {
          if (entry[1]._tag === "Complete" && entry[1].exit._tag === "Success") {
            keys5.push(entry[0]);
          }
        }
        return keys5;
      });
    }
    resolveMapValue(value, ignorePending = false) {
      return clockWith3((clock3) => {
        switch (value._tag) {
          case "Complete": {
            this.trackAccess(value.key);
            if (this.hasExpired(clock3, value.timeToLiveMillis)) {
              remove5(this.cacheState.map, value.key.current);
              return succeed(none2());
            }
            this.trackHit();
            return map9(value.exit, some2);
          }
          case "Pending": {
            this.trackAccess(value.key);
            this.trackHit();
            if (ignorePending) {
              return succeed(none2());
            }
            return map9(_await(value.deferred), some2);
          }
          case "Refreshing": {
            this.trackAccess(value.complete.key);
            this.trackHit();
            if (this.hasExpired(clock3, value.complete.timeToLiveMillis)) {
              if (ignorePending) {
                return succeed(none2());
              }
              return map9(_await(value.deferred), some2);
            }
            return map9(value.complete.exit, some2);
          }
        }
      });
    }
    trackHit() {
      this.cacheState.hits = this.cacheState.hits + 1;
    }
    trackMiss() {
      this.cacheState.misses = this.cacheState.misses + 1;
    }
    trackAccess(key) {
      offer(this.cacheState.accesses, key);
      if (compareAndSet(this.cacheState.updating, false, true)) {
        let loop3 = true;
        while (loop3) {
          const key2 = poll(this.cacheState.accesses, EmptyMutableQueue);
          if (key2 === EmptyMutableQueue) {
            loop3 = false;
          } else {
            this.cacheState.keys.add(key2);
          }
        }
        let size9 = size4(this.cacheState.map);
        loop3 = size9 > this.capacity;
        while (loop3) {
          const key2 = this.cacheState.keys.remove();
          if (key2 !== void 0) {
            if (has4(this.cacheState.map, key2.current)) {
              remove5(this.cacheState.map, key2.current);
              size9 = size9 - 1;
              loop3 = size9 > this.capacity;
            }
          } else {
            loop3 = false;
          }
        }
        set2(this.cacheState.updating, false);
      }
    }
    hasExpired(clock3, timeToLiveMillis) {
      return clock3.unsafeCurrentTimeMillis() > timeToLiveMillis;
    }
    lookupValueOf(input, deferred) {
      return clockWith3((clock3) => suspend(() => {
        const key = input;
        return pipe(this.lookup(input), provideContext(this.context), exit, flatMap8((exit4) => {
          const now = clock3.unsafeCurrentTimeMillis();
          const stats = makeEntryStats(now);
          const value = complete2(makeMapKey(key), exit4, stats, now + toMillis(decode(this.timeToLive(exit4))));
          set4(this.cacheState.map, key, value);
          return zipRight(done2(deferred, exit4), exit4);
        }), onInterrupt(() => zipRight(interrupt3(deferred), sync(() => {
          remove5(this.cacheState.map, key);
        }))));
      }));
    }
  };
  var make34 = (options) => {
    const timeToLive = decode(options.timeToLive);
    return makeWith({
      capacity: options.capacity,
      lookup: options.lookup,
      timeToLive: () => timeToLive
    });
  };
  var makeWith = (options) => map9(all3([context(), fiberId]), ([context4, fiberId3]) => new CacheImpl(options.capacity, context4, fiberId3, options.lookup, (exit4) => decode(options.timeToLive(exit4))));
  var unsafeMakeWith = (capacity, lookup, timeToLive) => new CacheImpl(capacity, empty3(), none3, lookup, (exit4) => decode(timeToLive(exit4)));

  // <eztb>/node_modules/effect/dist/esm/Cache.js
  var CacheTypeId2 = CacheTypeId;
  var ConsumerCacheTypeId2 = ConsumerCacheTypeId;
  var make35 = make34;
  var makeWith2 = makeWith;
  var makeCacheStats2 = makeCacheStats;
  var makeEntryStats2 = makeEntryStats;

  // <eztb>/node_modules/effect/dist/esm/Cause.js
  var IllegalArgumentException2 = IllegalArgumentException;

  // <eztb>/node_modules/effect/dist/esm/Effect.js
  var Effect_exports = {};
  __export(Effect_exports, {
    Do: () => Do3,
    EffectTypeId: () => EffectTypeId3,
    Service: () => Service,
    Tag: () => Tag2,
    acquireRelease: () => acquireRelease2,
    acquireReleaseInterruptible: () => acquireReleaseInterruptible2,
    acquireUseRelease: () => acquireUseRelease2,
    addFinalizer: () => addFinalizer2,
    all: () => all4,
    allSuccesses: () => allSuccesses2,
    allWith: () => allWith2,
    allowInterrupt: () => allowInterrupt2,
    andThen: () => andThen5,
    annotateCurrentSpan: () => annotateCurrentSpan2,
    annotateLogs: () => annotateLogs2,
    annotateLogsScoped: () => annotateLogsScoped2,
    annotateSpans: () => annotateSpans2,
    ap: () => ap2,
    as: () => as4,
    asSome: () => asSome2,
    asSomeError: () => asSomeError2,
    asVoid: () => asVoid3,
    async: () => async2,
    asyncEffect: () => asyncEffect2,
    awaitAllChildren: () => awaitAllChildren2,
    bind: () => bind4,
    bindAll: () => bindAll2,
    bindTo: () => bindTo4,
    blocked: () => blocked2,
    cacheRequestResult: () => cacheRequestResult,
    cached: () => cached3,
    cachedFunction: () => cachedFunction2,
    cachedInvalidateWithTTL: () => cachedInvalidateWithTTL2,
    cachedWithTTL: () => cachedWithTTL,
    catch: () => _catch2,
    catchAll: () => catchAll2,
    catchAllCause: () => catchAllCause2,
    catchAllDefect: () => catchAllDefect2,
    catchIf: () => catchIf2,
    catchSome: () => catchSome2,
    catchSomeCause: () => catchSomeCause2,
    catchSomeDefect: () => catchSomeDefect2,
    catchTag: () => catchTag2,
    catchTags: () => catchTags2,
    cause: () => cause2,
    checkInterruptible: () => checkInterruptible2,
    clock: () => clock2,
    clockWith: () => clockWith4,
    configProviderWith: () => configProviderWith2,
    console: () => console3,
    consoleWith: () => consoleWith2,
    context: () => context3,
    contextWith: () => contextWith2,
    contextWithEffect: () => contextWithEffect2,
    currentParentSpan: () => currentParentSpan2,
    currentSpan: () => currentSpan2,
    custom: () => custom2,
    daemonChildren: () => daemonChildren2,
    delay: () => delay2,
    descriptor: () => descriptor2,
    descriptorWith: () => descriptorWith2,
    die: () => die3,
    dieMessage: () => dieMessage2,
    dieSync: () => dieSync2,
    diffFiberRefs: () => diffFiberRefs2,
    disconnect: () => disconnect2,
    dropUntil: () => dropUntil2,
    dropWhile: () => dropWhile2,
    either: () => either4,
    ensureErrorType: () => ensureErrorType,
    ensureRequirementsType: () => ensureRequirementsType,
    ensureSuccessType: () => ensureSuccessType,
    ensuring: () => ensuring3,
    ensuringChild: () => ensuringChild2,
    ensuringChildren: () => ensuringChildren2,
    eventually: () => eventually2,
    every: () => every5,
    exists: () => exists2,
    exit: () => exit3,
    fail: () => fail4,
    failCause: () => failCause4,
    failCauseSync: () => failCauseSync2,
    failSync: () => failSync2,
    fiberId: () => fiberId2,
    fiberIdWith: () => fiberIdWith2,
    filter: () => filter5,
    filterEffectOrElse: () => filterEffectOrElse2,
    filterEffectOrFail: () => filterEffectOrFail2,
    filterMap: () => filterMap4,
    filterOrDie: () => filterOrDie2,
    filterOrDieMessage: () => filterOrDieMessage2,
    filterOrElse: () => filterOrElse2,
    filterOrFail: () => filterOrFail2,
    finalizersMask: () => finalizersMask2,
    findFirst: () => findFirst5,
    firstSuccessOf: () => firstSuccessOf2,
    flatMap: () => flatMap10,
    flatten: () => flatten6,
    flip: () => flip3,
    flipWith: () => flipWith2,
    fn: () => fn,
    fnUntraced: () => fnUntraced2,
    forEach: () => forEach8,
    forever: () => forever3,
    fork: () => fork3,
    forkAll: () => forkAll2,
    forkDaemon: () => forkDaemon2,
    forkIn: () => forkIn2,
    forkScoped: () => forkScoped2,
    forkWithErrorHandler: () => forkWithErrorHandler2,
    fromFiber: () => fromFiber2,
    fromFiberEffect: () => fromFiberEffect2,
    fromNullable: () => fromNullable4,
    functionWithSpan: () => functionWithSpan2,
    gen: () => gen3,
    getFiberRefs: () => getFiberRefs,
    getRuntimeFlags: () => getRuntimeFlags,
    head: () => head4,
    if: () => if_2,
    ignore: () => ignore2,
    ignoreLogged: () => ignoreLogged2,
    inheritFiberRefs: () => inheritFiberRefs2,
    interrupt: () => interrupt4,
    interruptWith: () => interruptWith2,
    interruptible: () => interruptible4,
    interruptibleMask: () => interruptibleMask2,
    intoDeferred: () => intoDeferred2,
    isEffect: () => isEffect2,
    isFailure: () => isFailure2,
    isSuccess: () => isSuccess2,
    iterate: () => iterate2,
    labelMetrics: () => labelMetrics2,
    labelMetricsScoped: () => labelMetricsScoped2,
    let: () => let_4,
    liftPredicate: () => liftPredicate3,
    linkSpanCurrent: () => linkSpanCurrent2,
    linkSpans: () => linkSpans2,
    locally: () => locally,
    locallyScoped: () => locallyScoped,
    locallyScopedWith: () => locallyScopedWith,
    locallyWith: () => locallyWith,
    log: () => log3,
    logAnnotations: () => logAnnotations2,
    logDebug: () => logDebug2,
    logError: () => logError2,
    logFatal: () => logFatal2,
    logInfo: () => logInfo2,
    logTrace: () => logTrace2,
    logWarning: () => logWarning2,
    logWithLevel: () => logWithLevel2,
    loop: () => loop2,
    makeLatch: () => makeLatch2,
    makeSemaphore: () => makeSemaphore2,
    makeSpan: () => makeSpan2,
    makeSpanScoped: () => makeSpanScoped2,
    map: () => map12,
    mapAccum: () => mapAccum3,
    mapBoth: () => mapBoth4,
    mapError: () => mapError2,
    mapErrorCause: () => mapErrorCause2,
    mapInputContext: () => mapInputContext3,
    match: () => match10,
    matchCause: () => matchCause3,
    matchCauseEffect: () => matchCauseEffect3,
    matchEffect: () => matchEffect2,
    merge: () => merge6,
    mergeAll: () => mergeAll5,
    metricLabels: () => metricLabels2,
    negate: () => negate2,
    never: () => never2,
    none: () => none9,
    onError: () => onError2,
    onExit: () => onExit3,
    onInterrupt: () => onInterrupt2,
    once: () => once3,
    option: () => option2,
    optionFromOptional: () => optionFromOptional2,
    orDie: () => orDie2,
    orDieWith: () => orDieWith2,
    orElse: () => orElse3,
    orElseFail: () => orElseFail2,
    orElseSucceed: () => orElseSucceed2,
    parallelErrors: () => parallelErrors2,
    parallelFinalizers: () => parallelFinalizers2,
    partition: () => partition4,
    patchFiberRefs: () => patchFiberRefs2,
    patchRuntimeFlags: () => patchRuntimeFlags,
    promise: () => promise2,
    provide: () => provide2,
    provideService: () => provideService3,
    provideServiceEffect: () => provideServiceEffect2,
    race: () => race2,
    raceAll: () => raceAll2,
    raceFirst: () => raceFirst2,
    raceWith: () => raceWith2,
    random: () => random3,
    randomWith: () => randomWith2,
    reduce: () => reduce11,
    reduceEffect: () => reduceEffect3,
    reduceRight: () => reduceRight3,
    reduceWhile: () => reduceWhile2,
    repeat: () => repeat,
    repeatN: () => repeatN2,
    repeatOrElse: () => repeatOrElse,
    replicate: () => replicate2,
    replicateEffect: () => replicateEffect2,
    request: () => request,
    retry: () => retry,
    retryOrElse: () => retryOrElse,
    runCallback: () => runCallback,
    runFork: () => runFork2,
    runPromise: () => runPromise,
    runPromiseExit: () => runPromiseExit,
    runRequestBlock: () => runRequestBlock2,
    runSync: () => runSync,
    runSyncExit: () => runSyncExit,
    runtime: () => runtime3,
    sandbox: () => sandbox2,
    schedule: () => schedule,
    scheduleForked: () => scheduleForked2,
    scheduleFrom: () => scheduleFrom,
    scope: () => scope2,
    scopeWith: () => scopeWith2,
    scoped: () => scoped2,
    scopedWith: () => scopedWith2,
    sequentialFinalizers: () => sequentialFinalizers2,
    serviceConstants: () => serviceConstants2,
    serviceFunction: () => serviceFunction2,
    serviceFunctionEffect: () => serviceFunctionEffect2,
    serviceFunctions: () => serviceFunctions2,
    serviceMembers: () => serviceMembers2,
    serviceOption: () => serviceOption2,
    serviceOptional: () => serviceOptional2,
    setFiberRefs: () => setFiberRefs2,
    sleep: () => sleep4,
    spanAnnotations: () => spanAnnotations2,
    spanLinks: () => spanLinks2,
    step: () => step3,
    succeed: () => succeed7,
    succeedNone: () => succeedNone2,
    succeedSome: () => succeedSome2,
    summarized: () => summarized2,
    supervised: () => supervised2,
    suspend: () => suspend4,
    sync: () => sync5,
    tagMetrics: () => tagMetrics2,
    tagMetricsScoped: () => tagMetricsScoped2,
    takeUntil: () => takeUntil2,
    takeWhile: () => takeWhile2,
    tap: () => tap2,
    tapBoth: () => tapBoth2,
    tapDefect: () => tapDefect2,
    tapError: () => tapError2,
    tapErrorCause: () => tapErrorCause2,
    tapErrorTag: () => tapErrorTag2,
    timed: () => timed2,
    timedWith: () => timedWith2,
    timeout: () => timeout2,
    timeoutFail: () => timeoutFail2,
    timeoutFailCause: () => timeoutFailCause2,
    timeoutOption: () => timeoutOption2,
    timeoutTo: () => timeoutTo2,
    tracer: () => tracer2,
    tracerWith: () => tracerWith4,
    transplant: () => transplant2,
    transposeMapOption: () => transposeMapOption2,
    transposeOption: () => transposeOption2,
    try: () => try_3,
    tryMap: () => tryMap2,
    tryMapPromise: () => tryMapPromise2,
    tryPromise: () => tryPromise2,
    uninterruptible: () => uninterruptible2,
    uninterruptibleMask: () => uninterruptibleMask3,
    unless: () => unless2,
    unlessEffect: () => unlessEffect2,
    unsafeMakeLatch: () => unsafeMakeLatch2,
    unsafeMakeSemaphore: () => unsafeMakeSemaphore2,
    unsandbox: () => unsandbox2,
    updateFiberRefs: () => updateFiberRefs2,
    updateService: () => updateService2,
    useSpan: () => useSpan2,
    using: () => using2,
    validate: () => validate2,
    validateAll: () => validateAll2,
    validateFirst: () => validateFirst2,
    validateWith: () => validateWith2,
    void: () => _void,
    when: () => when2,
    whenEffect: () => whenEffect2,
    whenFiberRef: () => whenFiberRef2,
    whenLogLevel: () => whenLogLevel2,
    whenRef: () => whenRef2,
    whileLoop: () => whileLoop3,
    withClock: () => withClock2,
    withClockScoped: () => withClockScoped2,
    withConcurrency: () => withConcurrency2,
    withConfigProvider: () => withConfigProvider2,
    withConfigProviderScoped: () => withConfigProviderScoped2,
    withConsole: () => withConsole2,
    withConsoleScoped: () => withConsoleScoped2,
    withEarlyRelease: () => withEarlyRelease2,
    withExecutionPlan: () => withExecutionPlan2,
    withFiberRuntime: () => withFiberRuntime2,
    withLogSpan: () => withLogSpan2,
    withMaxOpsBeforeYield: () => withMaxOpsBeforeYield2,
    withMetric: () => withMetric2,
    withParentSpan: () => withParentSpan2,
    withRandom: () => withRandom2,
    withRandomFixed: () => withRandomFixed,
    withRandomScoped: () => withRandomScoped2,
    withRequestBatching: () => withRequestBatching2,
    withRequestCache: () => withRequestCache2,
    withRequestCaching: () => withRequestCaching2,
    withRuntimeFlagsPatch: () => withRuntimeFlagsPatch,
    withRuntimeFlagsPatchScoped: () => withRuntimeFlagsPatchScoped,
    withScheduler: () => withScheduler2,
    withSchedulingPriority: () => withSchedulingPriority2,
    withSpan: () => withSpan2,
    withSpanScoped: () => withSpanScoped2,
    withTracer: () => withTracer2,
    withTracerEnabled: () => withTracerEnabled2,
    withTracerScoped: () => withTracerScoped2,
    withTracerTiming: () => withTracerTiming2,
    withUnhandledErrorLogLevel: () => withUnhandledErrorLogLevel2,
    yieldNow: () => yieldNow4,
    zip: () => zip4,
    zipLeft: () => zipLeft3,
    zipRight: () => zipRight3,
    zipWith: () => zipWith5
  });

  // <eztb>/node_modules/effect/dist/esm/internal/schedule/interval.js
  var IntervalSymbolKey = "effect/ScheduleInterval";
  var IntervalTypeId = /* @__PURE__ */ Symbol.for(IntervalSymbolKey);
  var empty26 = {
    [IntervalTypeId]: IntervalTypeId,
    startMillis: 0,
    endMillis: 0
  };
  var make36 = (startMillis, endMillis) => {
    if (startMillis > endMillis) {
      return empty26;
    }
    return {
      [IntervalTypeId]: IntervalTypeId,
      startMillis,
      endMillis
    };
  };
  var lessThan3 = /* @__PURE__ */ dual(2, (self, that) => min3(self, that) === self);
  var min3 = /* @__PURE__ */ dual(2, (self, that) => {
    if (self.endMillis <= that.startMillis) return self;
    if (that.endMillis <= self.startMillis) return that;
    if (self.startMillis < that.startMillis) return self;
    if (that.startMillis < self.startMillis) return that;
    if (self.endMillis <= that.endMillis) return self;
    return that;
  });
  var isEmpty7 = (self) => {
    return self.startMillis >= self.endMillis;
  };
  var intersect = /* @__PURE__ */ dual(2, (self, that) => {
    const start3 = Math.max(self.startMillis, that.startMillis);
    const end3 = Math.min(self.endMillis, that.endMillis);
    return make36(start3, end3);
  });
  var size7 = (self) => {
    return millis(self.endMillis - self.startMillis);
  };
  var after = (startMilliseconds) => {
    return make36(startMilliseconds, Number.POSITIVE_INFINITY);
  };

  // <eztb>/node_modules/effect/dist/esm/ScheduleInterval.js
  var make37 = make36;
  var empty27 = empty26;
  var lessThan4 = lessThan3;
  var isEmpty8 = isEmpty7;
  var intersect2 = intersect;
  var size8 = size7;
  var after2 = after;

  // <eztb>/node_modules/effect/dist/esm/internal/schedule/intervals.js
  var IntervalsSymbolKey = "effect/ScheduleIntervals";
  var IntervalsTypeId = /* @__PURE__ */ Symbol.for(IntervalsSymbolKey);
  var make38 = (intervals) => {
    return {
      [IntervalsTypeId]: IntervalsTypeId,
      intervals
    };
  };
  var union6 = /* @__PURE__ */ dual(2, (self, that) => {
    if (!isNonEmpty(that.intervals)) {
      return self;
    }
    if (!isNonEmpty(self.intervals)) {
      return that;
    }
    if (headNonEmpty2(self.intervals).startMillis < headNonEmpty2(that.intervals).startMillis) {
      return unionLoop(tailNonEmpty2(self.intervals), that.intervals, headNonEmpty2(self.intervals), empty4());
    }
    return unionLoop(self.intervals, tailNonEmpty2(that.intervals), headNonEmpty2(that.intervals), empty4());
  });
  var unionLoop = (_self, _that, _interval, _acc) => {
    let self = _self;
    let that = _that;
    let interval = _interval;
    let acc = _acc;
    while (isNonEmpty(self) || isNonEmpty(that)) {
      if (!isNonEmpty(self) && isNonEmpty(that)) {
        if (interval.endMillis < headNonEmpty2(that).startMillis) {
          acc = pipe(acc, prepend2(interval));
          interval = headNonEmpty2(that);
          that = tailNonEmpty2(that);
          self = empty4();
        } else {
          interval = make37(interval.startMillis, headNonEmpty2(that).endMillis);
          that = tailNonEmpty2(that);
          self = empty4();
        }
      } else if (isNonEmpty(self) && isEmpty(that)) {
        if (interval.endMillis < headNonEmpty2(self).startMillis) {
          acc = pipe(acc, prepend2(interval));
          interval = headNonEmpty2(self);
          that = empty4();
          self = tailNonEmpty2(self);
        } else {
          interval = make37(interval.startMillis, headNonEmpty2(self).endMillis);
          that = empty4();
          self = tailNonEmpty2(self);
        }
      } else if (isNonEmpty(self) && isNonEmpty(that)) {
        if (headNonEmpty2(self).startMillis < headNonEmpty2(that).startMillis) {
          if (interval.endMillis < headNonEmpty2(self).startMillis) {
            acc = pipe(acc, prepend2(interval));
            interval = headNonEmpty2(self);
            self = tailNonEmpty2(self);
          } else {
            interval = make37(interval.startMillis, headNonEmpty2(self).endMillis);
            self = tailNonEmpty2(self);
          }
        } else if (interval.endMillis < headNonEmpty2(that).startMillis) {
          acc = pipe(acc, prepend2(interval));
          interval = headNonEmpty2(that);
          that = tailNonEmpty2(that);
        } else {
          interval = make37(interval.startMillis, headNonEmpty2(that).endMillis);
          that = tailNonEmpty2(that);
        }
      } else {
        throw new Error(getBugErrorMessage("Intervals.unionLoop"));
      }
    }
    return make38(pipe(acc, prepend2(interval), reverse2));
  };
  var intersect3 = /* @__PURE__ */ dual(2, (self, that) => intersectLoop(self.intervals, that.intervals, empty4()));
  var intersectLoop = (_left, _right, _acc) => {
    let left3 = _left;
    let right3 = _right;
    let acc = _acc;
    while (isNonEmpty(left3) && isNonEmpty(right3)) {
      const interval = pipe(headNonEmpty2(left3), intersect2(headNonEmpty2(right3)));
      const intervals = isEmpty8(interval) ? acc : pipe(acc, prepend2(interval));
      if (pipe(headNonEmpty2(left3), lessThan4(headNonEmpty2(right3)))) {
        left3 = tailNonEmpty2(left3);
      } else {
        right3 = tailNonEmpty2(right3);
      }
      acc = intervals;
    }
    return make38(reverse2(acc));
  };
  var start = (self) => {
    return pipe(self.intervals, head2, getOrElse2(() => empty27)).startMillis;
  };
  var end = (self) => {
    return pipe(self.intervals, head2, getOrElse2(() => empty27)).endMillis;
  };
  var lessThan5 = /* @__PURE__ */ dual(2, (self, that) => start(self) < start(that));
  var isNonEmpty3 = (self) => {
    return isNonEmpty(self.intervals);
  };
  var max4 = /* @__PURE__ */ dual(2, (self, that) => lessThan5(self, that) ? that : self);

  // <eztb>/node_modules/effect/dist/esm/ScheduleIntervals.js
  var make39 = make38;
  var union7 = union6;
  var intersect4 = intersect3;
  var start2 = start;
  var end2 = end;
  var lessThan6 = lessThan5;
  var isNonEmpty4 = isNonEmpty3;
  var max5 = max4;

  // <eztb>/node_modules/effect/dist/esm/internal/schedule/decision.js
  var OP_CONTINUE = "Continue";
  var OP_DONE2 = "Done";
  var _continue = (intervals) => {
    return {
      _tag: OP_CONTINUE,
      intervals
    };
  };
  var continueWith = (interval) => {
    return {
      _tag: OP_CONTINUE,
      intervals: make39(of2(interval))
    };
  };
  var done5 = {
    _tag: OP_DONE2
  };
  var isContinue = (self) => {
    return self._tag === OP_CONTINUE;
  };
  var isDone3 = (self) => {
    return self._tag === OP_DONE2;
  };

  // <eztb>/node_modules/effect/dist/esm/ScheduleDecision.js
  var _continue2 = _continue;
  var continueWith2 = continueWith;
  var done6 = done5;
  var isContinue2 = isContinue;
  var isDone4 = isDone3;

  // <eztb>/node_modules/effect/dist/esm/Scope.js
  var close = scopeClose;
  var fork2 = scopeFork;

  // <eztb>/node_modules/effect/dist/esm/internal/effect/circular.js
  var Semaphore = class {
    constructor(permits) {
      __publicField(this, "permits");
      __publicField(this, "waiters", /* @__PURE__ */ new Set());
      __publicField(this, "taken", 0);
      __publicField(this, "take", (n) => asyncInterrupt((resume2) => {
        if (this.free < n) {
          const observer = () => {
            if (this.free < n) {
              return;
            }
            this.waiters.delete(observer);
            this.taken += n;
            resume2(succeed(n));
          };
          this.waiters.add(observer);
          return sync(() => {
            this.waiters.delete(observer);
          });
        }
        this.taken += n;
        return resume2(succeed(n));
      }));
      __publicField(this, "resize", (permits) => asVoid(withFiberRuntime((fiber) => {
        this.permits = permits;
        if (this.free < 0) {
          return void_2;
        }
        return this.updateTakenUnsafe(fiber, (taken) => taken);
      })));
      __publicField(this, "release", (n) => this.updateTaken((taken) => taken - n));
      __publicField(this, "releaseAll", /* @__PURE__ */ this.updateTaken((_) => 0));
      __publicField(this, "withPermits", (n) => (self) => uninterruptibleMask((restore) => flatMap8(restore(this.take(n)), (permits) => ensuring(restore(self), this.release(permits)))));
      __publicField(this, "withPermitsIfAvailable", (n) => (self) => uninterruptibleMask((restore) => suspend(() => {
        if (this.free < n) {
          return succeedNone;
        }
        this.taken += n;
        return ensuring(restore(asSome(self)), this.release(n));
      })));
      this.permits = permits;
    }
    get free() {
      return this.permits - this.taken;
    }
    updateTakenUnsafe(fiber, f) {
      this.taken = f(this.taken);
      if (this.waiters.size > 0) {
        fiber.getFiberRef(currentScheduler).scheduleTask(() => {
          const iter = this.waiters.values();
          let item = iter.next();
          while (item.done === false && this.free > 0) {
            item.value();
            item = iter.next();
          }
        }, fiber.getFiberRef(currentSchedulingPriority));
      }
      return succeed(this.free);
    }
    updateTaken(f) {
      return withFiberRuntime((fiber) => this.updateTakenUnsafe(fiber, f));
    }
  };
  var unsafeMakeSemaphore = (permits) => new Semaphore(permits);
  var makeSemaphore = (permits) => sync(() => unsafeMakeSemaphore(permits));
  var Latch = class extends Class2 {
    constructor(isOpen) {
      super();
      __publicField(this, "isOpen");
      __publicField(this, "waiters", []);
      __publicField(this, "scheduled", false);
      __publicField(this, "flushWaiters", () => {
        this.scheduled = false;
        const waiters = this.waiters;
        this.waiters = [];
        for (let i = 0; i < waiters.length; i++) {
          waiters[i](exitVoid);
        }
      });
      __publicField(this, "open", /* @__PURE__ */ withFiberRuntime((fiber) => {
        if (this.isOpen) {
          return void_2;
        }
        this.isOpen = true;
        return this.unsafeSchedule(fiber);
      }));
      __publicField(this, "release", /* @__PURE__ */ withFiberRuntime((fiber) => {
        if (this.isOpen) {
          return void_2;
        }
        return this.unsafeSchedule(fiber);
      }));
      __publicField(this, "await", /* @__PURE__ */ asyncInterrupt((resume2) => {
        if (this.isOpen) {
          return resume2(void_2);
        }
        this.waiters.push(resume2);
        return sync(() => {
          const index = this.waiters.indexOf(resume2);
          if (index !== -1) {
            this.waiters.splice(index, 1);
          }
        });
      }));
      __publicField(this, "close", /* @__PURE__ */ sync(() => {
        this.isOpen = false;
      }));
      __publicField(this, "whenOpen", (self) => {
        return zipRight(this.await, self);
      });
      this.isOpen = isOpen;
    }
    commit() {
      return this.await;
    }
    unsafeSchedule(fiber) {
      if (this.scheduled || this.waiters.length === 0) {
        return void_2;
      }
      this.scheduled = true;
      fiber.currentScheduler.scheduleTask(this.flushWaiters, fiber.getFiberRef(currentSchedulingPriority));
      return void_2;
    }
    unsafeOpen() {
      if (this.isOpen) return;
      this.isOpen = true;
      this.flushWaiters();
    }
    unsafeClose() {
      this.isOpen = false;
    }
  };
  var unsafeMakeLatch = (open) => new Latch(open ?? false);
  var makeLatch = (open) => sync(() => unsafeMakeLatch(open));
  var awaitAllChildren = (self) => ensuringChildren(self, fiberAwaitAll);
  var cached2 = /* @__PURE__ */ dual(2, (self, timeToLive) => map9(cachedInvalidateWithTTL(self, timeToLive), (tuple) => tuple[0]));
  var cachedInvalidateWithTTL = /* @__PURE__ */ dual(2, (self, timeToLive) => {
    const duration3 = decode(timeToLive);
    return flatMap8(context(), (env) => map9(makeSynchronized(none2()), (cache7) => [provideContext(getCachedValue(self, duration3, cache7), env), invalidateCache(cache7)]));
  });
  var computeCachedValue = (self, timeToLive, start3) => {
    const timeToLiveMillis = toMillis(decode(timeToLive));
    return pipe(deferredMake(), tap((deferred) => intoDeferred(self, deferred)), map9((deferred) => some2([start3 + timeToLiveMillis, deferred])));
  };
  var getCachedValue = (self, timeToLive, cache7) => uninterruptibleMask((restore) => pipe(clockWith3((clock3) => clock3.currentTimeMillis), flatMap8((time) => updateSomeAndGetEffectSynchronized(cache7, (option3) => {
    switch (option3._tag) {
      case "None": {
        return some2(computeCachedValue(self, timeToLive, time));
      }
      case "Some": {
        const [end3] = option3.value;
        return end3 - time <= 0 ? some2(computeCachedValue(self, timeToLive, time)) : none2();
      }
    }
  })), flatMap8((option3) => isNone2(option3) ? dieMessage("BUG: Effect.cachedInvalidate - please report an issue at https://github.com/Effect-TS/effect/issues") : restore(deferredAwait(option3.value[1])))));
  var invalidateCache = (cache7) => set5(cache7, none2());
  var ensuringChild = /* @__PURE__ */ dual(2, (self, f) => ensuringChildren(self, (children) => f(fiberAll(children))));
  var ensuringChildren = /* @__PURE__ */ dual(2, (self, children) => flatMap8(track, (supervisor) => pipe(supervised(self, supervisor), ensuring(flatMap8(supervisor.value, children)))));
  var forkAll = /* @__PURE__ */ dual((args2) => isIterable(args2[0]), (effects, options) => options?.discard ? forEachSequentialDiscard(effects, fork) : map9(forEachSequential(effects, fork), fiberAll));
  var forkIn = /* @__PURE__ */ dual(2, (self, scope3) => withFiberRuntime((parent, parentStatus) => {
    const scopeImpl = scope3;
    const fiber = unsafeFork2(self, parent, parentStatus.runtimeFlags, globalScope);
    if (scopeImpl.state._tag === "Open") {
      const finalizer = () => fiberIdWith((fiberId3) => equals(fiberId3, fiber.id()) ? void_2 : asVoid(interruptFiber(fiber)));
      const key = {};
      scopeImpl.state.finalizers.set(key, finalizer);
      fiber.addObserver(() => {
        if (scopeImpl.state._tag === "Closed") return;
        scopeImpl.state.finalizers.delete(key);
      });
    } else {
      fiber.unsafeInterruptAsFork(parent.id());
    }
    return succeed(fiber);
  }));
  var forkScoped = (self) => scopeWith((scope3) => forkIn(self, scope3));
  var fromFiber = (fiber) => join2(fiber);
  var fromFiberEffect = (fiber) => suspend(() => flatMap8(fiber, join2));
  var memoKeySymbol = /* @__PURE__ */ Symbol.for("effect/Effect/memoizeFunction.key");
  var _a47;
  var Key = class {
    constructor(a, eq) {
      __publicField(this, "a");
      __publicField(this, "eq");
      __publicField(this, _a47, memoKeySymbol);
      this.a = a;
      this.eq = eq;
    }
    [(_a47 = memoKeySymbol, symbol2)](that) {
      if (hasProperty(that, memoKeySymbol)) {
        if (this.eq) {
          return this.eq(this.a, that.a);
        } else {
          return equals(this.a, that.a);
        }
      }
      return false;
    }
    [symbol]() {
      return this.eq ? 0 : cached(this, hash(this.a));
    }
  };
  var cachedFunction = (f, eq) => {
    return pipe(sync(() => empty17()), flatMap8(makeSynchronized), map9((ref) => (a) => pipe(ref.modifyEffect((map14) => {
      const result = pipe(map14, get8(new Key(a, eq)));
      if (isNone2(result)) {
        return pipe(deferredMake(), tap((deferred) => pipe(diffFiberRefs(f(a)), intoDeferred(deferred), fork)), map9((deferred) => [deferred, pipe(map14, set4(new Key(a, eq), deferred))]));
      }
      return succeed([result.value, map14]);
    }), flatMap8(deferredAwait), flatMap8(([patch9, b]) => pipe(patchFiberRefs(patch9), as(b))))));
  };
  var raceFirst = /* @__PURE__ */ dual(2, (self, that) => pipe(exit(self), race(exit(that)), (effect) => flatten4(effect)));
  var supervised = /* @__PURE__ */ dual(2, (self, supervisor) => {
    const supervise = fiberRefLocallyWith(currentSupervisor, (s) => s.zip(supervisor));
    return supervise(self);
  });
  var timeout = /* @__PURE__ */ dual(2, (self, duration3) => timeoutFail(self, {
    onTimeout: () => timeoutExceptionFromDuration(duration3),
    duration: duration3
  }));
  var timeoutFail = /* @__PURE__ */ dual(2, (self, {
    duration: duration3,
    onTimeout
  }) => flatten4(timeoutTo(self, {
    onTimeout: () => failSync(onTimeout),
    onSuccess: succeed,
    duration: duration3
  })));
  var timeoutFailCause = /* @__PURE__ */ dual(2, (self, {
    duration: duration3,
    onTimeout
  }) => flatten4(timeoutTo(self, {
    onTimeout: () => failCauseSync(onTimeout),
    onSuccess: succeed,
    duration: duration3
  })));
  var timeoutOption = /* @__PURE__ */ dual(2, (self, duration3) => timeoutTo(self, {
    duration: duration3,
    onSuccess: some2,
    onTimeout: none2
  }));
  var timeoutTo = /* @__PURE__ */ dual(2, (self, {
    duration: duration3,
    onSuccess,
    onTimeout
  }) => fiberIdWith((parentFiberId) => uninterruptibleMask((restore) => raceFibersWith(restore(self), interruptible2(sleep3(duration3)), {
    onSelfWin: (winner, loser) => flatMap8(winner.await, (exit4) => {
      if (exit4._tag === "Success") {
        return flatMap8(winner.inheritAll, () => as(interruptAsFiber(loser, parentFiberId), onSuccess(exit4.value)));
      } else {
        return flatMap8(interruptAsFiber(loser, parentFiberId), () => exitFailCause(exit4.cause));
      }
    }),
    onOtherWin: (winner, loser) => flatMap8(winner.await, (exit4) => {
      if (exit4._tag === "Success") {
        return flatMap8(winner.inheritAll, () => as(interruptAsFiber(loser, parentFiberId), onTimeout()));
      } else {
        return flatMap8(interruptAsFiber(loser, parentFiberId), () => exitFailCause(exit4.cause));
      }
    }),
    otherScope: globalScope
  }))));
  var SynchronizedSymbolKey = "effect/Ref/SynchronizedRef";
  var SynchronizedTypeId = /* @__PURE__ */ Symbol.for(SynchronizedSymbolKey);
  var synchronizedVariance = {
    /* c8 ignore next */
    _A: (_) => _
  };
  var _a48, _b14, _c2, _d;
  var SynchronizedImpl = class extends (_d = Class2, _c2 = SynchronizedTypeId, _b14 = RefTypeId, _a48 = TypeId13, _d) {
    constructor(ref, withLock) {
      super();
      __publicField(this, "ref");
      __publicField(this, "withLock");
      __publicField(this, _c2, synchronizedVariance);
      __publicField(this, _b14, refVariance);
      __publicField(this, _a48, TypeId13);
      __publicField(this, "get");
      this.ref = ref;
      this.withLock = withLock;
      this.get = get11(this.ref);
    }
    commit() {
      return this.get;
    }
    modify(f) {
      return this.modifyEffect((a) => succeed(f(a)));
    }
    modifyEffect(f) {
      return this.withLock(pipe(flatMap8(get11(this.ref), f), flatMap8(([b, a]) => as(set5(this.ref, a), b))));
    }
  };
  var makeSynchronized = (value) => sync(() => unsafeMakeSynchronized(value));
  var unsafeMakeSynchronized = (value) => {
    const ref = unsafeMake5(value);
    const sem = unsafeMakeSemaphore(1);
    return new SynchronizedImpl(ref, sem.withPermits(1));
  };
  var updateSomeAndGetEffectSynchronized = /* @__PURE__ */ dual(2, (self, pf) => self.modifyEffect((value) => {
    const result = pf(value);
    switch (result._tag) {
      case "None": {
        return succeed([value, value]);
      }
      case "Some": {
        return map9(result.value, (a) => [a, a]);
      }
    }
  }));
  var bindAll = /* @__PURE__ */ dual((args2) => isEffect(args2[0]), (self, f, options) => flatMap8(self, (a) => all3(f(a), options).pipe(map9((record) => Object.assign({}, a, record)))));

  // <eztb>/node_modules/effect/dist/esm/internal/managedRuntime/circular.js
  var TypeId16 = /* @__PURE__ */ Symbol.for("effect/ManagedRuntime");

  // <eztb>/node_modules/effect/dist/esm/internal/opCodes/layer.js
  var OP_FRESH = "Fresh";
  var OP_FROM_EFFECT = "FromEffect";
  var OP_SCOPED = "Scoped";
  var OP_SUSPEND = "Suspend";
  var OP_PROVIDE = "Provide";
  var OP_PROVIDE_MERGE = "ProvideMerge";
  var OP_MERGE_ALL = "MergeAll";

  // <eztb>/node_modules/effect/dist/esm/Fiber.js
  var interruptAs = interruptAsFiber;

  // <eztb>/node_modules/effect/dist/esm/internal/runtime.js
  var makeDual = (f) => function() {
    if (arguments.length === 1) {
      const runtime4 = arguments[0];
      return (effect, ...args2) => f(runtime4, effect, ...args2);
    }
    return f.apply(this, arguments);
  };
  var unsafeFork3 = /* @__PURE__ */ makeDual((runtime4, self, options) => {
    const fiberId3 = unsafeMake2();
    const fiberRefUpdates = [[currentContext, [[fiberId3, runtime4.context]]]];
    if (options?.scheduler) {
      fiberRefUpdates.push([currentScheduler, [[fiberId3, options.scheduler]]]);
    }
    let fiberRefs3 = updateManyAs2(runtime4.fiberRefs, {
      entries: fiberRefUpdates,
      forkAs: fiberId3
    });
    if (options?.updateRefs) {
      fiberRefs3 = options.updateRefs(fiberRefs3, fiberId3);
    }
    const fiberRuntime = new FiberRuntime(fiberId3, fiberRefs3, runtime4.runtimeFlags);
    let effect = self;
    if (options?.scope) {
      effect = flatMap8(fork2(options.scope, sequential2), (closeableScope) => zipRight(scopeAddFinalizer(closeableScope, fiberIdWith((id) => equals(id, fiberRuntime.id()) ? void_2 : interruptAsFiber(fiberRuntime, id))), onExit(self, (exit4) => close(closeableScope, exit4))));
    }
    const supervisor = fiberRuntime.currentSupervisor;
    if (supervisor !== none8) {
      supervisor.onStart(runtime4.context, effect, none2(), fiberRuntime);
      fiberRuntime.addObserver((exit4) => supervisor.onEnd(exit4, fiberRuntime));
    }
    globalScope.add(runtime4.runtimeFlags, fiberRuntime);
    if (options?.immediate === false) {
      fiberRuntime.resume(effect);
    } else {
      fiberRuntime.start(effect);
    }
    return fiberRuntime;
  });
  var unsafeRunCallback = /* @__PURE__ */ makeDual((runtime4, effect, options = {}) => {
    const fiberRuntime = unsafeFork3(runtime4, effect, options);
    if (options.onExit) {
      fiberRuntime.addObserver((exit4) => {
        options.onExit(exit4);
      });
    }
    return (id, cancelOptions) => unsafeRunCallback(runtime4)(pipe(fiberRuntime, interruptAs(id ?? none4)), {
      ...cancelOptions,
      onExit: cancelOptions?.onExit ? (exit4) => cancelOptions.onExit(flatten5(exit4)) : void 0
    });
  });
  var unsafeRunSync = /* @__PURE__ */ makeDual((runtime4, effect) => {
    const result = unsafeRunSyncExit(runtime4)(effect);
    if (result._tag === "Failure") {
      throw fiberFailure(result.effect_instruction_i0);
    }
    return result.effect_instruction_i0;
  });
  var AsyncFiberExceptionImpl = class extends Error {
    constructor(fiber) {
      super(`Fiber #${fiber.id().id} cannot be resolved synchronously. This is caused by using runSync on an effect that performs async work`);
      __publicField(this, "fiber");
      __publicField(this, "_tag", "AsyncFiberException");
      this.fiber = fiber;
      this.name = this._tag;
      this.stack = this.message;
    }
  };
  var asyncFiberException = (fiber) => {
    const limit = Error.stackTraceLimit;
    Error.stackTraceLimit = 0;
    const error = new AsyncFiberExceptionImpl(fiber);
    Error.stackTraceLimit = limit;
    return error;
  };
  var FiberFailureId = /* @__PURE__ */ Symbol.for("effect/Runtime/FiberFailure");
  var FiberFailureCauseId = /* @__PURE__ */ Symbol.for("effect/Runtime/FiberFailure/Cause");
  var _a49, _b15;
  var FiberFailureImpl = class extends Error {
    constructor(cause3) {
      const head5 = prettyErrors(cause3)[0];
      super(head5?.message || "An error has occurred");
      __publicField(this, _b15);
      __publicField(this, _a49);
      this[FiberFailureId] = FiberFailureId;
      this[FiberFailureCauseId] = cause3;
      this.name = head5 ? `(FiberFailure) ${head5.name}` : "FiberFailure";
      if (head5?.stack) {
        this.stack = head5.stack;
      }
    }
    toJSON() {
      return {
        _id: "FiberFailure",
        cause: this[FiberFailureCauseId].toJSON()
      };
    }
    toString() {
      return "(FiberFailure) " + pretty(this[FiberFailureCauseId], {
        renderErrorCause: true
      });
    }
    [(_b15 = FiberFailureId, _a49 = FiberFailureCauseId, NodeInspectSymbol)]() {
      return this.toString();
    }
  };
  var fiberFailure = (cause3) => {
    const limit = Error.stackTraceLimit;
    Error.stackTraceLimit = 0;
    const error = new FiberFailureImpl(cause3);
    Error.stackTraceLimit = limit;
    return error;
  };
  var fastPath = (effect) => {
    const op = effect;
    switch (op._op) {
      case "Failure":
      case "Success": {
        return op;
      }
      case "Left": {
        return exitFail(op.left);
      }
      case "Right": {
        return exitSucceed(op.right);
      }
      case "Some": {
        return exitSucceed(op.value);
      }
      case "None": {
        return exitFail(new NoSuchElementException());
      }
    }
  };
  var unsafeRunSyncExit = /* @__PURE__ */ makeDual((runtime4, effect) => {
    const op = fastPath(effect);
    if (op) {
      return op;
    }
    const scheduler = new SyncScheduler();
    const fiberRuntime = unsafeFork3(runtime4)(effect, {
      scheduler
    });
    scheduler.flush();
    const result = fiberRuntime.unsafePoll();
    if (result) {
      return result;
    }
    return exitDie(capture(asyncFiberException(fiberRuntime), currentSpanFromFiber(fiberRuntime)));
  });
  var unsafeRunPromise = /* @__PURE__ */ makeDual((runtime4, effect, options) => unsafeRunPromiseExit(runtime4, effect, options).then((result) => {
    switch (result._tag) {
      case OP_SUCCESS: {
        return result.effect_instruction_i0;
      }
      case OP_FAILURE: {
        throw fiberFailure(result.effect_instruction_i0);
      }
    }
  }));
  var unsafeRunPromiseExit = /* @__PURE__ */ makeDual((runtime4, effect, options) => new Promise((resolve) => {
    const op = fastPath(effect);
    if (op) {
      resolve(op);
    }
    const fiber = unsafeFork3(runtime4)(effect);
    fiber.addObserver((exit4) => {
      resolve(exit4);
    });
    if (options?.signal !== void 0) {
      if (options.signal.aborted) {
        fiber.unsafeInterruptAsFork(fiber.id());
      } else {
        options.signal.addEventListener("abort", () => {
          fiber.unsafeInterruptAsFork(fiber.id());
        }, {
          once: true
        });
      }
    }
  }));
  var RuntimeImpl = class {
    constructor(context4, runtimeFlags2, fiberRefs3) {
      __publicField(this, "context");
      __publicField(this, "runtimeFlags");
      __publicField(this, "fiberRefs");
      this.context = context4;
      this.runtimeFlags = runtimeFlags2;
      this.fiberRefs = fiberRefs3;
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var make40 = (options) => new RuntimeImpl(options.context, options.runtimeFlags, options.fiberRefs);
  var runtime2 = () => withFiberRuntime((state, status) => succeed(new RuntimeImpl(state.getFiberRef(currentContext), status.runtimeFlags, state.getFiberRefs())));
  var defaultRuntimeFlags = /* @__PURE__ */ make16(Interruption, CooperativeYielding, RuntimeMetrics);
  var defaultRuntime = /* @__PURE__ */ make40({
    context: /* @__PURE__ */ empty3(),
    runtimeFlags: defaultRuntimeFlags,
    fiberRefs: /* @__PURE__ */ empty21()
  });
  var unsafeRunEffect = /* @__PURE__ */ unsafeRunCallback(defaultRuntime);
  var unsafeForkEffect = /* @__PURE__ */ unsafeFork3(defaultRuntime);
  var unsafeRunPromiseEffect = /* @__PURE__ */ unsafeRunPromise(defaultRuntime);
  var unsafeRunPromiseExitEffect = /* @__PURE__ */ unsafeRunPromiseExit(defaultRuntime);
  var unsafeRunSyncEffect = /* @__PURE__ */ unsafeRunSync(defaultRuntime);
  var unsafeRunSyncExitEffect = /* @__PURE__ */ unsafeRunSyncExit(defaultRuntime);
  var asyncEffect = (register) => suspend(() => {
    let cleanup = void 0;
    return flatMap8(deferredMake(), (deferred) => flatMap8(runtime2(), (runtime4) => uninterruptibleMask((restore) => zipRight(fork(restore(matchCauseEffect(register((cb) => unsafeRunCallback(runtime4)(intoDeferred(cb, deferred))), {
      onFailure: (cause3) => deferredFailCause(deferred, cause3),
      onSuccess: (cleanup_) => {
        cleanup = cleanup_;
        return void_2;
      }
    }))), restore(onInterrupt(deferredAwait(deferred), () => cleanup ?? void_2))))));
  });

  // <eztb>/node_modules/effect/dist/esm/internal/synchronizedRef.js
  var modifyEffect = /* @__PURE__ */ dual(2, (self, f) => self.modifyEffect(f));

  // <eztb>/node_modules/effect/dist/esm/internal/layer.js
  var LayerSymbolKey = "effect/Layer";
  var LayerTypeId = /* @__PURE__ */ Symbol.for(LayerSymbolKey);
  var layerVariance = {
    /* c8 ignore next */
    _RIn: (_) => _,
    /* c8 ignore next */
    _E: (_) => _,
    /* c8 ignore next */
    _ROut: (_) => _
  };
  var proto3 = {
    [LayerTypeId]: layerVariance,
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var MemoMapTypeIdKey = "effect/Layer/MemoMap";
  var MemoMapTypeId = /* @__PURE__ */ Symbol.for(MemoMapTypeIdKey);
  var CurrentMemoMap = /* @__PURE__ */ Reference2()("effect/Layer/CurrentMemoMap", {
    defaultValue: () => unsafeMakeMemoMap()
  });
  var isLayer = (u) => hasProperty(u, LayerTypeId);
  var isFresh = (self) => {
    return self._op_layer === OP_FRESH;
  };
  var _a50;
  _a50 = MemoMapTypeId;
  var MemoMapImpl = class {
    constructor(ref) {
      __publicField(this, "ref");
      __publicField(this, _a50);
      this.ref = ref;
      this[MemoMapTypeId] = MemoMapTypeId;
    }
    /**
     * Checks the memo map to see if a layer exists. If it is, immediately
     * returns it. Otherwise, obtains the layer, stores it in the memo map,
     * and adds a finalizer to the `Scope`.
     */
    getOrElseMemoize(layer, scope3) {
      return pipe(modifyEffect(this.ref, (map14) => {
        const inMap = map14.get(layer);
        if (inMap !== void 0) {
          const [acquire, release] = inMap;
          const cached4 = pipe(acquire, flatMap8(([patch9, b]) => pipe(patchFiberRefs(patch9), as(b))), onExit(exitMatch({
            onFailure: () => void_2,
            onSuccess: () => scopeAddFinalizerExit(scope3, release)
          })));
          return succeed([cached4, map14]);
        }
        return pipe(make26(0), flatMap8((observers) => pipe(deferredMake(), flatMap8((deferred) => pipe(make26(() => void_2), map9((finalizerRef) => {
          const resource = uninterruptibleMask((restore) => pipe(scopeMake(), flatMap8((innerScope) => pipe(restore(flatMap8(makeBuilder(layer, innerScope, true), (f) => diffFiberRefs(f(this)))), exit, flatMap8((exit4) => {
            switch (exit4._tag) {
              case OP_FAILURE: {
                return pipe(deferredFailCause(deferred, exit4.effect_instruction_i0), zipRight(scopeClose(innerScope, exit4)), zipRight(failCause(exit4.effect_instruction_i0)));
              }
              case OP_SUCCESS: {
                return pipe(set5(finalizerRef, (exit5) => pipe(scopeClose(innerScope, exit5), whenEffect(modify3(observers, (n) => [n === 1, n - 1])), asVoid)), zipRight(update2(observers, (n) => n + 1)), zipRight(scopeAddFinalizerExit(scope3, (exit5) => pipe(sync(() => map14.delete(layer)), zipRight(get11(finalizerRef)), flatMap8((finalizer) => finalizer(exit5))))), zipRight(deferredSucceed(deferred, exit4.effect_instruction_i0)), as(exit4.effect_instruction_i0[1]));
              }
            }
          })))));
          const memoized = [pipe(deferredAwait(deferred), onExit(exitMatchEffect({
            onFailure: () => void_2,
            onSuccess: () => update2(observers, (n) => n + 1)
          }))), (exit4) => pipe(get11(finalizerRef), flatMap8((finalizer) => finalizer(exit4)))];
          return [resource, isFresh(layer) ? map14 : map14.set(layer, memoized)];
        }))))));
      }), flatten4);
    }
  };
  var makeMemoMap = /* @__PURE__ */ suspend(() => map9(makeSynchronized(/* @__PURE__ */ new Map()), (ref) => new MemoMapImpl(ref)));
  var unsafeMakeMemoMap = () => new MemoMapImpl(unsafeMakeSynchronized(/* @__PURE__ */ new Map()));
  var buildWithScope = /* @__PURE__ */ dual(2, (self, scope3) => flatMap8(makeMemoMap, (memoMap) => buildWithMemoMap(self, memoMap, scope3)));
  var buildWithMemoMap = /* @__PURE__ */ dual(3, (self, memoMap, scope3) => flatMap8(makeBuilder(self, scope3), (run3) => provideService(run3(memoMap), CurrentMemoMap, memoMap)));
  var makeBuilder = (self, scope3, inMemoMap = false) => {
    const op = self;
    switch (op._op_layer) {
      case "Locally": {
        return sync(() => (memoMap) => op.f(memoMap.getOrElseMemoize(op.self, scope3)));
      }
      case "ExtendScope": {
        return sync(() => (memoMap) => scopeWith((scope4) => memoMap.getOrElseMemoize(op.layer, scope4)));
      }
      case "Fold": {
        return sync(() => (memoMap) => pipe(memoMap.getOrElseMemoize(op.layer, scope3), matchCauseEffect({
          onFailure: (cause3) => memoMap.getOrElseMemoize(op.failureK(cause3), scope3),
          onSuccess: (value) => memoMap.getOrElseMemoize(op.successK(value), scope3)
        })));
      }
      case "Fresh": {
        return sync(() => (_) => pipe(op.layer, buildWithScope(scope3)));
      }
      case "FromEffect": {
        return inMemoMap ? sync(() => (_) => op.effect) : sync(() => (memoMap) => memoMap.getOrElseMemoize(self, scope3));
      }
      case "Provide": {
        return sync(() => (memoMap) => pipe(memoMap.getOrElseMemoize(op.first, scope3), flatMap8((env) => pipe(memoMap.getOrElseMemoize(op.second, scope3), provideContext(env)))));
      }
      case "Scoped": {
        return inMemoMap ? sync(() => (_) => scopeExtend(op.effect, scope3)) : sync(() => (memoMap) => memoMap.getOrElseMemoize(self, scope3));
      }
      case "Suspend": {
        return sync(() => (memoMap) => memoMap.getOrElseMemoize(op.evaluate(), scope3));
      }
      case "ProvideMerge": {
        return sync(() => (memoMap) => pipe(memoMap.getOrElseMemoize(op.first, scope3), zipWith3(memoMap.getOrElseMemoize(op.second, scope3), op.zipK)));
      }
      case "ZipWith": {
        return gen2(function* () {
          const parallelScope = yield* scopeFork(scope3, parallel2);
          const firstScope = yield* scopeFork(parallelScope, sequential2);
          const secondScope = yield* scopeFork(parallelScope, sequential2);
          return (memoMap) => pipe(memoMap.getOrElseMemoize(op.first, firstScope), zipWithOptions(memoMap.getOrElseMemoize(op.second, secondScope), op.zipK, {
            concurrent: true
          }));
        });
      }
      case "MergeAll": {
        const layers = op.layers;
        return map9(scopeFork(scope3, parallel2), (parallelScope) => (memoMap) => {
          const contexts = new Array(layers.length);
          return map9(forEachConcurrentDiscard(layers, fnUntraced(function* (layer, i) {
            const scope4 = yield* scopeFork(parallelScope, sequential2);
            const context4 = yield* memoMap.getOrElseMemoize(layer, scope4);
            contexts[i] = context4;
          }), false, false), () => mergeAll2(...contexts));
        });
      }
    }
  };
  var context2 = () => fromEffectContext(context());
  var fromEffect2 = /* @__PURE__ */ dual(2, (a, b) => {
    const tagFirst = isTag2(a);
    const tag = tagFirst ? a : b;
    const effect = tagFirst ? b : a;
    return fromEffectContext(map9(effect, (service) => make5(tag, service)));
  });
  function fromEffectContext(effect) {
    const fromEffect3 = Object.create(proto3);
    fromEffect3._op_layer = OP_FROM_EFFECT;
    fromEffect3.effect = effect;
    return fromEffect3;
  }
  var mergeAll4 = (...layers) => {
    const mergeAll6 = Object.create(proto3);
    mergeAll6._op_layer = OP_MERGE_ALL;
    mergeAll6.layers = layers;
    return mergeAll6;
  };
  var scoped = /* @__PURE__ */ dual(2, (a, b) => {
    const tagFirst = isTag2(a);
    const tag = tagFirst ? a : b;
    const effect = tagFirst ? b : a;
    return scopedContext(map9(effect, (service) => make5(tag, service)));
  });
  var scopedContext = (effect) => {
    const scoped3 = Object.create(proto3);
    scoped3._op_layer = OP_SCOPED;
    scoped3.effect = effect;
    return scoped3;
  };
  var succeed4 = /* @__PURE__ */ dual(2, (a, b) => {
    const tagFirst = isTag2(a);
    const tag = tagFirst ? a : b;
    const resource = tagFirst ? b : a;
    return fromEffectContext(succeed(make5(tag, resource)));
  });
  var suspend3 = (evaluate2) => {
    const suspend5 = Object.create(proto3);
    suspend5._op_layer = OP_SUSPEND;
    suspend5.evaluate = evaluate2;
    return suspend5;
  };
  var sync3 = /* @__PURE__ */ dual(2, (a, b) => {
    const tagFirst = isTag2(a);
    const tag = tagFirst ? a : b;
    const evaluate2 = tagFirst ? b : a;
    return fromEffectContext(sync(() => make5(tag, evaluate2())));
  });
  var provide = /* @__PURE__ */ dual(2, (self, that) => suspend3(() => {
    const provideTo = Object.create(proto3);
    provideTo._op_layer = OP_PROVIDE;
    provideTo.first = Object.create(proto3, {
      _op_layer: {
        value: OP_PROVIDE_MERGE,
        enumerable: true
      },
      first: {
        value: context2(),
        enumerable: true
      },
      second: {
        value: Array.isArray(that) ? mergeAll4(...that) : that
      },
      zipK: {
        value: (a, b) => pipe(a, merge3(b))
      }
    });
    provideTo.second = self;
    return provideTo;
  }));
  var provideSomeLayer = /* @__PURE__ */ dual(2, (self, layer) => scopedWith((scope3) => flatMap8(buildWithScope(layer, scope3), (context4) => provideSomeContext(self, context4))));
  var provideSomeRuntime = /* @__PURE__ */ dual(2, (self, rt) => {
    const patchRefs = diff6(defaultRuntime.fiberRefs, rt.fiberRefs);
    const patchFlags = diff4(defaultRuntime.runtimeFlags, rt.runtimeFlags);
    return uninterruptibleMask((restore) => withFiberRuntime((fiber) => {
      const oldContext = fiber.getFiberRef(currentContext);
      const oldRefs = fiber.getFiberRefs();
      const newRefs = patch7(fiber.id(), oldRefs)(patchRefs);
      const oldFlags = fiber.currentRuntimeFlags;
      const newFlags = patch4(patchFlags)(oldFlags);
      const rollbackRefs = diff6(newRefs, oldRefs);
      const rollbackFlags = diff4(newFlags, oldFlags);
      fiber.setFiberRefs(newRefs);
      fiber.currentRuntimeFlags = newFlags;
      return ensuring(provideSomeContext(restore(self), merge3(oldContext, rt.context)), withFiberRuntime((fiber2) => {
        fiber2.setFiberRefs(patch7(fiber2.id(), fiber2.getFiberRefs())(rollbackRefs));
        fiber2.currentRuntimeFlags = patch4(rollbackFlags)(fiber2.currentRuntimeFlags);
        return void_2;
      }));
    }));
  });
  var effect_provide = /* @__PURE__ */ dual(2, (self, source) => {
    if (Array.isArray(source)) {
      return provideSomeLayer(self, mergeAll4(...source));
    } else if (isLayer(source)) {
      return provideSomeLayer(self, source);
    } else if (isContext2(source)) {
      return provideSomeContext(self, source);
    } else if (TypeId16 in source) {
      return flatMap8(source.runtimeEffect, (rt) => provideSomeRuntime(self, rt));
    } else {
      return provideSomeRuntime(self, source);
    }
  });

  // <eztb>/node_modules/effect/dist/esm/internal/console.js
  var console2 = /* @__PURE__ */ map9(/* @__PURE__ */ fiberRefGet(currentServices), /* @__PURE__ */ get3(consoleTag));
  var consoleWith = (f) => fiberRefGetWith(currentServices, (services) => f(get3(services, consoleTag)));
  var withConsole = /* @__PURE__ */ dual(2, (effect, value) => fiberRefLocallyWith(effect, currentServices, add2(consoleTag, value)));
  var withConsoleScoped = (console4) => fiberRefLocallyScopedWith(currentServices, add2(consoleTag, console4));

  // <eztb>/node_modules/effect/dist/esm/Data.js
  var Error3 = /* @__PURE__ */ (function() {
    const plainArgsSymbol = /* @__PURE__ */ Symbol.for("effect/Data/Error/plainArgs");
    const O = {
      BaseEffectError: class extends YieldableError {
        constructor(args2) {
          super(args2?.message, args2?.cause ? {
            cause: args2.cause
          } : void 0);
          if (args2) {
            Object.assign(this, args2);
            Object.defineProperty(this, plainArgsSymbol, {
              value: args2,
              enumerable: false
            });
          }
        }
        toJSON() {
          return {
            ...this[plainArgsSymbol],
            ...this
          };
        }
      }
    };
    return O.BaseEffectError;
  })();
  var TaggedError = (tag) => {
    const O = {
      BaseEffectError: class extends Error3 {
        constructor() {
          super(...arguments);
          __publicField(this, "_tag", tag);
        }
      }
    };
    O.BaseEffectError.prototype.name = tag;
    return O.BaseEffectError;
  };

  // <eztb>/node_modules/effect/dist/esm/internal/dateTime.js
  var TypeId17 = /* @__PURE__ */ Symbol.for("effect/DateTime");
  var TimeZoneTypeId = /* @__PURE__ */ Symbol.for("effect/DateTime/TimeZone");
  var Proto2 = {
    [TypeId17]: TypeId17,
    pipe() {
      return pipeArguments(this, arguments);
    },
    [NodeInspectSymbol]() {
      return this.toString();
    },
    toJSON() {
      return toDateUtc(this).toJSON();
    }
  };
  var ProtoUtc = {
    ...Proto2,
    _tag: "Utc",
    [symbol]() {
      return cached(this, number2(this.epochMillis));
    },
    [symbol2](that) {
      return isDateTime(that) && that._tag === "Utc" && this.epochMillis === that.epochMillis;
    },
    toString() {
      return `DateTime.Utc(${toDateUtc(this).toJSON()})`;
    }
  };
  var ProtoZoned = {
    ...Proto2,
    _tag: "Zoned",
    [symbol]() {
      return pipe(number2(this.epochMillis), combine(hash(this.zone)), cached(this));
    },
    [symbol2](that) {
      return isDateTime(that) && that._tag === "Zoned" && this.epochMillis === that.epochMillis && equals(this.zone, that.zone);
    },
    toString() {
      return `DateTime.Zoned(${formatIsoZoned(this)})`;
    }
  };
  var ProtoTimeZone = {
    [TimeZoneTypeId]: TimeZoneTypeId,
    [NodeInspectSymbol]() {
      return this.toString();
    }
  };
  var ProtoTimeZoneNamed = {
    ...ProtoTimeZone,
    _tag: "Named",
    [symbol]() {
      return cached(this, string(`Named:${this.id}`));
    },
    [symbol2](that) {
      return isTimeZone(that) && that._tag === "Named" && this.id === that.id;
    },
    toString() {
      return `TimeZone.Named(${this.id})`;
    },
    toJSON() {
      return {
        _id: "TimeZone",
        _tag: "Named",
        id: this.id
      };
    }
  };
  var ProtoTimeZoneOffset = {
    ...ProtoTimeZone,
    _tag: "Offset",
    [symbol]() {
      return cached(this, string(`Offset:${this.offset}`));
    },
    [symbol2](that) {
      return isTimeZone(that) && that._tag === "Offset" && this.offset === that.offset;
    },
    toString() {
      return `TimeZone.Offset(${offsetToString(this.offset)})`;
    },
    toJSON() {
      return {
        _id: "TimeZone",
        _tag: "Offset",
        offset: this.offset
      };
    }
  };
  var makeZonedProto = (epochMillis, zone, partsUtc) => {
    const self = Object.create(ProtoZoned);
    self.epochMillis = epochMillis;
    self.zone = zone;
    Object.defineProperty(self, "partsUtc", {
      value: partsUtc,
      enumerable: false,
      writable: true
    });
    Object.defineProperty(self, "adjustedEpochMillis", {
      value: void 0,
      enumerable: false,
      writable: true
    });
    Object.defineProperty(self, "partsAdjusted", {
      value: void 0,
      enumerable: false,
      writable: true
    });
    return self;
  };
  var isDateTime = (u) => hasProperty(u, TypeId17);
  var isDateTimeArgs = (args2) => isDateTime(args2[0]);
  var isTimeZone = (u) => hasProperty(u, TimeZoneTypeId);
  var isTimeZoneNamed = (u) => isTimeZone(u) && u._tag === "Named";
  var isZoned = (self) => self._tag === "Zoned";
  var makeUtc = (epochMillis) => {
    const self = Object.create(ProtoUtc);
    self.epochMillis = epochMillis;
    Object.defineProperty(self, "partsUtc", {
      value: void 0,
      enumerable: false,
      writable: true
    });
    return self;
  };
  var unsafeFromDate = (date) => {
    const epochMillis = date.getTime();
    if (Number.isNaN(epochMillis)) {
      throw new IllegalArgumentException2("Invalid date");
    }
    return makeUtc(epochMillis);
  };
  var unsafeMake8 = (input) => {
    if (isDateTime(input)) {
      return input;
    } else if (input instanceof Date) {
      return unsafeFromDate(input);
    } else if (typeof input === "object") {
      const date = /* @__PURE__ */ new Date(0);
      setPartsDate(date, input);
      return unsafeFromDate(date);
    } else if (typeof input === "string" && !hasZone(input)) {
      return unsafeFromDate(/* @__PURE__ */ new Date(input + "Z"));
    }
    return unsafeFromDate(new Date(input));
  };
  var hasZone = (input) => /Z|[+-]\d{2}$|[+-]\d{2}:?\d{2}$|\]$/.test(input);
  var minEpochMillis = -864e13 + 12 * 60 * 60 * 1e3;
  var maxEpochMillis = 864e13 - 14 * 60 * 60 * 1e3;
  var unsafeMakeZoned = (input, options) => {
    if (options?.timeZone === void 0 && isDateTime(input) && isZoned(input)) {
      return input;
    }
    const self = unsafeMake8(input);
    if (self.epochMillis < minEpochMillis || self.epochMillis > maxEpochMillis) {
      throw new RangeError(`Epoch millis out of range: ${self.epochMillis}`);
    }
    let zone;
    if (options?.timeZone === void 0) {
      const offset = new Date(self.epochMillis).getTimezoneOffset() * -60 * 1e3;
      zone = zoneMakeOffset(offset);
    } else if (isTimeZone(options?.timeZone)) {
      zone = options.timeZone;
    } else if (typeof options?.timeZone === "number") {
      zone = zoneMakeOffset(options.timeZone);
    } else {
      const parsedZone = zoneFromString(options.timeZone);
      if (isNone2(parsedZone)) {
        throw new IllegalArgumentException2(`Invalid time zone: ${options.timeZone}`);
      }
      zone = parsedZone.value;
    }
    if (options?.adjustForTimeZone !== true) {
      return makeZonedProto(self.epochMillis, zone, self.partsUtc);
    }
    return makeZonedFromAdjusted(self.epochMillis, zone, options?.disambiguation ?? "compatible");
  };
  var validZoneCache = /* @__PURE__ */ globalValue("effect/DateTime/validZoneCache", () => /* @__PURE__ */ new Map());
  var formatOptions = {
    day: "numeric",
    month: "numeric",
    year: "numeric",
    hour: "numeric",
    minute: "numeric",
    second: "numeric",
    timeZoneName: "longOffset",
    fractionalSecondDigits: 3,
    hourCycle: "h23"
  };
  var zoneMakeIntl = (format5) => {
    const zoneId = format5.resolvedOptions().timeZone;
    if (validZoneCache.has(zoneId)) {
      return validZoneCache.get(zoneId);
    }
    const zone = Object.create(ProtoTimeZoneNamed);
    zone.id = zoneId;
    zone.format = format5;
    validZoneCache.set(zoneId, zone);
    return zone;
  };
  var zoneUnsafeMakeNamed = (zoneId) => {
    if (validZoneCache.has(zoneId)) {
      return validZoneCache.get(zoneId);
    }
    try {
      return zoneMakeIntl(new Intl.DateTimeFormat("en-US", {
        ...formatOptions,
        timeZone: zoneId
      }));
    } catch {
      throw new IllegalArgumentException2(`Invalid time zone: ${zoneId}`);
    }
  };
  var zoneMakeOffset = (offset) => {
    const zone = Object.create(ProtoTimeZoneOffset);
    zone.offset = offset;
    return zone;
  };
  var zoneMakeNamed = /* @__PURE__ */ liftThrowable(zoneUnsafeMakeNamed);
  var offsetZoneRegex = /^(?:GMT|[+-])/;
  var zoneFromString = (zone) => {
    if (offsetZoneRegex.test(zone)) {
      const offset = parseOffset(zone);
      return offset === null ? none2() : some2(zoneMakeOffset(offset));
    }
    return zoneMakeNamed(zone);
  };
  var toDateUtc = (self) => new Date(self.epochMillis);
  var toDate = (self) => {
    if (self._tag === "Utc") {
      return new Date(self.epochMillis);
    } else if (self.zone._tag === "Offset") {
      return new Date(self.epochMillis + self.zone.offset);
    } else if (self.adjustedEpochMillis !== void 0) {
      return new Date(self.adjustedEpochMillis);
    }
    const parts2 = self.zone.format.formatToParts(self.epochMillis).filter((_) => _.type !== "literal");
    const date = /* @__PURE__ */ new Date(0);
    date.setUTCFullYear(Number(parts2[2].value), Number(parts2[0].value) - 1, Number(parts2[1].value));
    date.setUTCHours(Number(parts2[3].value), Number(parts2[4].value), Number(parts2[5].value), Number(parts2[6].value));
    self.adjustedEpochMillis = date.getTime();
    return date;
  };
  var zonedOffset = (self) => {
    const date = toDate(self);
    return date.getTime() - toEpochMillis(self);
  };
  var offsetToString = (offset) => {
    const abs = Math.abs(offset);
    let hours2 = Math.floor(abs / (60 * 60 * 1e3));
    let minutes2 = Math.round(abs % (60 * 60 * 1e3) / (60 * 1e3));
    if (minutes2 === 60) {
      hours2 += 1;
      minutes2 = 0;
    }
    return `${offset < 0 ? "-" : "+"}${String(hours2).padStart(2, "0")}:${String(minutes2).padStart(2, "0")}`;
  };
  var zonedOffsetIso = (self) => offsetToString(zonedOffset(self));
  var toEpochMillis = (self) => self.epochMillis;
  var dateToParts = (date) => ({
    millis: date.getUTCMilliseconds(),
    seconds: date.getUTCSeconds(),
    minutes: date.getUTCMinutes(),
    hours: date.getUTCHours(),
    day: date.getUTCDate(),
    weekDay: date.getUTCDay(),
    month: date.getUTCMonth() + 1,
    year: date.getUTCFullYear()
  });
  var toParts = (self) => {
    if (self._tag === "Utc") {
      return toPartsUtc(self);
    } else if (self.partsAdjusted !== void 0) {
      return self.partsAdjusted;
    }
    self.partsAdjusted = withDate(self, dateToParts);
    return self.partsAdjusted;
  };
  var toPartsUtc = (self) => {
    if (self.partsUtc !== void 0) {
      return self.partsUtc;
    }
    self.partsUtc = withDateUtc(self, dateToParts);
    return self.partsUtc;
  };
  var setPartsDate = (date, parts2) => {
    if (parts2.year !== void 0) {
      date.setUTCFullYear(parts2.year);
    }
    if (parts2.month !== void 0) {
      date.setUTCMonth(parts2.month - 1);
    }
    if (parts2.day !== void 0) {
      date.setUTCDate(parts2.day);
    }
    if (parts2.weekDay !== void 0) {
      const diff8 = parts2.weekDay - date.getUTCDay();
      date.setUTCDate(date.getUTCDate() + diff8);
    }
    if (parts2.hours !== void 0) {
      date.setUTCHours(parts2.hours);
    }
    if (parts2.minutes !== void 0) {
      date.setUTCMinutes(parts2.minutes);
    }
    if (parts2.seconds !== void 0) {
      date.setUTCSeconds(parts2.seconds);
    }
    if (parts2.millis !== void 0) {
      date.setUTCMilliseconds(parts2.millis);
    }
  };
  var constDayMillis = 24 * 60 * 60 * 1e3;
  var makeZonedFromAdjusted = (adjustedMillis, zone, disambiguation) => {
    if (zone._tag === "Offset") {
      return makeZonedProto(adjustedMillis - zone.offset, zone);
    }
    const beforeOffset = calculateNamedOffset(adjustedMillis - constDayMillis, adjustedMillis, zone);
    const afterOffset = calculateNamedOffset(adjustedMillis + constDayMillis, adjustedMillis, zone);
    if (beforeOffset === afterOffset) {
      return makeZonedProto(adjustedMillis - beforeOffset, zone);
    }
    const isForwards = beforeOffset < afterOffset;
    const transitionMillis = beforeOffset - afterOffset;
    if (isForwards) {
      const currentAfterOffset = calculateNamedOffset(adjustedMillis - afterOffset, adjustedMillis, zone);
      if (currentAfterOffset === afterOffset) {
        return makeZonedProto(adjustedMillis - afterOffset, zone);
      }
      const before2 = makeZonedProto(adjustedMillis - beforeOffset, zone);
      const beforeAdjustedMillis = toDate(before2).getTime();
      if (adjustedMillis !== beforeAdjustedMillis) {
        switch (disambiguation) {
          case "reject": {
            const formatted = new Date(adjustedMillis).toISOString();
            throw new RangeError(`Gap time: ${formatted} does not exist in time zone ${zone.id}`);
          }
          case "earlier":
            return makeZonedProto(adjustedMillis - afterOffset, zone);
          case "compatible":
          case "later":
            return before2;
        }
      }
      return before2;
    }
    const currentBeforeOffset = calculateNamedOffset(adjustedMillis - beforeOffset, adjustedMillis, zone);
    if (currentBeforeOffset === beforeOffset) {
      if (disambiguation === "earlier" || disambiguation === "compatible") {
        return makeZonedProto(adjustedMillis - beforeOffset, zone);
      }
      const laterOffset = calculateNamedOffset(adjustedMillis - beforeOffset + transitionMillis, adjustedMillis + transitionMillis, zone);
      if (laterOffset === beforeOffset) {
        return makeZonedProto(adjustedMillis - beforeOffset, zone);
      }
      if (disambiguation === "reject") {
        const formatted = new Date(adjustedMillis).toISOString();
        throw new RangeError(`Ambiguous time: ${formatted} occurs twice in time zone ${zone.id}`);
      }
    }
    return makeZonedProto(adjustedMillis - afterOffset, zone);
  };
  var offsetRegex = /([+-])(\d{2}):(\d{2})$/;
  var parseOffset = (offset) => {
    const match11 = offsetRegex.exec(offset);
    if (match11 === null) {
      return null;
    }
    const [, sign, hours2, minutes2] = match11;
    return (sign === "+" ? 1 : -1) * (Number(hours2) * 60 + Number(minutes2)) * 60 * 1e3;
  };
  var calculateNamedOffset = (utcMillis, adjustedMillis, zone) => {
    const offset = zone.format.formatToParts(utcMillis).find((_) => _.type === "timeZoneName")?.value ?? "";
    if (offset === "GMT") {
      return 0;
    }
    const result = parseOffset(offset);
    if (result === null) {
      return zonedOffset(makeZonedProto(adjustedMillis, zone));
    }
    return result;
  };
  var mutate4 = /* @__PURE__ */ dual(isDateTimeArgs, (self, f, options) => {
    if (self._tag === "Utc") {
      const date = toDateUtc(self);
      f(date);
      return makeUtc(date.getTime());
    }
    const adjustedDate = toDate(self);
    const newAdjustedDate = new Date(adjustedDate.getTime());
    f(newAdjustedDate);
    return makeZonedFromAdjusted(newAdjustedDate.getTime(), self.zone, options?.disambiguation ?? "compatible");
  });
  var withDate = /* @__PURE__ */ dual(2, (self, f) => f(toDate(self)));
  var withDateUtc = /* @__PURE__ */ dual(2, (self, f) => f(toDateUtc(self)));
  var formatIsoOffset = (self) => {
    const date = toDate(self);
    return self._tag === "Utc" ? date.toISOString() : `${date.toISOString().slice(0, -1)}${zonedOffsetIso(self)}`;
  };
  var formatIsoZoned = (self) => self.zone._tag === "Offset" ? formatIsoOffset(self) : `${formatIsoOffset(self)}[${self.zone.id}]`;

  // <eztb>/node_modules/effect/dist/esm/String.js
  var isNonEmpty5 = (self) => self.length > 0;

  // <eztb>/node_modules/effect/dist/esm/Cron.js
  var TypeId18 = /* @__PURE__ */ Symbol.for("effect/Cron");
  var CronProto = {
    [TypeId18]: TypeId18,
    [symbol2](that) {
      return isCron(that) && equals3(this, that);
    },
    [symbol]() {
      return pipe(hash(this.tz), combine(array2(fromIterable(this.seconds))), combine(array2(fromIterable(this.minutes))), combine(array2(fromIterable(this.hours))), combine(array2(fromIterable(this.days))), combine(array2(fromIterable(this.months))), combine(array2(fromIterable(this.weekdays))), cached(this));
    },
    toString() {
      return format2(this.toJSON());
    },
    toJSON() {
      return {
        _id: "Cron",
        tz: this.tz,
        seconds: fromIterable(this.seconds),
        minutes: fromIterable(this.minutes),
        hours: fromIterable(this.hours),
        days: fromIterable(this.days),
        months: fromIterable(this.months),
        weekdays: fromIterable(this.weekdays)
      };
    },
    [NodeInspectSymbol]() {
      return this.toJSON();
    },
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var isCron = (u) => hasProperty(u, TypeId18);
  var make41 = (values3) => {
    const o = Object.create(CronProto);
    o.seconds = new Set(sort(values3.seconds ?? [0], Order));
    o.minutes = new Set(sort(values3.minutes, Order));
    o.hours = new Set(sort(values3.hours, Order));
    o.days = new Set(sort(values3.days, Order));
    o.months = new Set(sort(values3.months, Order));
    o.weekdays = new Set(sort(values3.weekdays, Order));
    o.tz = fromNullable2(values3.tz);
    const seconds2 = Array.from(o.seconds);
    const minutes2 = Array.from(o.minutes);
    const hours2 = Array.from(o.hours);
    const days2 = Array.from(o.days);
    const months = Array.from(o.months);
    const weekdays = Array.from(o.weekdays);
    o.first = {
      second: seconds2[0] ?? 0,
      minute: minutes2[0] ?? 0,
      hour: hours2[0] ?? 0,
      day: days2[0] ?? 1,
      month: (months[0] ?? 1) - 1,
      weekday: weekdays[0] ?? 0
    };
    o.next = {
      second: nextLookupTable(seconds2, 60),
      minute: nextLookupTable(minutes2, 60),
      hour: nextLookupTable(hours2, 24),
      day: nextLookupTable(days2, 32),
      month: nextLookupTable(months, 13),
      weekday: nextLookupTable(weekdays, 7)
    };
    return o;
  };
  var nextLookupTable = (values3, size9) => {
    const result = new Array(size9).fill(void 0);
    if (values3.length === 0) {
      return result;
    }
    let current = void 0;
    let index = values3.length - 1;
    for (let i = size9 - 1; i >= 0; i--) {
      while (index >= 0 && values3[index] >= i) {
        current = values3[index--];
      }
      result[i] = current;
    }
    return result;
  };
  var ParseErrorTypeId = /* @__PURE__ */ Symbol.for("effect/Cron/errors/ParseError");
  var _a51, _b16;
  var ParseError = class extends (_b16 = /* @__PURE__ */ TaggedError("CronParseError"), _a51 = ParseErrorTypeId, _b16) {
    constructor() {
      super(...arguments);
      /**
       * @since 2.0.0
       */
      __publicField(this, _a51, ParseErrorTypeId);
    }
  };
  var parse = (cron3, tz) => {
    const segments = cron3.split(" ").filter(isNonEmpty5);
    if (segments.length !== 5 && segments.length !== 6) {
      return left2(new ParseError({
        message: `Invalid number of segments in cron expression`,
        input: cron3
      }));
    }
    if (segments.length === 5) {
      segments.unshift("0");
    }
    const [seconds2, minutes2, hours2, days2, months, weekdays] = segments;
    const zone = tz === void 0 || isTimeZone(tz) ? right2(tz) : fromOption2(zoneFromString(tz), () => new ParseError({
      message: `Invalid time zone in cron expression`,
      input: tz
    }));
    return all({
      tz: zone,
      seconds: parseSegment(seconds2, secondOptions),
      minutes: parseSegment(minutes2, minuteOptions),
      hours: parseSegment(hours2, hourOptions),
      days: parseSegment(days2, dayOptions),
      months: parseSegment(months, monthOptions),
      weekdays: parseSegment(weekdays, weekdayOptions)
    }).pipe(map(make41));
  };
  var match9 = (cron3, date) => {
    const parts2 = unsafeMakeZoned(date, {
      timeZone: getOrUndefined2(cron3.tz)
    }).pipe(toParts);
    if (cron3.seconds.size !== 0 && !cron3.seconds.has(parts2.seconds)) {
      return false;
    }
    if (cron3.minutes.size !== 0 && !cron3.minutes.has(parts2.minutes)) {
      return false;
    }
    if (cron3.hours.size !== 0 && !cron3.hours.has(parts2.hours)) {
      return false;
    }
    if (cron3.months.size !== 0 && !cron3.months.has(parts2.month)) {
      return false;
    }
    if (cron3.days.size === 0 && cron3.weekdays.size === 0) {
      return true;
    }
    if (cron3.weekdays.size === 0) {
      return cron3.days.has(parts2.day);
    }
    if (cron3.days.size === 0) {
      return cron3.weekdays.has(parts2.weekDay);
    }
    return cron3.days.has(parts2.day) || cron3.weekdays.has(parts2.weekDay);
  };
  var daysInMonth = (date) => new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 0)).getUTCDate();
  var next2 = (cron3, startFrom) => {
    const tz = getOrUndefined2(cron3.tz);
    const zoned = unsafeMakeZoned(startFrom ?? /* @__PURE__ */ new Date(), {
      timeZone: tz
    });
    const utc = tz !== void 0 && isTimeZoneNamed(tz) && tz.id === "UTC";
    const adjustDst = utc ? constVoid : (current) => {
      const adjusted = unsafeMakeZoned(current, {
        timeZone: zoned.zone,
        adjustForTimeZone: true
      }).pipe(toDate);
      const drift = current.getTime() - adjusted.getTime();
      if (drift > 0) {
        current.setTime(current.getTime() + drift);
      }
    };
    const result = mutate4(zoned, (current) => {
      current.setUTCSeconds(current.getUTCSeconds() + 1, 0);
      for (let i = 0; i < 1e4; i++) {
        if (cron3.seconds.size !== 0) {
          const currentSecond = current.getUTCSeconds();
          const nextSecond2 = cron3.next.second[currentSecond];
          if (nextSecond2 === void 0) {
            current.setUTCMinutes(current.getUTCMinutes() + 1, cron3.first.second);
            adjustDst(current);
            continue;
          }
          if (nextSecond2 > currentSecond) {
            current.setUTCSeconds(nextSecond2);
            adjustDst(current);
            continue;
          }
        }
        if (cron3.minutes.size !== 0) {
          const currentMinute = current.getUTCMinutes();
          const nextMinute2 = cron3.next.minute[currentMinute];
          if (nextMinute2 === void 0) {
            current.setUTCHours(current.getUTCHours() + 1, cron3.first.minute, cron3.first.second);
            adjustDst(current);
            continue;
          }
          if (nextMinute2 > currentMinute) {
            current.setUTCMinutes(nextMinute2, cron3.first.second);
            adjustDst(current);
            continue;
          }
        }
        if (cron3.hours.size !== 0) {
          const currentHour = current.getUTCHours();
          const nextHour2 = cron3.next.hour[currentHour];
          if (nextHour2 === void 0) {
            current.setUTCDate(current.getUTCDate() + 1);
            current.setUTCHours(cron3.first.hour, cron3.first.minute, cron3.first.second);
            adjustDst(current);
            continue;
          }
          if (nextHour2 > currentHour) {
            current.setUTCHours(nextHour2, cron3.first.minute, cron3.first.second);
            adjustDst(current);
            continue;
          }
        }
        if (cron3.weekdays.size !== 0 || cron3.days.size !== 0) {
          let a = Infinity;
          let b = Infinity;
          if (cron3.weekdays.size !== 0) {
            const currentWeekday = current.getUTCDay();
            const nextWeekday = cron3.next.weekday[currentWeekday];
            a = nextWeekday === void 0 ? 7 - currentWeekday + cron3.first.weekday : nextWeekday - currentWeekday;
          }
          if (cron3.days.size !== 0 && a !== 0) {
            const currentDay = current.getUTCDate();
            const nextDay2 = cron3.next.day[currentDay];
            b = nextDay2 === void 0 ? daysInMonth(current) - currentDay + cron3.first.day : nextDay2 - currentDay;
          }
          const addDays = Math.min(a, b);
          if (addDays !== 0) {
            current.setUTCDate(current.getUTCDate() + addDays);
            current.setUTCHours(cron3.first.hour, cron3.first.minute, cron3.first.second);
            adjustDst(current);
            continue;
          }
        }
        if (cron3.months.size !== 0) {
          const currentMonth = current.getUTCMonth() + 1;
          const nextMonth = cron3.next.month[currentMonth];
          if (nextMonth === void 0) {
            current.setUTCFullYear(current.getUTCFullYear() + 1);
            current.setUTCMonth(cron3.first.month, cron3.first.day);
            current.setUTCHours(cron3.first.hour, cron3.first.minute, cron3.first.second);
            adjustDst(current);
            continue;
          }
          if (nextMonth > currentMonth) {
            current.setUTCMonth(nextMonth - 1, cron3.first.day);
            current.setUTCHours(cron3.first.hour, cron3.first.minute, cron3.first.second);
            adjustDst(current);
            continue;
          }
        }
        return;
      }
      throw new Error("Unable to find next cron date");
    });
    return toDateUtc(result);
  };
  var Equivalence2 = /* @__PURE__ */ make((self, that) => restrictionsEquals(self.seconds, that.seconds) && restrictionsEquals(self.minutes, that.minutes) && restrictionsEquals(self.hours, that.hours) && restrictionsEquals(self.days, that.days) && restrictionsEquals(self.months, that.months) && restrictionsEquals(self.weekdays, that.weekdays));
  var restrictionsArrayEquals = /* @__PURE__ */ array(number);
  var restrictionsEquals = (self, that) => restrictionsArrayEquals(fromIterable(self), fromIterable(that));
  var equals3 = /* @__PURE__ */ dual(2, (self, that) => Equivalence2(self, that));
  var secondOptions = {
    min: 0,
    max: 59
  };
  var minuteOptions = {
    min: 0,
    max: 59
  };
  var hourOptions = {
    min: 0,
    max: 23
  };
  var dayOptions = {
    min: 1,
    max: 31
  };
  var monthOptions = {
    min: 1,
    max: 12,
    aliases: {
      jan: 1,
      feb: 2,
      mar: 3,
      apr: 4,
      may: 5,
      jun: 6,
      jul: 7,
      aug: 8,
      sep: 9,
      oct: 10,
      nov: 11,
      dec: 12
    }
  };
  var weekdayOptions = {
    min: 0,
    max: 6,
    aliases: {
      sun: 0,
      mon: 1,
      tue: 2,
      wed: 3,
      thu: 4,
      fri: 5,
      sat: 6
    }
  };
  var parseSegment = (input, options) => {
    const capacity = options.max - options.min + 1;
    const values3 = /* @__PURE__ */ new Set();
    const fields = input.split(",");
    for (const field of fields) {
      const [raw, step4] = splitStep(field);
      if (raw === "*" && step4 === void 0) {
        return right2(/* @__PURE__ */ new Set());
      }
      if (step4 !== void 0) {
        if (!Number.isInteger(step4)) {
          return left2(new ParseError({
            message: `Expected step value to be a positive integer`,
            input
          }));
        }
        if (step4 < 1) {
          return left2(new ParseError({
            message: `Expected step value to be greater than 0`,
            input
          }));
        }
        if (step4 > options.max) {
          return left2(new ParseError({
            message: `Expected step value to be less than ${options.max}`,
            input
          }));
        }
      }
      if (raw === "*") {
        for (let i = options.min; i <= options.max; i += step4 ?? 1) {
          values3.add(i);
        }
      } else {
        const [left3, right3] = splitRange(raw, options.aliases);
        if (!Number.isInteger(left3)) {
          return left2(new ParseError({
            message: `Expected a positive integer`,
            input
          }));
        }
        if (left3 < options.min || left3 > options.max) {
          return left2(new ParseError({
            message: `Expected a value between ${options.min} and ${options.max}`,
            input
          }));
        }
        if (right3 === void 0) {
          values3.add(left3);
        } else {
          if (!Number.isInteger(right3)) {
            return left2(new ParseError({
              message: `Expected a positive integer`,
              input
            }));
          }
          if (right3 < options.min || right3 > options.max) {
            return left2(new ParseError({
              message: `Expected a value between ${options.min} and ${options.max}`,
              input
            }));
          }
          if (left3 > right3) {
            return left2(new ParseError({
              message: `Invalid value range`,
              input
            }));
          }
          for (let i = left3; i <= right3; i += step4 ?? 1) {
            values3.add(i);
          }
        }
      }
      if (values3.size >= capacity) {
        return right2(/* @__PURE__ */ new Set());
      }
    }
    return right2(values3);
  };
  var splitStep = (input) => {
    const seperator = input.indexOf("/");
    if (seperator !== -1) {
      return [input.slice(0, seperator), Number(input.slice(seperator + 1))];
    }
    return [input, void 0];
  };
  var splitRange = (input, aliases) => {
    const seperator = input.indexOf("-");
    if (seperator !== -1) {
      return [aliasOrValue(input.slice(0, seperator), aliases), aliasOrValue(input.slice(seperator + 1), aliases)];
    }
    return [aliasOrValue(input, aliases), void 0];
  };
  function aliasOrValue(field, aliases) {
    return aliases?.[field.toLocaleLowerCase()] ?? Number(field);
  }

  // <eztb>/node_modules/effect/dist/esm/Random.js
  var next3 = next;
  var fixed2 = fixed;

  // <eztb>/node_modules/effect/dist/esm/internal/schedule.js
  var ScheduleSymbolKey = "effect/Schedule";
  var ScheduleTypeId = /* @__PURE__ */ Symbol.for(ScheduleSymbolKey);
  var isSchedule = (u) => hasProperty(u, ScheduleTypeId);
  var ScheduleDriverSymbolKey = "effect/ScheduleDriver";
  var ScheduleDriverTypeId = /* @__PURE__ */ Symbol.for(ScheduleDriverSymbolKey);
  var defaultIterationMetadata = {
    start: 0,
    now: 0,
    input: void 0,
    output: void 0,
    elapsed: zero,
    elapsedSincePrevious: zero,
    recurrence: 0
  };
  var CurrentIterationMetadata = /* @__PURE__ */ Reference2()("effect/Schedule/CurrentIterationMetadata", {
    defaultValue: () => defaultIterationMetadata
  });
  var scheduleVariance = {
    /* c8 ignore next */
    _Out: (_) => _,
    /* c8 ignore next */
    _In: (_) => _,
    /* c8 ignore next */
    _R: (_) => _
  };
  var scheduleDriverVariance = {
    /* c8 ignore next */
    _Out: (_) => _,
    /* c8 ignore next */
    _In: (_) => _,
    /* c8 ignore next */
    _R: (_) => _
  };
  var _a52;
  _a52 = ScheduleTypeId;
  var ScheduleImpl = class {
    constructor(initial, step4) {
      __publicField(this, "initial");
      __publicField(this, "step");
      __publicField(this, _a52, scheduleVariance);
      this.initial = initial;
      this.step = step4;
    }
    pipe() {
      return pipeArguments(this, arguments);
    }
  };
  var updateInfo = (iterationMetaRef, now, input, output) => update2(iterationMetaRef, (prev) => prev.recurrence === 0 ? {
    now,
    input,
    output,
    recurrence: prev.recurrence + 1,
    elapsed: zero,
    elapsedSincePrevious: zero,
    start: now
  } : {
    now,
    input,
    output,
    recurrence: prev.recurrence + 1,
    elapsed: millis(now - prev.start),
    elapsedSincePrevious: millis(now - prev.now),
    start: prev.start
  });
  var _a53;
  _a53 = ScheduleDriverTypeId;
  var ScheduleDriverImpl = class {
    constructor(schedule2, ref) {
      __publicField(this, "schedule");
      __publicField(this, "ref");
      __publicField(this, _a53, scheduleDriverVariance);
      __publicField(this, "iterationMeta", /* @__PURE__ */ unsafeMake5(defaultIterationMetadata));
      this.schedule = schedule2;
      this.ref = ref;
    }
    get state() {
      return map9(get11(this.ref), (tuple) => tuple[1]);
    }
    get last() {
      return flatMap8(get11(this.ref), ([element, _]) => {
        switch (element._tag) {
          case "None": {
            return failSync(() => new NoSuchElementException());
          }
          case "Some": {
            return succeed(element.value);
          }
        }
      });
    }
    get reset() {
      return set5(this.ref, [none2(), this.schedule.initial]).pipe(zipLeft(set5(this.iterationMeta, defaultIterationMetadata)));
    }
    next(input) {
      return pipe(map9(get11(this.ref), (tuple) => tuple[1]), flatMap8((state) => pipe(currentTimeMillis2, flatMap8((now) => pipe(suspend(() => this.schedule.step(now, input, state)), flatMap8(([state2, out, decision]) => {
        const setState = set5(this.ref, [some2(out), state2]);
        if (isDone4(decision)) {
          return setState.pipe(zipRight(fail2(none2())));
        }
        const millis2 = start2(decision.intervals) - now;
        if (millis2 <= 0) {
          return setState.pipe(zipRight(updateInfo(this.iterationMeta, now, input, out)), as(out));
        }
        const duration3 = millis(millis2);
        return pipe(setState, zipRight(updateInfo(this.iterationMeta, now, input, out)), zipRight(sleep3(duration3)), as(out));
      }))))));
    }
  };
  var makeWithState = (initial, step4) => new ScheduleImpl(initial, step4);
  var addDelay = /* @__PURE__ */ dual(2, (self, f) => addDelayEffect(self, (out) => sync(() => f(out))));
  var addDelayEffect = /* @__PURE__ */ dual(2, (self, f) => modifyDelayEffect(self, (out, duration3) => map9(f(out), (delay3) => sum(duration3, decode(delay3)))));
  var andThen4 = /* @__PURE__ */ dual(2, (self, that) => map11(andThenEither(self, that), merge));
  var andThenEither = /* @__PURE__ */ dual(2, (self, that) => makeWithState([self.initial, that.initial, true], (now, input, state) => state[2] ? flatMap8(self.step(now, input, state[0]), ([lState, out, decision]) => {
    if (isDone4(decision)) {
      return map9(that.step(now, input, state[1]), ([rState, out2, decision2]) => [[lState, rState, false], right2(out2), decision2]);
    }
    return succeed([[lState, state[1], true], left2(out), decision]);
  }) : map9(that.step(now, input, state[1]), ([rState, out, decision]) => [[state[0], rState, false], right2(out), decision])));
  var as3 = /* @__PURE__ */ dual(2, (self, out) => map11(self, () => out));
  var asVoid2 = (self) => map11(self, constVoid);
  var bothInOut = /* @__PURE__ */ dual(2, (self, that) => makeWithState([self.initial, that.initial], (now, [in1, in2], state) => zipWith3(self.step(now, in1, state[0]), that.step(now, in2, state[1]), ([lState, out, lDecision], [rState, out2, rDecision]) => {
    if (isContinue2(lDecision) && isContinue2(rDecision)) {
      const interval = pipe(lDecision.intervals, union7(rDecision.intervals));
      return [[lState, rState], [out, out2], _continue2(interval)];
    }
    return [[lState, rState], [out, out2], done6];
  })));
  var check = /* @__PURE__ */ dual(2, (self, test) => checkEffect(self, (input, out) => sync(() => test(input, out))));
  var checkEffect = /* @__PURE__ */ dual(2, (self, test) => makeWithState(self.initial, (now, input, state) => flatMap8(self.step(now, input, state), ([state2, out, decision]) => {
    if (isDone4(decision)) {
      return succeed([state2, out, done6]);
    }
    return map9(test(input, out), (cont) => cont ? [state2, out, decision] : [state2, out, done6]);
  })));
  var collectAllInputs = () => collectAllOutputs(identity2());
  var collectAllOutputs = (self) => reduce10(self, empty4(), (outs, out) => pipe(outs, append2(out)));
  var collectUntil = (f) => collectAllOutputs(recurUntil(f));
  var collectUntilEffect = (f) => collectAllOutputs(recurUntilEffect(f));
  var collectWhile = (f) => collectAllOutputs(recurWhile(f));
  var collectWhileEffect = (f) => collectAllOutputs(recurWhileEffect(f));
  var compose = /* @__PURE__ */ dual(2, (self, that) => makeWithState([self.initial, that.initial], (now, input, state) => flatMap8(self.step(now, input, state[0]), ([lState, out, lDecision]) => map9(that.step(now, out, state[1]), ([rState, out2, rDecision]) => isDone4(lDecision) ? [[lState, rState], out2, done6] : isDone4(rDecision) ? [[lState, rState], out2, done6] : [[lState, rState], out2, _continue2(pipe(lDecision.intervals, max5(rDecision.intervals)))]))));
  var mapInput3 = /* @__PURE__ */ dual(2, (self, f) => mapInputEffect(self, (input2) => sync(() => f(input2))));
  var mapInputContext2 = /* @__PURE__ */ dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => mapInputContext(self.step(now, input, state), f)));
  var mapInputEffect = /* @__PURE__ */ dual(2, (self, f) => makeWithState(self.initial, (now, input2, state) => flatMap8(f(input2), (input) => self.step(now, input, state))));
  var cron = (expression, tz) => {
    const parsed = isCron(expression) ? right2(expression) : parse(expression, tz);
    return makeWithState([true, [Number.MIN_SAFE_INTEGER, 0, 0]], (now, _, [initial, previous]) => {
      if (now < previous[0]) {
        return succeed([[false, previous], [previous[1], previous[2]], continueWith2(make37(previous[1], previous[2]))]);
      }
      if (isLeft2(parsed)) {
        return die2(parsed.left);
      }
      const cron3 = parsed.right;
      const date = new Date(now);
      let next4;
      if (initial && match9(cron3, date)) {
        next4 = now;
      }
      next4 = next2(cron3, date).getTime();
      const start3 = beginningOfSecond(next4);
      const end3 = endOfSecond(next4);
      return succeed([[false, [next4, start3, end3]], [start3, end3], continueWith2(make37(start3, end3))]);
    });
  };
  var dayOfMonth = (day) => {
    return makeWithState([Number.NEGATIVE_INFINITY, 0], (now, _, state) => {
      if (!Number.isInteger(day) || day < 1 || 31 < day) {
        return dieSync(() => new IllegalArgumentException(`Invalid argument in: dayOfMonth(${day}). Must be in range 1...31`));
      }
      const n = state[1];
      const initial = n === 0;
      const day0 = nextDayOfMonth(now, day, initial);
      const start3 = beginningOfDay(day0);
      const end3 = endOfDay(day0);
      const interval = make37(start3, end3);
      return succeed([[end3, n + 1], n, continueWith2(interval)]);
    });
  };
  var dayOfWeek = (day) => {
    return makeWithState([Number.MIN_SAFE_INTEGER, 0], (now, _, state) => {
      if (!Number.isInteger(day) || day < 1 || 7 < day) {
        return dieSync(() => new IllegalArgumentException(`Invalid argument in: dayOfWeek(${day}). Must be in range 1 (Monday)...7 (Sunday)`));
      }
      const n = state[1];
      const initial = n === 0;
      const day0 = nextDay(now, day, initial);
      const start3 = beginningOfDay(day0);
      const end3 = endOfDay(day0);
      const interval = make37(start3, end3);
      return succeed([[end3, n + 1], n, continueWith2(interval)]);
    });
  };
  var delayed = /* @__PURE__ */ dual(2, (self, f) => delayedEffect(self, (duration3) => sync(() => f(duration3))));
  var delayedEffect = /* @__PURE__ */ dual(2, (self, f) => modifyDelayEffect(self, (_, delay3) => f(delay3)));
  var delayedSchedule = (schedule2) => addDelay(schedule2, (x) => x);
  var delays = (self) => makeWithState(self.initial, (now, input, state) => pipe(self.step(now, input, state), flatMap8(([state2, _, decision]) => {
    if (isDone4(decision)) {
      return succeed([state2, zero, decision]);
    }
    return succeed([state2, millis(start2(decision.intervals) - now), decision]);
  })));
  var mapBoth3 = /* @__PURE__ */ dual(2, (self, {
    onInput,
    onOutput
  }) => map11(mapInput3(self, onInput), onOutput));
  var mapBothEffect = /* @__PURE__ */ dual(2, (self, {
    onInput,
    onOutput
  }) => mapEffect(mapInputEffect(self, onInput), onOutput));
  var driver = (self) => pipe(make26([none2(), self.initial]), map9((ref) => new ScheduleDriverImpl(self, ref)));
  var duration = (durationInput) => {
    const duration3 = decode(durationInput);
    const durationMillis = toMillis(duration3);
    return makeWithState(true, (now, _, state) => succeed(state ? [false, duration3, continueWith2(after2(now + durationMillis))] : [false, zero, done6]));
  };
  var either3 = /* @__PURE__ */ dual(2, (self, that) => union8(self, that));
  var eitherWith = /* @__PURE__ */ dual(3, (self, that, f) => unionWith2(self, that, f));
  var ensuring2 = /* @__PURE__ */ dual(2, (self, finalizer) => makeWithState(self.initial, (now, input, state) => flatMap8(self.step(now, input, state), ([state2, out, decision]) => isDone4(decision) ? as(finalizer, [state2, out, decision]) : succeed([state2, out, decision]))));
  var exponential2 = (baseInput, factor = 2) => {
    const base = decode(baseInput);
    return delayedSchedule(map11(forever2, (i) => times(base, Math.pow(factor, i))));
  };
  var fibonacci = (oneInput) => {
    const one = decode(oneInput);
    return delayedSchedule(pipe(unfold2([one, one], ([a, b]) => [b, sum(a, b)]), map11((out) => out[0])));
  };
  var fixed3 = (intervalInput) => {
    const interval = decode(intervalInput);
    const intervalMillis = toMillis(interval);
    return makeWithState([none2(), 0], (now, _, [option3, n]) => sync(() => {
      switch (option3._tag) {
        case "None": {
          return [[some2([now, now + intervalMillis]), n + 1], n, continueWith2(after2(now + intervalMillis))];
        }
        case "Some": {
          const [startMillis, lastRun] = option3.value;
          const runningBehind = now > lastRun + intervalMillis;
          const boundary = equals(interval, zero) ? interval : millis(intervalMillis - (now - startMillis) % intervalMillis);
          const sleepTime = equals(boundary, zero) ? interval : boundary;
          const nextRun = runningBehind ? now : now + toMillis(sleepTime);
          return [[some2([startMillis, nextRun]), n + 1], n, continueWith2(after2(nextRun))];
        }
      }
    }));
  };
  var fromDelay = (delay3) => duration(delay3);
  var fromDelays = (delay3, ...delays3) => makeWithState([[delay3, ...delays3].map((_) => decode(_)), true], (now, _, [durations, cont]) => sync(() => {
    if (cont) {
      const x = durations[0];
      const interval = after2(now + toMillis(x));
      if (durations.length >= 2) {
        return [[durations.slice(1), true], x, continueWith2(interval)];
      }
      const y = durations.slice(1);
      return [[[x, ...y], false], x, continueWith2(interval)];
    }
    return [[durations, false], zero, done6];
  }));
  var fromFunction = (f) => map11(identity2(), f);
  var hourOfDay = (hour) => makeWithState([Number.NEGATIVE_INFINITY, 0], (now, _, state) => {
    if (!Number.isInteger(hour) || hour < 0 || 23 < hour) {
      return dieSync(() => new IllegalArgumentException(`Invalid argument in: hourOfDay(${hour}). Must be in range 0...23`));
    }
    const n = state[1];
    const initial = n === 0;
    const hour0 = nextHour(now, hour, initial);
    const start3 = beginningOfHour(hour0);
    const end3 = endOfHour(hour0);
    const interval = make37(start3, end3);
    return succeed([[end3, n + 1], n, continueWith2(interval)]);
  });
  var identity2 = () => makeWithState(void 0, (now, input, state) => succeed([state, input, continueWith2(after2(now))]));
  var intersect5 = /* @__PURE__ */ dual(2, (self, that) => intersectWith(self, that, intersect4));
  var intersectWith = /* @__PURE__ */ dual(3, (self, that, f) => makeWithState([self.initial, that.initial], (now, input, state) => pipe(zipWith3(self.step(now, input, state[0]), that.step(now, input, state[1]), (a, b) => [a, b]), flatMap8(([[lState, out, lDecision], [rState, out2, rDecision]]) => {
    if (isContinue2(lDecision) && isContinue2(rDecision)) {
      return intersectWithLoop(self, that, input, lState, out, lDecision.intervals, rState, out2, rDecision.intervals, f);
    }
    return succeed([[lState, rState], [out, out2], done6]);
  }))));
  var intersectWithLoop = (self, that, input, lState, out, lInterval, rState, out2, rInterval, f) => {
    const combined = f(lInterval, rInterval);
    if (isNonEmpty4(combined)) {
      return succeed([[lState, rState], [out, out2], _continue2(combined)]);
    }
    if (pipe(lInterval, lessThan6(rInterval))) {
      return flatMap8(self.step(end2(lInterval), input, lState), ([lState2, out3, decision]) => {
        if (isDone4(decision)) {
          return succeed([[lState2, rState], [out3, out2], done6]);
        }
        return intersectWithLoop(self, that, input, lState2, out3, decision.intervals, rState, out2, rInterval, f);
      });
    }
    return flatMap8(that.step(end2(rInterval), input, rState), ([rState2, out22, decision]) => {
      if (isDone4(decision)) {
        return succeed([[lState, rState2], [out, out22], done6]);
      }
      return intersectWithLoop(self, that, input, lState, out, lInterval, rState2, out22, decision.intervals, f);
    });
  };
  var jittered = (self) => jitteredWith(self, {
    min: 0.8,
    max: 1.2
  });
  var jitteredWith = /* @__PURE__ */ dual(2, (self, options) => {
    const {
      max: max6,
      min: min4
    } = Object.assign({
      min: 0.8,
      max: 1.2
    }, options);
    return delayedEffect(self, (duration3) => map9(next3, (random4) => {
      const d = toMillis(duration3);
      const jittered3 = d * min4 * (1 - random4) + d * max6 * random4;
      return millis(jittered3);
    }));
  });
  var linear = (baseInput) => {
    const base = decode(baseInput);
    return delayedSchedule(map11(forever2, (i) => times(base, i + 1)));
  };
  var map11 = /* @__PURE__ */ dual(2, (self, f) => mapEffect(self, (out) => sync(() => f(out))));
  var mapEffect = /* @__PURE__ */ dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => flatMap8(self.step(now, input, state), ([state2, out, decision]) => map9(f(out), (out2) => [state2, out2, decision]))));
  var minuteOfHour = (minute) => makeWithState([Number.MIN_SAFE_INTEGER, 0], (now, _, state) => {
    if (!Number.isInteger(minute) || minute < 0 || 59 < minute) {
      return dieSync(() => new IllegalArgumentException(`Invalid argument in: minuteOfHour(${minute}). Must be in range 0...59`));
    }
    const n = state[1];
    const initial = n === 0;
    const minute0 = nextMinute(now, minute, initial);
    const start3 = beginningOfMinute(minute0);
    const end3 = endOfMinute(minute0);
    const interval = make37(start3, end3);
    return succeed([[end3, n + 1], n, continueWith2(interval)]);
  });
  var modifyDelay = /* @__PURE__ */ dual(2, (self, f) => modifyDelayEffect(self, (out, duration3) => sync(() => f(out, duration3))));
  var modifyDelayEffect = /* @__PURE__ */ dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => flatMap8(self.step(now, input, state), ([state2, out, decision]) => {
    if (isDone4(decision)) {
      return succeed([state2, out, decision]);
    }
    const intervals = decision.intervals;
    const delay3 = size8(make37(now, start2(intervals)));
    return map9(f(out, delay3), (durationInput) => {
      const duration3 = decode(durationInput);
      const oldStart = start2(intervals);
      const newStart = now + toMillis(duration3);
      const delta = newStart - oldStart;
      const newEnd = Math.max(0, end2(intervals) + delta);
      const newInterval = make37(newStart, newEnd);
      return [state2, out, continueWith2(newInterval)];
    });
  })));
  var onDecision = /* @__PURE__ */ dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => flatMap8(self.step(now, input, state), ([state2, out, decision]) => as(f(out, decision), [state2, out, decision]))));
  var passthrough = (self) => makeWithState(self.initial, (now, input, state) => pipe(self.step(now, input, state), map9(([state2, _, decision]) => [state2, input, decision])));
  var provideContext3 = /* @__PURE__ */ dual(2, (self, context4) => makeWithState(self.initial, (now, input, state) => provideContext(self.step(now, input, state), context4)));
  var provideService2 = /* @__PURE__ */ dual(3, (self, tag, service) => makeWithState(self.initial, (now, input, state) => contextWithEffect((env) => provideContext(
    // @ts-expect-error
    self.step(now, input, state),
    add2(env, tag, service)
  ))));
  var recurUntil = (f) => untilInput(identity2(), f);
  var recurUntilEffect = (f) => untilInputEffect(identity2(), f);
  var recurUntilOption = (pf) => untilOutput(map11(identity2(), pf), isSome2);
  var recurUpTo = (durationInput) => {
    const duration3 = decode(durationInput);
    return whileOutput(elapsed, (elapsed3) => lessThan2(elapsed3, duration3));
  };
  var recurWhile = (f) => whileInput(identity2(), f);
  var recurWhileEffect = (f) => whileInputEffect(identity2(), f);
  var recurs = (n) => whileOutput(forever2, (out) => out < n);
  var reduce10 = /* @__PURE__ */ dual(3, (self, zero2, f) => reduceEffect2(self, zero2, (z, out) => sync(() => f(z, out))));
  var reduceEffect2 = /* @__PURE__ */ dual(3, (self, zero2, f) => makeWithState([self.initial, zero2], (now, input, [s, z]) => flatMap8(self.step(now, input, s), ([s2, out, decision]) => isDone4(decision) ? succeed([[s2, z], z, decision]) : map9(f(z, out), (z2) => [[s2, z2], z, decision]))));
  var repetitions = (self) => reduce10(self, 0, (n, _) => n + 1);
  var resetAfter = /* @__PURE__ */ dual(2, (self, durationInput) => {
    const duration3 = decode(durationInput);
    return pipe(self, intersect5(elapsed), resetWhen(([, time]) => greaterThanOrEqualTo2(time, duration3)), map11((out) => out[0]));
  });
  var resetWhen = /* @__PURE__ */ dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => flatMap8(self.step(now, input, state), ([state2, out, decision]) => f(out) ? self.step(now, input, self.initial) : succeed([state2, out, decision]))));
  var run = /* @__PURE__ */ dual(3, (self, now, input) => pipe(runLoop(self, now, fromIterable2(input), self.initial, empty4()), map9((list) => reverse2(list))));
  var runLoop = (self, now, inputs, state, acc) => {
    if (!isNonEmpty(inputs)) {
      return succeed(acc);
    }
    const input = headNonEmpty2(inputs);
    const nextInputs = tailNonEmpty2(inputs);
    return flatMap8(self.step(now, input, state), ([state2, out, decision]) => {
      if (isDone4(decision)) {
        return sync(() => pipe(acc, prepend2(out)));
      }
      return runLoop(self, start2(decision.intervals), nextInputs, state2, prepend2(acc, out));
    });
  };
  var secondOfMinute = (second) => makeWithState([Number.NEGATIVE_INFINITY, 0], (now, _, state) => {
    if (!Number.isInteger(second) || second < 0 || 59 < second) {
      return dieSync(() => new IllegalArgumentException(`Invalid argument in: secondOfMinute(${second}). Must be in range 0...59`));
    }
    const n = state[1];
    const initial = n === 0;
    const second0 = nextSecond(now, second, initial);
    const start3 = beginningOfSecond(second0);
    const end3 = endOfSecond(second0);
    const interval = make37(start3, end3);
    return succeed([[end3, n + 1], n, continueWith2(interval)]);
  });
  var spaced = (duration3) => addDelay(forever2, () => duration3);
  var succeed5 = (value) => map11(forever2, () => value);
  var sync4 = (evaluate2) => map11(forever2, evaluate2);
  var tapInput = /* @__PURE__ */ dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => zipRight(f(input), self.step(now, input, state))));
  var tapOutput = /* @__PURE__ */ dual(2, (self, f) => makeWithState(self.initial, (now, input, state) => tap(self.step(now, input, state), ([, out]) => f(out))));
  var unfold2 = (initial, f) => makeWithState(initial, (now, _, state) => sync(() => [f(state), state, continueWith2(after2(now))]));
  var union8 = /* @__PURE__ */ dual(2, (self, that) => unionWith2(self, that, union7));
  var unionWith2 = /* @__PURE__ */ dual(3, (self, that, f) => makeWithState([self.initial, that.initial], (now, input, state) => zipWith3(self.step(now, input, state[0]), that.step(now, input, state[1]), ([lState, l, lDecision], [rState, r, rDecision]) => {
    if (isDone4(lDecision) && isDone4(rDecision)) {
      return [[lState, rState], [l, r], done6];
    }
    if (isDone4(lDecision) && isContinue2(rDecision)) {
      return [[lState, rState], [l, r], _continue2(rDecision.intervals)];
    }
    if (isContinue2(lDecision) && isDone4(rDecision)) {
      return [[lState, rState], [l, r], _continue2(lDecision.intervals)];
    }
    if (isContinue2(lDecision) && isContinue2(rDecision)) {
      const combined = f(lDecision.intervals, rDecision.intervals);
      return [[lState, rState], [l, r], _continue2(combined)];
    }
    throw new Error("BUG: Schedule.unionWith - please report an issue at https://github.com/Effect-TS/effect/issues");
  })));
  var untilInput = /* @__PURE__ */ dual(2, (self, f) => check(self, (input, _) => !f(input)));
  var untilInputEffect = /* @__PURE__ */ dual(2, (self, f) => checkEffect(self, (input, _) => negate(f(input))));
  var untilOutput = /* @__PURE__ */ dual(2, (self, f) => check(self, (_, out) => !f(out)));
  var untilOutputEffect = /* @__PURE__ */ dual(2, (self, f) => checkEffect(self, (_, out) => negate(f(out))));
  var upTo = /* @__PURE__ */ dual(2, (self, duration3) => zipLeft2(self, recurUpTo(duration3)));
  var whileInput = /* @__PURE__ */ dual(2, (self, f) => check(self, (input, _) => f(input)));
  var whileInputEffect = /* @__PURE__ */ dual(2, (self, f) => checkEffect(self, (input, _) => f(input)));
  var whileOutput = /* @__PURE__ */ dual(2, (self, f) => check(self, (_, out) => f(out)));
  var whileOutputEffect = /* @__PURE__ */ dual(2, (self, f) => checkEffect(self, (_, out) => f(out)));
  var windowed = (intervalInput) => {
    const interval = decode(intervalInput);
    const millis2 = toMillis(interval);
    return makeWithState([none2(), 0], (now, _, [option3, n]) => {
      switch (option3._tag) {
        case "None": {
          return succeed([[some2(now), n + 1], n, continueWith2(after2(now + millis2))]);
        }
        case "Some": {
          return succeed([[some2(option3.value), n + 1], n, continueWith2(after2(now + (millis2 - (now - option3.value) % millis2)))]);
        }
      }
    });
  };
  var zipLeft2 = /* @__PURE__ */ dual(2, (self, that) => map11(intersect5(self, that), (out) => out[0]));
  var zipRight2 = /* @__PURE__ */ dual(2, (self, that) => map11(intersect5(self, that), (out) => out[1]));
  var zipWith4 = /* @__PURE__ */ dual(3, (self, that, f) => map11(intersect5(self, that), ([out, out2]) => f(out, out2)));
  var beginningOfSecond = (now) => {
    const date = new Date(now);
    return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), date.getSeconds(), 0).getTime();
  };
  var endOfSecond = (now) => {
    const date = new Date(beginningOfSecond(now));
    return date.setSeconds(date.getSeconds() + 1);
  };
  var nextSecond = (now, second, initial) => {
    const date = new Date(now);
    if (date.getSeconds() === second && initial) {
      return now;
    }
    if (date.getSeconds() < second) {
      return date.setSeconds(second);
    }
    const newDate = new Date(date.setSeconds(second));
    return newDate.setTime(newDate.getTime() + 1e3 * 60);
  };
  var beginningOfMinute = (now) => {
    const date = new Date(now);
    return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), date.getMinutes(), 0, 0).getTime();
  };
  var endOfMinute = (now) => {
    const date = new Date(beginningOfMinute(now));
    return date.setMinutes(date.getMinutes() + 1);
  };
  var nextMinute = (now, minute, initial) => {
    const date = new Date(now);
    if (date.getMinutes() === minute && initial) {
      return now;
    }
    if (date.getMinutes() < minute) {
      return date.setMinutes(minute);
    }
    const newDate = new Date(date.setMinutes(minute));
    return newDate.setTime(newDate.getTime() + 1e3 * 60 * 60);
  };
  var beginningOfHour = (now) => {
    const date = new Date(now);
    return new Date(date.getFullYear(), date.getMonth(), date.getDate(), date.getHours(), 0, 0, 0).getTime();
  };
  var endOfHour = (now) => {
    const date = new Date(beginningOfHour(now));
    return date.setHours(date.getHours() + 1);
  };
  var nextHour = (now, hour, initial) => {
    const date = new Date(now);
    if (date.getHours() === hour && initial) {
      return now;
    }
    if (date.getHours() < hour) {
      return date.setHours(hour);
    }
    const newDate = new Date(date.setHours(hour));
    return newDate.setTime(newDate.getTime() + 1e3 * 60 * 60 * 24);
  };
  var beginningOfDay = (now) => {
    const date = new Date(now);
    return new Date(date.getFullYear(), date.getMonth(), date.getDate(), 0, 0, 0, 0).getTime();
  };
  var endOfDay = (now) => {
    const date = new Date(beginningOfDay(now));
    return date.setDate(date.getDate() + 1);
  };
  var nextDay = (now, dayOfWeek3, initial) => {
    const date = new Date(now);
    if (date.getDay() === dayOfWeek3 && initial) {
      return now;
    }
    const nextDayOfWeek = (7 + dayOfWeek3 - date.getDay()) % 7;
    return date.setDate(date.getDate() + (nextDayOfWeek === 0 ? 7 : nextDayOfWeek));
  };
  var nextDayOfMonth = (now, day, initial) => {
    const date = new Date(now);
    if (date.getDate() === day && initial) {
      return now;
    }
    if (date.getDate() < day) {
      return date.setDate(day);
    }
    return findNextMonth(now, day, 1);
  };
  var findNextMonth = (now, day, months) => {
    const d = new Date(now);
    const tmp1 = new Date(d.setDate(day));
    const tmp2 = new Date(tmp1.setMonth(tmp1.getMonth() + months));
    if (tmp2.getDate() === day) {
      const d2 = new Date(now);
      const tmp3 = new Date(d2.setDate(day));
      return tmp3.setMonth(tmp3.getMonth() + months);
    }
    return findNextMonth(now, day, months + 1);
  };
  var ScheduleDefectTypeId = /* @__PURE__ */ Symbol.for("effect/Schedule/ScheduleDefect");
  var _a54;
  _a54 = ScheduleDefectTypeId;
  var ScheduleDefect = class {
    constructor(error) {
      __publicField(this, "error");
      __publicField(this, _a54);
      this.error = error;
      this[ScheduleDefectTypeId] = ScheduleDefectTypeId;
    }
  };
  var isScheduleDefect = (u) => hasProperty(u, ScheduleDefectTypeId);
  var scheduleDefectWrap = (self) => catchAll(self, (e) => die2(new ScheduleDefect(e)));
  var scheduleDefectRefailCause = (cause3) => match2(find(cause3, (_) => isDieType(_) && isScheduleDefect(_.defect) ? some2(_.defect) : none2()), {
    onNone: () => cause3,
    onSome: (error) => fail(error.error)
  });
  var scheduleDefectRefail = (effect) => catchAllCause(effect, (cause3) => failCause(scheduleDefectRefailCause(cause3)));
  var repeat_Effect = /* @__PURE__ */ dual(2, (self, schedule2) => repeatOrElse_Effect(self, schedule2, (e, _) => fail2(e)));
  var repeat_combined = /* @__PURE__ */ dual(2, (self, options) => {
    if (isSchedule(options)) {
      return repeat_Effect(self, options);
    }
    const base = options.schedule ?? passthrough(forever2);
    const withWhile = options.while ? whileInputEffect(base, (a) => {
      const applied = options.while(a);
      if (typeof applied === "boolean") {
        return succeed(applied);
      }
      return scheduleDefectWrap(applied);
    }) : base;
    const withUntil = options.until ? untilInputEffect(withWhile, (a) => {
      const applied = options.until(a);
      if (typeof applied === "boolean") {
        return succeed(applied);
      }
      return scheduleDefectWrap(applied);
    }) : withWhile;
    const withTimes = options.times ? intersect5(withUntil, recurs(options.times)).pipe(map11((intersectionPair) => intersectionPair[0])) : withUntil;
    return scheduleDefectRefail(repeat_Effect(self, withTimes));
  });
  var repeatOrElse_Effect = /* @__PURE__ */ dual(3, (self, schedule2, orElse4) => flatMap8(driver(schedule2), (driver3) => matchEffect(self, {
    onFailure: (error) => orElse4(error, none2()),
    onSuccess: (value) => repeatOrElseEffectLoop(provideServiceEffect(self, CurrentIterationMetadata, get11(driver3.iterationMeta)), driver3, (error, option3) => provideServiceEffect(orElse4(error, option3), CurrentIterationMetadata, get11(driver3.iterationMeta)), value)
  })));
  var repeatOrElseEffectLoop = (self, driver3, orElse4, value) => matchEffect(driver3.next(value), {
    onFailure: () => orDie(driver3.last),
    onSuccess: (b) => matchEffect(self, {
      onFailure: (error) => orElse4(error, some2(b)),
      onSuccess: (value2) => repeatOrElseEffectLoop(self, driver3, orElse4, value2)
    })
  });
  var retry_Effect = /* @__PURE__ */ dual(2, (self, policy) => retryOrElse_Effect(self, policy, (e, _) => fail2(e)));
  var retry_combined = /* @__PURE__ */ dual(2, (self, options) => {
    if (isSchedule(options)) {
      return retry_Effect(self, options);
    }
    return scheduleDefectRefail(retry_Effect(self, fromRetryOptions(options)));
  });
  var fromRetryOptions = (options) => {
    const base = options.schedule ?? forever2;
    const withWhile = options.while ? whileInputEffect(base, (e) => {
      const applied = options.while(e);
      if (typeof applied === "boolean") {
        return succeed(applied);
      }
      return scheduleDefectWrap(applied);
    }) : base;
    const withUntil = options.until ? untilInputEffect(withWhile, (e) => {
      const applied = options.until(e);
      if (typeof applied === "boolean") {
        return succeed(applied);
      }
      return scheduleDefectWrap(applied);
    }) : withWhile;
    return options.times !== void 0 ? intersect5(withUntil, recurs(options.times)) : withUntil;
  };
  var retryOrElse_Effect = /* @__PURE__ */ dual(3, (self, policy, orElse4) => flatMap8(driver(policy), (driver3) => retryOrElse_EffectLoop(provideServiceEffect(self, CurrentIterationMetadata, get11(driver3.iterationMeta)), driver3, (e, out) => provideServiceEffect(orElse4(e, out), CurrentIterationMetadata, get11(driver3.iterationMeta)))));
  var retryOrElse_EffectLoop = (self, driver3, orElse4) => {
    return catchAll(self, (e) => matchEffect(driver3.next(e), {
      onFailure: () => pipe(driver3.last, orDie, flatMap8((out) => orElse4(e, out))),
      onSuccess: () => retryOrElse_EffectLoop(self, driver3, orElse4)
    }));
  };
  var schedule_Effect = /* @__PURE__ */ dual(2, (self, schedule2) => scheduleFrom_Effect(self, void 0, schedule2));
  var scheduleFrom_Effect = /* @__PURE__ */ dual(3, (self, initial, schedule2) => flatMap8(driver(schedule2), (driver3) => scheduleFrom_EffectLoop(provideServiceEffect(self, CurrentIterationMetadata, get11(driver3.iterationMeta)), initial, driver3)));
  var scheduleFrom_EffectLoop = (self, initial, driver3) => matchEffect(driver3.next(initial), {
    onFailure: () => orDie(driver3.last),
    onSuccess: () => flatMap8(self, (a) => scheduleFrom_EffectLoop(self, a, driver3))
  });
  var count = /* @__PURE__ */ unfold2(0, (n) => n + 1);
  var elapsed = /* @__PURE__ */ makeWithState(/* @__PURE__ */ none2(), (now, _, state) => {
    switch (state._tag) {
      case "None": {
        return succeed([some2(now), zero, continueWith2(after2(now))]);
      }
      case "Some": {
        return succeed([some2(state.value), millis(now - state.value), continueWith2(after2(now))]);
      }
    }
  });
  var forever2 = /* @__PURE__ */ unfold2(0, (n) => n + 1);
  var once2 = /* @__PURE__ */ asVoid2(/* @__PURE__ */ recurs(1));
  var stop = /* @__PURE__ */ asVoid2(/* @__PURE__ */ recurs(0));
  var scheduleForked = /* @__PURE__ */ dual(2, (self, schedule2) => forkScoped(schedule_Effect(self, schedule2)));

  // <eztb>/node_modules/effect/dist/esm/internal/executionPlan.js
  var withExecutionPlan = /* @__PURE__ */ dual(2, (effect, plan) => suspend(() => {
    let i = 0;
    let result;
    return flatMap8(whileLoop({
      while: () => i < plan.steps.length && (result === void 0 || isLeft2(result)),
      body: () => {
        const step4 = plan.steps[i];
        let nextEffect = effect_provide(effect, step4.provide);
        if (result) {
          let attempted = false;
          const wrapped = nextEffect;
          nextEffect = suspend(() => {
            if (attempted) return wrapped;
            attempted = true;
            return result;
          });
          nextEffect = scheduleDefectRefail(retry_Effect(nextEffect, scheduleFromStep(step4, false)));
        } else {
          const schedule2 = scheduleFromStep(step4, true);
          nextEffect = schedule2 ? scheduleDefectRefail(retry_Effect(nextEffect, schedule2)) : nextEffect;
        }
        return either2(nextEffect);
      },
      step: (either6) => {
        result = either6;
        i++;
      }
    }), () => result);
  }));
  var scheduleFromStep = (step4, first2) => {
    if (!first2) {
      return fromRetryOptions({
        schedule: step4.schedule ? step4.schedule : step4.attempts ? void 0 : once2,
        times: step4.attempts,
        while: step4.while
      });
    } else if (step4.attempts === 1 || !(step4.schedule || step4.attempts)) {
      return void 0;
    }
    return fromRetryOptions({
      schedule: step4.schedule,
      while: step4.while,
      times: step4.attempts ? step4.attempts - 1 : void 0
    });
  };

  // <eztb>/node_modules/effect/dist/esm/internal/query.js
  var currentCache = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentCache"), () => fiberRefUnsafeMake(unsafeMakeWith(65536, () => map9(deferredMake(), (handle) => ({
    listeners: new Listeners(),
    handle
  })), () => seconds(60))));
  var currentCacheEnabled = /* @__PURE__ */ globalValue(/* @__PURE__ */ Symbol.for("effect/FiberRef/currentCacheEnabled"), () => fiberRefUnsafeMake(false));
  var fromRequest = (request3, dataSource) => flatMap8(isEffect(dataSource) ? dataSource : succeed(dataSource), (ds) => fiberIdWith((id) => {
    const proxy = new Proxy(request3, {});
    return fiberRefGetWith(currentCacheEnabled, (cacheEnabled) => {
      if (cacheEnabled) {
        const cached4 = fiberRefGetWith(currentCache, (cache7) => flatMap8(cache7.getEither(proxy), (orNew) => {
          switch (orNew._tag) {
            case "Left": {
              if (orNew.left.listeners.interrupted) {
                return flatMap8(cache7.invalidateWhen(proxy, (entry) => entry.handle === orNew.left.handle), () => cached4);
              }
              orNew.left.listeners.increment();
              return uninterruptibleMask((restore) => flatMap8(exit(blocked(empty15, restore(deferredAwait(orNew.left.handle)))), (exit4) => {
                orNew.left.listeners.decrement();
                return exit4;
              }));
            }
            case "Right": {
              orNew.right.listeners.increment();
              return uninterruptibleMask((restore) => flatMap8(exit(blocked(single(ds, makeEntry({
                request: proxy,
                result: orNew.right.handle,
                listeners: orNew.right.listeners,
                ownerId: id,
                state: {
                  completed: false
                }
              })), restore(deferredAwait(orNew.right.handle)))), () => {
                orNew.right.listeners.decrement();
                return deferredAwait(orNew.right.handle);
              }));
            }
          }
        }));
        return cached4;
      }
      const listeners = new Listeners();
      listeners.increment();
      return flatMap8(deferredMake(), (ref) => ensuring(blocked(single(ds, makeEntry({
        request: proxy,
        result: ref,
        listeners,
        ownerId: id,
        state: {
          completed: false
        }
      })), deferredAwait(ref)), sync(() => listeners.decrement())));
    });
  }));
  var cacheRequest = (request3, result) => {
    return fiberRefGetWith(currentCacheEnabled, (cacheEnabled) => {
      if (cacheEnabled) {
        return fiberRefGetWith(currentCache, (cache7) => flatMap8(cache7.getEither(request3), (orNew) => {
          switch (orNew._tag) {
            case "Left": {
              return void_2;
            }
            case "Right": {
              return deferredComplete(orNew.right.handle, result);
            }
          }
        }));
      }
      return void_2;
    });
  };
  var withRequestCaching = /* @__PURE__ */ dual(2, (self, strategy) => fiberRefLocally(self, currentCacheEnabled, strategy));
  var withRequestCache = /* @__PURE__ */ dual(
    2,
    // @ts-expect-error
    (self, cache7) => fiberRefLocally(self, currentCache, cache7)
  );

  // <eztb>/node_modules/effect/dist/esm/Request.js
  var isRequest2 = isRequest;

  // <eztb>/node_modules/effect/dist/esm/Effect.js
  var EffectTypeId3 = EffectTypeId2;
  var isEffect2 = isEffect;
  var cachedWithTTL = cached2;
  var cachedInvalidateWithTTL2 = cachedInvalidateWithTTL;
  var cached3 = memoize;
  var cachedFunction2 = cachedFunction;
  var once3 = once;
  var all4 = all3;
  var allWith2 = allWith;
  var allSuccesses2 = allSuccesses;
  var dropUntil2 = dropUntil;
  var dropWhile2 = dropWhile;
  var takeUntil2 = takeUntil;
  var takeWhile2 = takeWhile;
  var every5 = every4;
  var exists2 = exists;
  var filter5 = filter4;
  var filterMap4 = filterMap3;
  var findFirst5 = findFirst3;
  var forEach8 = forEach7;
  var head4 = head3;
  var mergeAll5 = mergeAll3;
  var partition4 = partition3;
  var reduce11 = reduce8;
  var reduceWhile2 = reduceWhile;
  var reduceRight3 = reduceRight2;
  var reduceEffect3 = reduceEffect;
  var replicate2 = replicate;
  var replicateEffect2 = replicateEffect;
  var validateAll2 = validateAll;
  var validateFirst2 = validateFirst;
  var async2 = async_;
  var asyncEffect2 = asyncEffect;
  var custom2 = custom;
  var withFiberRuntime2 = withFiberRuntime;
  var fail4 = fail2;
  var failSync2 = failSync;
  var failCause4 = failCause;
  var failCauseSync2 = failCauseSync;
  var die3 = die2;
  var dieMessage2 = dieMessage;
  var dieSync2 = dieSync;
  var gen3 = gen2;
  var never2 = never;
  var none9 = none6;
  var promise2 = promise;
  var succeed7 = succeed;
  var succeedNone2 = succeedNone;
  var succeedSome2 = succeedSome;
  var suspend4 = suspend;
  var sync5 = sync;
  var _void = void_2;
  var yieldNow4 = yieldNow;
  var _catch2 = _catch;
  var catchAll2 = catchAll;
  var catchAllCause2 = catchAllCause;
  var catchAllDefect2 = catchAllDefect;
  var catchIf2 = catchIf;
  var catchSome2 = catchSome;
  var catchSomeCause2 = catchSomeCause;
  var catchSomeDefect2 = catchSomeDefect;
  var catchTag2 = catchTag;
  var catchTags2 = catchTags;
  var cause2 = cause;
  var eventually2 = eventually;
  var ignore2 = ignore;
  var ignoreLogged2 = ignoreLogged;
  var parallelErrors2 = parallelErrors;
  var sandbox2 = sandbox;
  var retry = retry_combined;
  var withExecutionPlan2 = withExecutionPlan;
  var retryOrElse = retryOrElse_Effect;
  var try_3 = try_2;
  var tryMap2 = tryMap;
  var tryMapPromise2 = tryMapPromise;
  var tryPromise2 = tryPromise;
  var unsandbox2 = unsandbox;
  var allowInterrupt2 = allowInterrupt;
  var checkInterruptible2 = checkInterruptible;
  var disconnect2 = disconnect;
  var interrupt4 = interrupt2;
  var interruptWith2 = interruptWith;
  var interruptible4 = interruptible2;
  var interruptibleMask2 = interruptibleMask;
  var onInterrupt2 = onInterrupt;
  var uninterruptible2 = uninterruptible;
  var uninterruptibleMask3 = uninterruptibleMask;
  var liftPredicate3 = liftPredicate2;
  var as4 = as;
  var asSome2 = asSome;
  var asSomeError2 = asSomeError;
  var asVoid3 = asVoid;
  var flip3 = flip2;
  var flipWith2 = flipWith;
  var map12 = map9;
  var mapAccum3 = mapAccum2;
  var mapBoth4 = mapBoth2;
  var mapError2 = mapError;
  var mapErrorCause2 = mapErrorCause;
  var merge6 = merge5;
  var negate2 = negate;
  var acquireRelease2 = acquireRelease;
  var acquireReleaseInterruptible2 = acquireReleaseInterruptible;
  var acquireUseRelease2 = acquireUseRelease;
  var addFinalizer2 = addFinalizer;
  var ensuring3 = ensuring;
  var onError2 = onError;
  var onExit3 = onExit;
  var parallelFinalizers2 = parallelFinalizers;
  var sequentialFinalizers2 = sequentialFinalizers;
  var finalizersMask2 = finalizersMask;
  var scope2 = scope;
  var scopeWith2 = scopeWith;
  var scopedWith2 = scopedWith;
  var scoped2 = scopedEffect;
  var using2 = using;
  var withEarlyRelease2 = withEarlyRelease;
  var awaitAllChildren2 = awaitAllChildren;
  var daemonChildren2 = daemonChildren;
  var descriptor2 = descriptor;
  var descriptorWith2 = descriptorWith;
  var diffFiberRefs2 = diffFiberRefs;
  var ensuringChild2 = ensuringChild;
  var ensuringChildren2 = ensuringChildren;
  var fiberId2 = fiberId;
  var fiberIdWith2 = fiberIdWith;
  var fork3 = fork;
  var forkDaemon2 = forkDaemon;
  var forkAll2 = forkAll;
  var forkIn2 = forkIn;
  var forkScoped2 = forkScoped;
  var forkWithErrorHandler2 = forkWithErrorHandler;
  var fromFiber2 = fromFiber;
  var fromFiberEffect2 = fromFiberEffect;
  var supervised2 = supervised;
  var transplant2 = transplant;
  var withConcurrency2 = withConcurrency;
  var withScheduler2 = withScheduler;
  var withSchedulingPriority2 = withSchedulingPriority;
  var withMaxOpsBeforeYield2 = withMaxOpsBeforeYield;
  var clock2 = clock;
  var clockWith4 = clockWith3;
  var withClockScoped2 = withClockScoped;
  var withClock2 = withClock;
  var console3 = console2;
  var consoleWith2 = consoleWith;
  var withConsoleScoped2 = withConsoleScoped;
  var withConsole2 = withConsole;
  var delay2 = delay;
  var sleep4 = sleep3;
  var timed2 = timed;
  var timedWith2 = timedWith;
  var timeout2 = timeout;
  var timeoutOption2 = timeoutOption;
  var timeoutFail2 = timeoutFail;
  var timeoutFailCause2 = timeoutFailCause;
  var timeoutTo2 = timeoutTo;
  var configProviderWith2 = configProviderWith;
  var withConfigProvider2 = withConfigProvider;
  var withConfigProviderScoped2 = withConfigProviderScoped;
  var context3 = context;
  var contextWith2 = contextWith;
  var contextWithEffect2 = contextWithEffect;
  var mapInputContext3 = mapInputContext;
  var provide2 = effect_provide;
  var provideService3 = provideService;
  var provideServiceEffect2 = provideServiceEffect;
  var serviceFunction2 = serviceFunction;
  var serviceFunctionEffect2 = serviceFunctionEffect;
  var serviceFunctions2 = serviceFunctions;
  var serviceConstants2 = serviceConstants;
  var serviceMembers2 = serviceMembers;
  var serviceOption2 = serviceOption;
  var serviceOptional2 = serviceOptional;
  var updateService2 = updateService;
  var Do3 = Do2;
  var bind4 = bind3;
  var bindAll2 = bindAll;
  var bindTo4 = bindTo3;
  var let_4 = let_3;
  var option2 = option;
  var either4 = either2;
  var exit3 = exit;
  var intoDeferred2 = intoDeferred;
  var if_2 = if_;
  var filterOrDie2 = filterOrDie;
  var filterOrDieMessage2 = filterOrDieMessage;
  var filterOrElse2 = filterOrElse;
  var filterOrFail2 = filterOrFail;
  var filterEffectOrElse2 = filterEffectOrElse;
  var filterEffectOrFail2 = filterEffectOrFail;
  var unless2 = unless;
  var unlessEffect2 = unlessEffect;
  var when2 = when;
  var whenEffect2 = whenEffect;
  var whenFiberRef2 = whenFiberRef;
  var whenRef2 = whenRef;
  var flatMap10 = flatMap8;
  var andThen5 = andThen3;
  var flatten6 = flatten4;
  var race2 = race;
  var raceAll2 = raceAll;
  var raceFirst2 = raceFirst;
  var raceWith2 = raceWith;
  var summarized2 = summarized;
  var tap2 = tap;
  var tapBoth2 = tapBoth;
  var tapDefect2 = tapDefect;
  var tapError2 = tapError;
  var tapErrorTag2 = tapErrorTag;
  var tapErrorCause2 = tapErrorCause;
  var forever3 = forever;
  var iterate2 = iterate;
  var loop2 = loop;
  var repeat = repeat_combined;
  var repeatN2 = repeatN;
  var repeatOrElse = repeatOrElse_Effect;
  var schedule = schedule_Effect;
  var scheduleForked2 = scheduleForked;
  var scheduleFrom = scheduleFrom_Effect;
  var whileLoop3 = whileLoop;
  var getFiberRefs = fiberRefs2;
  var inheritFiberRefs2 = inheritFiberRefs;
  var locally = fiberRefLocally;
  var locallyWith = fiberRefLocallyWith;
  var locallyScoped = fiberRefLocallyScoped;
  var locallyScopedWith = fiberRefLocallyScopedWith;
  var patchFiberRefs2 = patchFiberRefs;
  var setFiberRefs2 = setFiberRefs;
  var updateFiberRefs2 = updateFiberRefs;
  var isFailure2 = isFailure;
  var isSuccess2 = isSuccess;
  var match10 = match6;
  var matchCause3 = matchCause;
  var matchCauseEffect3 = matchCauseEffect;
  var matchEffect2 = matchEffect;
  var log3 = log2;
  var logWithLevel2 = (level, ...message) => logWithLevel(level)(...message);
  var logTrace2 = logTrace;
  var logDebug2 = logDebug;
  var logInfo2 = logInfo;
  var logWarning2 = logWarning;
  var logError2 = logError;
  var logFatal2 = logFatal;
  var withLogSpan2 = withLogSpan;
  var annotateLogs2 = annotateLogs;
  var annotateLogsScoped2 = annotateLogsScoped;
  var logAnnotations2 = logAnnotations;
  var withUnhandledErrorLogLevel2 = withUnhandledErrorLogLevel;
  var whenLogLevel2 = whenLogLevel;
  var orDie2 = orDie;
  var orDieWith2 = orDieWith;
  var orElse3 = orElse2;
  var orElseFail2 = orElseFail;
  var orElseSucceed2 = orElseSucceed;
  var firstSuccessOf2 = firstSuccessOf;
  var random3 = random2;
  var randomWith2 = randomWith;
  var withRandom2 = withRandom;
  var withRandomFixed = /* @__PURE__ */ dual(2, (effect, values3) => withRandom2(effect, fixed2(values3)));
  var withRandomScoped2 = withRandomScoped;
  var runtime3 = runtime2;
  var getRuntimeFlags = runtimeFlags;
  var patchRuntimeFlags = updateRuntimeFlags;
  var withRuntimeFlagsPatch = withRuntimeFlags;
  var withRuntimeFlagsPatchScoped = withRuntimeFlagsScoped;
  var tagMetrics2 = tagMetrics;
  var labelMetrics2 = labelMetrics;
  var tagMetricsScoped2 = tagMetricsScoped;
  var labelMetricsScoped2 = labelMetricsScoped;
  var metricLabels2 = metricLabels;
  var withMetric2 = withMetric;
  var unsafeMakeSemaphore2 = unsafeMakeSemaphore;
  var makeSemaphore2 = makeSemaphore;
  var unsafeMakeLatch2 = unsafeMakeLatch;
  var makeLatch2 = makeLatch;
  var runFork2 = unsafeForkEffect;
  var runCallback = unsafeRunEffect;
  var runPromise = unsafeRunPromiseEffect;
  var runPromiseExit = unsafeRunPromiseExitEffect;
  var runSync = unsafeRunSyncEffect;
  var runSyncExit = unsafeRunSyncExitEffect;
  var validate2 = validate;
  var validateWith2 = validateWith;
  var zip4 = zipOptions;
  var zipLeft3 = zipLeftOptions;
  var zipRight3 = zipRightOptions;
  var zipWith5 = zipWithOptions;
  var ap2 = /* @__PURE__ */ dual(2, (self, that) => zipWith5(self, that, (f, a) => f(a)));
  var blocked2 = blocked;
  var runRequestBlock2 = runRequestBlock;
  var step3 = step2;
  var request = /* @__PURE__ */ dual((args2) => isRequest2(args2[0]), fromRequest);
  var cacheRequestResult = cacheRequest;
  var withRequestBatching2 = withRequestBatching;
  var withRequestCaching2 = withRequestCaching;
  var withRequestCache2 = withRequestCache;
  var tracer2 = tracer;
  var tracerWith4 = tracerWith;
  var withTracer2 = withTracer;
  var withTracerScoped2 = withTracerScoped;
  var withTracerEnabled2 = withTracerEnabled;
  var withTracerTiming2 = withTracerTiming;
  var annotateSpans2 = annotateSpans;
  var annotateCurrentSpan2 = annotateCurrentSpan;
  var currentSpan2 = currentSpan;
  var currentParentSpan2 = currentParentSpan;
  var spanAnnotations2 = spanAnnotations;
  var spanLinks2 = spanLinks;
  var linkSpans2 = linkSpans;
  var linkSpanCurrent2 = linkSpanCurrent;
  var makeSpan2 = makeSpan;
  var makeSpanScoped2 = makeSpanScoped;
  var useSpan2 = useSpan;
  var withSpan2 = withSpan;
  var functionWithSpan2 = functionWithSpan;
  var withSpanScoped2 = withSpanScoped;
  var withParentSpan2 = withParentSpan;
  var fromNullable4 = fromNullable3;
  var optionFromOptional2 = optionFromOptional;
  var transposeOption2 = (self) => {
    return isNone(self) ? succeedNone2 : map12(self.value, some);
  };
  var transposeMapOption2 = /* @__PURE__ */ dual(2, (self, f) => isNone(self) ? succeedNone2 : map12(f(self.value), some));
  var makeTagProxy = (TagClass) => {
    const cache7 = /* @__PURE__ */ new Map();
    return new Proxy(TagClass, {
      get(target, prop, receiver) {
        if (prop in target) {
          return Reflect.get(target, prop, receiver);
        }
        if (cache7.has(prop)) {
          return cache7.get(prop);
        }
        const fn2 = (...args2) => andThen3(target, (s) => {
          if (typeof s[prop] === "function") {
            cache7.set(prop, (...args3) => andThen3(target, (s2) => s2[prop](...args3)));
            return s[prop](...args2);
          }
          cache7.set(prop, andThen3(target, (s2) => s2[prop]));
          return s[prop];
        });
        const cn = andThen3(target, (s) => s[prop]);
        Object.assign(fn2, cn);
        const apply = fn2.apply;
        const bind5 = fn2.bind;
        const call = fn2.call;
        const proto4 = Object.setPrototypeOf({}, Object.getPrototypeOf(cn));
        proto4.apply = apply;
        proto4.bind = bind5;
        proto4.call = call;
        Object.setPrototypeOf(fn2, proto4);
        cache7.set(prop, fn2);
        return fn2;
      }
    });
  };
  var Tag2 = (id) => () => {
    const limit = Error.stackTraceLimit;
    Error.stackTraceLimit = 2;
    const creationError = new Error();
    Error.stackTraceLimit = limit;
    function TagClass() {
    }
    Object.setPrototypeOf(TagClass, TagProto);
    TagClass.key = id;
    Object.defineProperty(TagClass, "use", {
      get() {
        return (body) => andThen3(this, body);
      }
    });
    Object.defineProperty(TagClass, "stack", {
      get() {
        return creationError.stack;
      }
    });
    return makeTagProxy(TagClass);
  };
  var Service = function() {
    return function() {
      const [id, maker] = arguments;
      const proxy = "accessors" in maker ? maker["accessors"] : false;
      const limit = Error.stackTraceLimit;
      Error.stackTraceLimit = 2;
      const creationError = new Error();
      Error.stackTraceLimit = limit;
      let patchState = "unchecked";
      const TagClass = function(service) {
        if (patchState === "unchecked") {
          const proto4 = Object.getPrototypeOf(service);
          if (proto4 === Object.prototype || proto4 === null) {
            patchState = "plain";
          } else {
            const selfProto = Object.getPrototypeOf(this);
            Object.setPrototypeOf(selfProto, proto4);
            patchState = "patched";
          }
        }
        if (patchState === "plain") {
          Object.assign(this, service);
        } else if (patchState === "patched") {
          Object.setPrototypeOf(service, Object.getPrototypeOf(this));
          return service;
        }
      };
      TagClass.prototype._tag = id;
      Object.defineProperty(TagClass, "make", {
        get() {
          return (service) => new this(service);
        }
      });
      Object.defineProperty(TagClass, "use", {
        get() {
          return (body) => andThen3(this, body);
        }
      });
      TagClass.key = id;
      Object.assign(TagClass, TagProto);
      Object.defineProperty(TagClass, "stack", {
        get() {
          return creationError.stack;
        }
      });
      const hasDeps = "dependencies" in maker && maker.dependencies.length > 0;
      const layerName = hasDeps ? "DefaultWithoutDependencies" : "Default";
      let layerCache;
      let isFunction3 = false;
      if ("effect" in maker) {
        isFunction3 = typeof maker.effect === "function";
        Object.defineProperty(TagClass, layerName, {
          get() {
            if (isFunction3) {
              return function() {
                return fromEffect2(TagClass, map12(maker.effect.apply(null, arguments), (_) => new this(_)));
              }.bind(this);
            }
            return layerCache ?? (layerCache = fromEffect2(TagClass, map12(maker.effect, (_) => new this(_))));
          }
        });
      } else if ("scoped" in maker) {
        isFunction3 = typeof maker.scoped === "function";
        Object.defineProperty(TagClass, layerName, {
          get() {
            if (isFunction3) {
              return function() {
                return scoped(TagClass, map12(maker.scoped.apply(null, arguments), (_) => new this(_)));
              }.bind(this);
            }
            return layerCache ?? (layerCache = scoped(TagClass, map12(maker.scoped, (_) => new this(_))));
          }
        });
      } else if ("sync" in maker) {
        Object.defineProperty(TagClass, layerName, {
          get() {
            return layerCache ?? (layerCache = sync3(TagClass, () => new this(maker.sync())));
          }
        });
      } else {
        Object.defineProperty(TagClass, layerName, {
          get() {
            return layerCache ?? (layerCache = succeed4(TagClass, new this(maker.succeed)));
          }
        });
      }
      if (hasDeps) {
        let layerWithDepsCache;
        Object.defineProperty(TagClass, "Default", {
          get() {
            if (isFunction3) {
              return function() {
                return provide(this.DefaultWithoutDependencies.apply(null, arguments), maker.dependencies);
              };
            }
            return layerWithDepsCache ?? (layerWithDepsCache = provide(this.DefaultWithoutDependencies, maker.dependencies));
          }
        });
      }
      return proxy === true ? makeTagProxy(TagClass) : TagClass;
    };
  };
  var fn = function(nameOrBody, ...pipeables) {
    const limit = Error.stackTraceLimit;
    Error.stackTraceLimit = 2;
    const errorDef = new Error();
    Error.stackTraceLimit = limit;
    if (typeof nameOrBody !== "string") {
      return defineLength(nameOrBody.length, function(...args2) {
        const limit2 = Error.stackTraceLimit;
        Error.stackTraceLimit = 2;
        const errorCall = new Error();
        Error.stackTraceLimit = limit2;
        return fnApply({
          self: this,
          body: nameOrBody,
          args: args2,
          pipeables,
          spanName: "<anonymous>",
          spanOptions: {
            context: DisablePropagation.context(true)
          },
          errorDef,
          errorCall
        });
      });
    }
    const name = nameOrBody;
    const options = pipeables[0];
    return (body, ...pipeables2) => defineLength(body.length, {
      [name](...args2) {
        const limit2 = Error.stackTraceLimit;
        Error.stackTraceLimit = 2;
        const errorCall = new Error();
        Error.stackTraceLimit = limit2;
        return fnApply({
          self: this,
          body,
          args: args2,
          pipeables: pipeables2,
          spanName: name,
          spanOptions: options,
          errorDef,
          errorCall
        });
      }
    }[name]);
  };
  function defineLength(length2, fn2) {
    return Object.defineProperty(fn2, "length", {
      value: length2,
      configurable: true
    });
  }
  function fnApply(options) {
    let effect;
    let fnError = void 0;
    if (isGeneratorFunction(options.body)) {
      effect = fromIterator(() => options.body.apply(options.self, options.args));
    } else {
      try {
        effect = options.body.apply(options.self, options.args);
      } catch (error) {
        fnError = error;
        effect = die3(error);
      }
    }
    if (options.pipeables.length > 0) {
      try {
        for (const x of options.pipeables) {
          effect = x(effect, ...options.args);
        }
      } catch (error) {
        effect = fnError ? failCause4(sequential(die(fnError), die(error))) : die3(error);
      }
    }
    let cache7 = false;
    const captureStackTrace = () => {
      if (cache7 !== false) {
        return cache7;
      }
      if (options.errorCall.stack) {
        const stackDef = options.errorDef.stack.trim().split("\n");
        const stackCall = options.errorCall.stack.trim().split("\n");
        let endStackDef = stackDef.slice(2).join("\n").trim();
        if (!endStackDef.includes(`(`)) {
          endStackDef = endStackDef.replace(/at (.*)/, "at ($1)");
        }
        let endStackCall = stackCall.slice(2).join("\n").trim();
        if (!endStackCall.includes(`(`)) {
          endStackCall = endStackCall.replace(/at (.*)/, "at ($1)");
        }
        cache7 = `${endStackDef}
${endStackCall}`;
        return cache7;
      }
    };
    const opts = options.spanOptions && "captureStackTrace" in options.spanOptions ? options.spanOptions : {
      captureStackTrace,
      ...options.spanOptions
    };
    return withSpan2(effect, options.spanName, opts);
  }
  var fnUntraced2 = fnUntraced;
  var ensureSuccessType = () => (effect) => effect;
  var ensureErrorType = () => (effect) => effect;
  var ensureRequirementsType = () => (effect) => effect;

  // <eztb>/node_modules/effect/dist/esm/Schedule.js
  var Schedule_exports = {};
  __export(Schedule_exports, {
    CurrentIterationMetadata: () => CurrentIterationMetadata2,
    ScheduleDriverTypeId: () => ScheduleDriverTypeId2,
    ScheduleTypeId: () => ScheduleTypeId2,
    addDelay: () => addDelay2,
    addDelayEffect: () => addDelayEffect2,
    andThen: () => andThen6,
    andThenEither: () => andThenEither2,
    as: () => as5,
    asVoid: () => asVoid4,
    bothInOut: () => bothInOut2,
    check: () => check2,
    checkEffect: () => checkEffect2,
    collectAllInputs: () => collectAllInputs2,
    collectAllOutputs: () => collectAllOutputs2,
    collectUntil: () => collectUntil2,
    collectUntilEffect: () => collectUntilEffect2,
    collectWhile: () => collectWhile2,
    collectWhileEffect: () => collectWhileEffect2,
    compose: () => compose2,
    count: () => count2,
    cron: () => cron2,
    dayOfMonth: () => dayOfMonth2,
    dayOfWeek: () => dayOfWeek2,
    delayed: () => delayed2,
    delayedEffect: () => delayedEffect2,
    delayedSchedule: () => delayedSchedule2,
    delays: () => delays2,
    driver: () => driver2,
    duration: () => duration2,
    either: () => either5,
    eitherWith: () => eitherWith2,
    elapsed: () => elapsed2,
    ensuring: () => ensuring4,
    exponential: () => exponential3,
    fibonacci: () => fibonacci2,
    fixed: () => fixed4,
    forever: () => forever4,
    fromDelay: () => fromDelay2,
    fromDelays: () => fromDelays2,
    fromFunction: () => fromFunction2,
    hourOfDay: () => hourOfDay2,
    identity: () => identity3,
    intersect: () => intersect6,
    intersectWith: () => intersectWith2,
    isSchedule: () => isSchedule2,
    jittered: () => jittered2,
    jitteredWith: () => jitteredWith2,
    linear: () => linear2,
    makeWithState: () => makeWithState2,
    map: () => map13,
    mapBoth: () => mapBoth5,
    mapBothEffect: () => mapBothEffect2,
    mapEffect: () => mapEffect2,
    mapInput: () => mapInput4,
    mapInputContext: () => mapInputContext4,
    mapInputEffect: () => mapInputEffect2,
    minuteOfHour: () => minuteOfHour2,
    modifyDelay: () => modifyDelay2,
    modifyDelayEffect: () => modifyDelayEffect2,
    onDecision: () => onDecision2,
    once: () => once4,
    passthrough: () => passthrough2,
    provideContext: () => provideContext4,
    provideService: () => provideService4,
    recurUntil: () => recurUntil2,
    recurUntilEffect: () => recurUntilEffect2,
    recurUntilOption: () => recurUntilOption2,
    recurUpTo: () => recurUpTo2,
    recurWhile: () => recurWhile2,
    recurWhileEffect: () => recurWhileEffect2,
    recurs: () => recurs2,
    reduce: () => reduce12,
    reduceEffect: () => reduceEffect4,
    repeatForever: () => repeatForever,
    repetitions: () => repetitions2,
    resetAfter: () => resetAfter2,
    resetWhen: () => resetWhen2,
    run: () => run2,
    secondOfMinute: () => secondOfMinute2,
    spaced: () => spaced2,
    stop: () => stop2,
    succeed: () => succeed8,
    sync: () => sync6,
    tapInput: () => tapInput2,
    tapOutput: () => tapOutput2,
    unfold: () => unfold3,
    union: () => union9,
    unionWith: () => unionWith3,
    untilInput: () => untilInput2,
    untilInputEffect: () => untilInputEffect2,
    untilOutput: () => untilOutput2,
    untilOutputEffect: () => untilOutputEffect2,
    upTo: () => upTo2,
    whileInput: () => whileInput2,
    whileInputEffect: () => whileInputEffect2,
    whileOutput: () => whileOutput2,
    whileOutputEffect: () => whileOutputEffect2,
    windowed: () => windowed2,
    zipLeft: () => zipLeft4,
    zipRight: () => zipRight4,
    zipWith: () => zipWith6
  });
  var ScheduleTypeId2 = ScheduleTypeId;
  var ScheduleDriverTypeId2 = ScheduleDriverTypeId;
  var makeWithState2 = makeWithState;
  var isSchedule2 = isSchedule;
  var addDelay2 = addDelay;
  var addDelayEffect2 = addDelayEffect;
  var andThen6 = andThen4;
  var andThenEither2 = andThenEither;
  var as5 = as3;
  var asVoid4 = asVoid2;
  var bothInOut2 = bothInOut;
  var check2 = check;
  var checkEffect2 = checkEffect;
  var collectAllInputs2 = collectAllInputs;
  var collectAllOutputs2 = collectAllOutputs;
  var collectUntil2 = collectUntil;
  var collectUntilEffect2 = collectUntilEffect;
  var collectWhile2 = collectWhile;
  var collectWhileEffect2 = collectWhileEffect;
  var compose2 = compose;
  var mapInput4 = mapInput3;
  var mapInputEffect2 = mapInputEffect;
  var mapInputContext4 = mapInputContext2;
  var count2 = count;
  var cron2 = cron;
  var secondOfMinute2 = secondOfMinute;
  var minuteOfHour2 = minuteOfHour;
  var hourOfDay2 = hourOfDay;
  var dayOfMonth2 = dayOfMonth;
  var dayOfWeek2 = dayOfWeek;
  var delayed2 = delayed;
  var delayedEffect2 = delayedEffect;
  var delayedSchedule2 = delayedSchedule;
  var delays2 = delays;
  var mapBoth5 = mapBoth3;
  var mapBothEffect2 = mapBothEffect;
  var driver2 = driver;
  var duration2 = duration;
  var either5 = either3;
  var eitherWith2 = eitherWith;
  var elapsed2 = elapsed;
  var ensuring4 = ensuring2;
  var exponential3 = exponential2;
  var fibonacci2 = fibonacci;
  var fixed4 = fixed3;
  var forever4 = forever2;
  var fromDelay2 = fromDelay;
  var fromDelays2 = fromDelays;
  var fromFunction2 = fromFunction;
  var identity3 = identity2;
  var passthrough2 = passthrough;
  var intersect6 = intersect5;
  var intersectWith2 = intersectWith;
  var jittered2 = jittered;
  var jitteredWith2 = jitteredWith;
  var linear2 = linear;
  var map13 = map11;
  var mapEffect2 = mapEffect;
  var modifyDelay2 = modifyDelay;
  var modifyDelayEffect2 = modifyDelayEffect;
  var onDecision2 = onDecision;
  var once4 = once2;
  var provideContext4 = provideContext3;
  var provideService4 = provideService2;
  var recurUntil2 = recurUntil;
  var recurUntilEffect2 = recurUntilEffect;
  var recurUntilOption2 = recurUntilOption;
  var recurUpTo2 = recurUpTo;
  var recurWhile2 = recurWhile;
  var recurWhileEffect2 = recurWhileEffect;
  var recurs2 = recurs;
  var reduce12 = reduce10;
  var reduceEffect4 = reduceEffect2;
  var repeatForever = forever2;
  var repetitions2 = repetitions;
  var resetAfter2 = resetAfter;
  var resetWhen2 = resetWhen;
  var run2 = run;
  var spaced2 = spaced;
  var stop2 = stop;
  var succeed8 = succeed5;
  var sync6 = sync4;
  var tapInput2 = tapInput;
  var tapOutput2 = tapOutput;
  var unfold3 = unfold2;
  var union9 = union8;
  var unionWith3 = unionWith2;
  var untilInput2 = untilInput;
  var untilInputEffect2 = untilInputEffect;
  var untilOutput2 = untilOutput;
  var untilOutputEffect2 = untilOutputEffect;
  var upTo2 = upTo;
  var whileInput2 = whileInput;
  var whileInputEffect2 = whileInputEffect;
  var whileOutput2 = whileOutput;
  var whileOutputEffect2 = whileOutputEffect;
  var windowed2 = windowed;
  var zipLeft4 = zipLeft2;
  var zipRight4 = zipRight2;
  var zipWith6 = zipWith4;
  var CurrentIterationMetadata2 = CurrentIterationMetadata;

  // <eztb>/packages/sdk/src/core/errors.ts
  var TiebaError = class extends Error {
  };
  var FetchError = class extends TiebaError {
    constructor(cause3) {
      super(cause3 instanceof Error ? cause3.message : String(cause3));
      this.cause = cause3;
      __publicField(this, "_tag", "FetchError");
      __publicField(this, "httpStatus", 502);
    }
  };
  var TiebaServerError = class extends TiebaError {
    constructor(code, msg) {
      super(`Tieba API error ${code}: ${msg}`);
      this.code = code;
      this.msg = msg;
      __publicField(this, "_tag", "TiebaServerError");
      __publicField(this, "httpStatus", 502);
    }
  };

  // <eztb>/packages/sdk/src/context.ts
  var _client = null;
  function getClient() {
    if (!_client) {
      throw new Error("TiebaClient 未初始化，请先调用 initClient()");
    }
    return _client;
  }
  function initClient(client) {
    _client = client;
  }

  // src/core/netPolicy.ts
  var RETRY_MAX_ATTEMPTS = 3;
  var RETRY_BASE_DELAY_MS = 700;
  var BREAKER_FAILURE_THRESHOLD = 5;
  var BREAKER_COOLDOWN_MS = 3e4;
  var RequestPausedError = class extends Error {
    constructor(remainingMs) {
      super(
        `连续 ${BREAKER_FAILURE_THRESHOLD} 次请求失败，已暂停请求约 ${Math.ceil(remainingMs / 1e3)} 秒；可在「诊断当前页面」里点「重置熔断」立即恢复`
      );
      this.name = "RequestPausedError";
      this.remainingMs = remainingMs;
    }
  };
  function isRetryableError(error) {
    if (!error || typeof error !== "object") return false;
    const kind = error.kind;
    if (kind === "network" || kind === "timeout") return true;
    const tag = error._tag;
    if (tag === "FetchError") return true;
    return error.name === "FetchError";
  }
  var consecutiveFailures = 0;
  var openUntil = 0;
  var pausedRequests = 0;
  function breakerSnapshot(now = Date.now()) {
    const remainingMs = Math.max(0, openUntil - now);
    return {
      open: remainingMs > 0,
      consecutiveFailures,
      openUntil,
      remainingMs,
      pausedRequests,
      threshold: BREAKER_FAILURE_THRESHOLD,
      cooldownMs: BREAKER_COOLDOWN_MS
    };
  }
  function recordRequestSuccess() {
    consecutiveFailures = 0;
    openUntil = 0;
  }
  function recordRequestFailure(now = Date.now()) {
    consecutiveFailures += 1;
    if (consecutiveFailures >= BREAKER_FAILURE_THRESHOLD && openUntil <= now) {
      openUntil = now + BREAKER_COOLDOWN_MS;
    }
  }
  function resetBreaker() {
    consecutiveFailures = 0;
    openUntil = 0;
    pausedRequests = 0;
  }
  async function withRequestPolicy(task, label = "请求", deps = {}) {
    const now = deps.now ?? Date.now;
    const sleep5 = deps.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
    for (let attempt = 1; ; attempt += 1) {
      const snapshot = breakerSnapshot(now());
      if (snapshot.open) {
        pausedRequests += 1;
        throw new RequestPausedError(snapshot.remainingMs);
      }
      try {
        const result = await task();
        recordRequestSuccess();
        return result;
      } catch (error) {
        if (isRetryableError(error) && attempt < RETRY_MAX_ATTEMPTS) {
          const delay3 = RETRY_BASE_DELAY_MS * 2 ** (attempt - 1);
          log.warn(
            `${label}失败（第 ${attempt}/${RETRY_MAX_ATTEMPTS} 次尝试），${delay3}ms 后重试`,
            error
          );
          await sleep5(delay3);
          continue;
        }
        recordRequestFailure(now());
        const after3 = breakerSnapshot(now());
        if (after3.open) {
          log.warn(
            `已连续失败 ${after3.consecutiveFailures} 次，暂停请求 ${Math.round(after3.cooldownMs / 1e3)} 秒`
          );
        }
        throw error;
      }
    }
  }

  // src/shims/undici.ts
  var Agent = class {
    constructor(_options) {
    }
  };
  var FormData = globalThis.FormData;
  function upgradeToHttps(url) {
    return url.replace(
      /^http:\/\/tiebac\.baidu\.com/i,
      "https://tiebac.baidu.com"
    );
  }
  function normalizeHeaders(headers) {
    if (!headers) return void 0;
    if (typeof Headers !== "undefined" && headers instanceof Headers) {
      const out = {};
      headers.forEach((value, key) => {
        out[key] = value;
      });
      return out;
    }
    return headers;
  }
  async function request2(url, options = {}) {
    const target = upgradeToHttps(String(url));
    const response = await withRequestPolicy(
      () => gmRequest({
        method: options.method ?? "GET",
        url: target,
        headers: normalizeHeaders(options.headers),
        data: options.body ?? null,
        responseType: "arraybuffer",
        timeout: DEFAULT_TIMEOUT
      }),
      `请求 ${target}`
    );
    const raw = response.response;
    const buffer = raw instanceof ArrayBuffer ? raw : raw instanceof Uint8Array ? raw.buffer.slice(
      raw.byteOffset,
      raw.byteOffset + raw.byteLength
    ) : new ArrayBuffer(0);
    const decode2 = () => new TextDecoder("utf-8").decode(buffer);
    return {
      statusCode: response.status,
      statusText: response.statusText ?? "",
      body: {
        json: async () => JSON.parse(decode2()),
        arrayBuffer: async () => buffer,
        text: async () => decode2(),
        dump: async () => {
        }
      }
    };
  }

  // <eztb>/packages/sdk/src/core/http.ts
  var BASE_URL = "http://tiebac.baidu.com";
  var CLIENT_VERSION = "12.64.1.1";
  var CLIENT_VERSION_OLD = "8.9.8.5";
  var CLIENT_TYPE = 2;
  var defaultRequestOptions = { method: "GET" };
  var defaultAgent = new Agent({
    connections: 32,
    pipelining: 1,
    connectTimeout: 1e4,
    headersTimeout: 3e4,
    bodyTimeout: 3e4,
    keepAliveTimeout: 1e4,
    keepAliveMaxTimeout: 6e4,
    autoSelectFamily: true,
    autoSelectFamilyAttemptTimeout: 250
  });
  var sharedDispatcher = defaultAgent;
  function withDispatcher(options) {
    if (options.dispatcher) return options;
    return { ...options, dispatcher: sharedDispatcher };
  }
  var PROTO_MULTIPART_FILENAME = "file";
  function buildProtoMultipartFormData(buffer) {
    const data = new FormData();
    data.set("data", new Blob([Buffer.from(buffer)]), PROTO_MULTIPART_FILENAME);
    return data;
  }
  function requestWithRetry(url, requestOptions = defaultRequestOptions, getBody = "arrayBuffer", retries = 3, delay3 = 1e3) {
    const urlObj = new URL(url, url[0] === "h" ? void 0 : BASE_URL);
    return Effect_exports.tryPromise({
      try: async () => {
        const res = await request2(urlObj, withDispatcher(requestOptions));
        if (res.statusCode >= 400) {
          await res.body.dump().catch(() => void 0);
          throw new FetchError(`${res.statusCode} ${res.statusText}`.trim());
        }
        return res.body[getBody]();
      },
      catch: (error) => error instanceof FetchError ? error : new FetchError(error)
    }).pipe(
      Effect_exports.retry({
        schedule: Schedule_exports.exponential(delay3),
        times: retries
      })
    );
  }
  function getData(url, requestOptions = defaultRequestOptions) {
    return requestWithRetry(url, requestOptions, "json");
  }
  function postFormData(url, data) {
    return requestWithRetry(
      url,
      {
        method: "POST",
        headers: {
          "Content-Type": "application/x-www-form-urlencoded"
        },
        body: data
      },
      "json"
    );
  }
  function postProtobuf(url, buffer) {
    return pipe(
      buildProtoMultipartFormData(buffer),
      (data) => requestWithRetry(
        BASE_URL + url,
        {
          method: "POST",
          headers: {
            x_bd_data_type: "protobuf"
          },
          body: data
        },
        "arrayBuffer"
      ),
      Effect_exports.andThen((buf) => new Uint8Array(buf))
    );
  }

  // <eztb>/packages/sdk/src/core/form.ts
  function createFormApi(config) {
    return (params) => Effect_exports.gen(function* () {
      const client = getClient();
      const tbs = yield* client.getTbs();
      const formParams = {
        BDUSS: client.bduss,
        tbs,
        ...config.buildParams(params)
      };
      const res = yield* postFormData(
        config.endpoint,
        client.packRequest(formParams)
      );
      const code = Number(res.error_code);
      if (code !== 0) {
        throw new TiebaServerError(code, res.error_msg ?? res.error ?? "");
      }
      if (config.extractResult) {
        return config.extractResult(res);
      }
      return void 0;
    });
  }

  // <eztb>/packages/sdk/src/core/proto.ts
  function createProtoApi(config) {
    return (params) => pipe(
      Effect_exports.succeed(
        config.reqCodec.encode(config.reqCodec.fromPartial(config.buildRequest(params))).finish()
      ),
      Effect_exports.andThen((buf) => getClient().postProtobuf(config.endpoint, buf)),
      Effect_exports.map((buf) => {
        const res = config.resCodec.decode(buf);
        if (res.error?.errorno) {
          throw new TiebaServerError(res.error.errorno, res.error.errmsg ?? "");
        }
        return config.extractResult(res);
      })
    );
  }

  // <eztb>/node_modules/@bufbuild/protobuf/dist/esm/wire/varint.js
  function varint64read() {
    let lowBits = 0;
    let highBits = 0;
    for (let shift2 = 0; shift2 < 28; shift2 += 7) {
      let b = this.buf[this.pos++];
      lowBits |= (b & 127) << shift2;
      if ((b & 128) == 0) {
        this.assertBounds();
        return [lowBits, highBits];
      }
    }
    let middleByte = this.buf[this.pos++];
    lowBits |= (middleByte & 15) << 28;
    highBits = (middleByte & 112) >> 4;
    if ((middleByte & 128) == 0) {
      this.assertBounds();
      return [lowBits, highBits];
    }
    for (let shift2 = 3; shift2 <= 31; shift2 += 7) {
      let b = this.buf[this.pos++];
      highBits |= (b & 127) << shift2;
      if ((b & 128) == 0) {
        this.assertBounds();
        return [lowBits, highBits];
      }
    }
    throw new Error("invalid varint");
  }
  function varint64write(lo, hi, bytes) {
    for (let i = 0; i < 28; i = i + 7) {
      const shift2 = lo >>> i;
      const hasNext = !(shift2 >>> 7 == 0 && hi == 0);
      const byte = (hasNext ? shift2 | 128 : shift2) & 255;
      bytes.push(byte);
      if (!hasNext) {
        return;
      }
    }
    const splitBits = lo >>> 28 & 15 | (hi & 7) << 4;
    const hasMoreBits = !(hi >> 3 == 0);
    bytes.push((hasMoreBits ? splitBits | 128 : splitBits) & 255);
    if (!hasMoreBits) {
      return;
    }
    for (let i = 3; i < 31; i = i + 7) {
      const shift2 = hi >>> i;
      const hasNext = !(shift2 >>> 7 == 0);
      const byte = (hasNext ? shift2 | 128 : shift2) & 255;
      bytes.push(byte);
      if (!hasNext) {
        return;
      }
    }
    bytes.push(hi >>> 31 & 1);
  }
  var TWO_PWR_32_DBL = 4294967296;
  function int64FromString(dec) {
    const minus = dec[0] === "-";
    if (minus) {
      dec = dec.slice(1);
    }
    const base = 1e6;
    let lowBits = 0;
    let highBits = 0;
    function add1e6digit(begin, end3) {
      const digit1e6 = Number(dec.slice(begin, end3));
      highBits *= base;
      lowBits = lowBits * base + digit1e6;
      if (lowBits >= TWO_PWR_32_DBL) {
        highBits = highBits + (lowBits / TWO_PWR_32_DBL | 0);
        lowBits = lowBits % TWO_PWR_32_DBL;
      }
    }
    add1e6digit(-24, -18);
    add1e6digit(-18, -12);
    add1e6digit(-12, -6);
    add1e6digit(-6);
    return minus ? negate3(lowBits, highBits) : newBits(lowBits, highBits);
  }
  function int64ToString(lo, hi) {
    let bits = newBits(lo, hi);
    const negative = bits.hi & 2147483648;
    if (negative) {
      bits = negate3(bits.lo, bits.hi);
    }
    const result = uInt64ToString(bits.lo, bits.hi);
    return negative ? "-" + result : result;
  }
  function uInt64ToString(lo, hi) {
    ({ lo, hi } = toUnsigned(lo, hi));
    if (hi <= 2097151) {
      return String(TWO_PWR_32_DBL * hi + lo);
    }
    const low = lo & 16777215;
    const mid = (lo >>> 24 | hi << 8) & 16777215;
    const high = hi >> 16 & 65535;
    let digitA = low + mid * 6777216 + high * 6710656;
    let digitB = mid + high * 8147497;
    let digitC = high * 2;
    const base = 1e7;
    if (digitA >= base) {
      digitB += Math.floor(digitA / base);
      digitA %= base;
    }
    if (digitB >= base) {
      digitC += Math.floor(digitB / base);
      digitB %= base;
    }
    return digitC.toString() + decimalFrom1e7WithLeadingZeros(digitB) + decimalFrom1e7WithLeadingZeros(digitA);
  }
  function toUnsigned(lo, hi) {
    return { lo: lo >>> 0, hi: hi >>> 0 };
  }
  function newBits(lo, hi) {
    return { lo: lo | 0, hi: hi | 0 };
  }
  function negate3(lowBits, highBits) {
    highBits = ~highBits;
    if (lowBits) {
      lowBits = ~lowBits + 1;
    } else {
      highBits += 1;
    }
    return newBits(lowBits, highBits);
  }
  var decimalFrom1e7WithLeadingZeros = (digit1e7) => {
    const partial = String(digit1e7);
    return "0000000".slice(partial.length) + partial;
  };
  function varint32write(value, bytes) {
    if (value >= 0) {
      while (value > 127) {
        bytes.push(value & 127 | 128);
        value = value >>> 7;
      }
      bytes.push(value);
    } else {
      for (let i = 0; i < 9; i++) {
        bytes.push(value & 127 | 128);
        value = value >> 7;
      }
      bytes.push(1);
    }
  }
  function varint32read() {
    let b = this.buf[this.pos++];
    let result = b & 127;
    if ((b & 128) == 0) {
      this.assertBounds();
      return result;
    }
    b = this.buf[this.pos++];
    result |= (b & 127) << 7;
    if ((b & 128) == 0) {
      this.assertBounds();
      return result;
    }
    b = this.buf[this.pos++];
    result |= (b & 127) << 14;
    if ((b & 128) == 0) {
      this.assertBounds();
      return result;
    }
    b = this.buf[this.pos++];
    result |= (b & 127) << 21;
    if ((b & 128) == 0) {
      this.assertBounds();
      return result;
    }
    b = this.buf[this.pos++];
    result |= (b & 15) << 28;
    for (let readBytes = 5; (b & 128) !== 0 && readBytes < 10; readBytes++)
      b = this.buf[this.pos++];
    if ((b & 128) != 0)
      throw new Error("invalid varint");
    this.assertBounds();
    return result >>> 0;
  }

  // <eztb>/node_modules/@bufbuild/protobuf/dist/esm/proto-int64.js
  var protoInt64 = /* @__PURE__ */ makeInt64Support();
  function makeInt64Support() {
    const dv = new DataView(new ArrayBuffer(8));
    const ok = typeof BigInt === "function" && typeof dv.getBigInt64 === "function" && typeof dv.getBigUint64 === "function" && typeof dv.setBigInt64 === "function" && typeof dv.setBigUint64 === "function" && (!!globalThis.Deno || typeof process != "object" || typeof process.env != "object" || process.env.BUF_BIGINT_DISABLE !== "1");
    if (ok) {
      const MIN = BigInt("-9223372036854775808");
      const MAX = BigInt("9223372036854775807");
      const UMIN = BigInt("0");
      const UMAX = BigInt("18446744073709551615");
      return {
        zero: BigInt(0),
        supported: true,
        parse(value) {
          const bi = typeof value == "bigint" ? value : BigInt(value);
          if (bi > MAX || bi < MIN) {
            throw new Error(`invalid int64: ${value}`);
          }
          return bi;
        },
        uParse(value) {
          const bi = typeof value == "bigint" ? value : BigInt(value);
          if (bi > UMAX || bi < UMIN) {
            throw new Error(`invalid uint64: ${value}`);
          }
          return bi;
        },
        enc(value) {
          dv.setBigInt64(0, this.parse(value), true);
          return {
            lo: dv.getInt32(0, true),
            hi: dv.getInt32(4, true)
          };
        },
        uEnc(value) {
          dv.setBigInt64(0, this.uParse(value), true);
          return {
            lo: dv.getInt32(0, true),
            hi: dv.getInt32(4, true)
          };
        },
        dec(lo, hi) {
          dv.setInt32(0, lo, true);
          dv.setInt32(4, hi, true);
          return dv.getBigInt64(0, true);
        },
        uDec(lo, hi) {
          dv.setInt32(0, lo, true);
          dv.setInt32(4, hi, true);
          return dv.getBigUint64(0, true);
        }
      };
    }
    return {
      zero: "0",
      supported: false,
      parse(value) {
        if (typeof value != "string") {
          value = value.toString();
        }
        assertInt64String(value);
        return value;
      },
      uParse(value) {
        if (typeof value != "string") {
          value = value.toString();
        }
        assertUInt64String(value);
        return value;
      },
      enc(value) {
        if (typeof value != "string") {
          value = value.toString();
        }
        assertInt64String(value);
        return int64FromString(value);
      },
      uEnc(value) {
        if (typeof value != "string") {
          value = value.toString();
        }
        assertUInt64String(value);
        return int64FromString(value);
      },
      dec(lo, hi) {
        return int64ToString(lo, hi);
      },
      uDec(lo, hi) {
        return uInt64ToString(lo, hi);
      }
    };
  }
  function assertInt64String(value) {
    if (!/^-?[0-9]+$/.test(value)) {
      throw new Error("invalid int64: " + value);
    }
  }
  function assertUInt64String(value) {
    if (!/^[0-9]+$/.test(value)) {
      throw new Error("invalid uint64: " + value);
    }
  }

  // <eztb>/node_modules/@bufbuild/protobuf/dist/esm/wire/text-encoding.js
  var symbol3 = /* @__PURE__ */ Symbol.for("@bufbuild/protobuf/text-encoding");
  function getTextEncoding() {
    if (globalThis[symbol3] == void 0) {
      const te = new globalThis.TextEncoder();
      const td = new globalThis.TextDecoder();
      globalThis[symbol3] = {
        encodeUtf8(text) {
          return te.encode(text);
        },
        decodeUtf8(bytes) {
          return td.decode(bytes);
        },
        checkUtf8(text) {
          try {
            encodeURIComponent(text);
            return true;
          } catch (_) {
            return false;
          }
        }
      };
    }
    return globalThis[symbol3];
  }

  // <eztb>/node_modules/@bufbuild/protobuf/dist/esm/wire/binary-encoding.js
  var WireType;
  (function(WireType2) {
    WireType2[WireType2["Varint"] = 0] = "Varint";
    WireType2[WireType2["Bit64"] = 1] = "Bit64";
    WireType2[WireType2["LengthDelimited"] = 2] = "LengthDelimited";
    WireType2[WireType2["StartGroup"] = 3] = "StartGroup";
    WireType2[WireType2["EndGroup"] = 4] = "EndGroup";
    WireType2[WireType2["Bit32"] = 5] = "Bit32";
  })(WireType || (WireType = {}));
  var FLOAT32_MAX = 34028234663852886e22;
  var FLOAT32_MIN = -34028234663852886e22;
  var UINT32_MAX = 4294967295;
  var INT32_MAX = 2147483647;
  var INT32_MIN = -2147483648;
  var BinaryWriter = class {
    constructor(encodeUtf8 = getTextEncoding().encodeUtf8) {
      this.encodeUtf8 = encodeUtf8;
      this.stack = [];
      this.chunks = [];
      this.buf = [];
    }
    /**
     * Return all bytes written and reset this writer.
     */
    finish() {
      if (this.buf.length) {
        this.chunks.push(new Uint8Array(this.buf));
        this.buf = [];
      }
      let len = 0;
      for (let i = 0; i < this.chunks.length; i++)
        len += this.chunks[i].length;
      let bytes = new Uint8Array(len);
      let offset = 0;
      for (let i = 0; i < this.chunks.length; i++) {
        bytes.set(this.chunks[i], offset);
        offset += this.chunks[i].length;
      }
      this.chunks = [];
      return bytes;
    }
    /**
     * Start a new fork for length-delimited data like a message
     * or a packed repeated field.
     *
     * Must be joined later with `join()`.
     */
    fork() {
      this.stack.push({ chunks: this.chunks, buf: this.buf });
      this.chunks = [];
      this.buf = [];
      return this;
    }
    /**
     * Join the last fork. Write its length and bytes, then
     * return to the previous state.
     */
    join() {
      let chunk2 = this.finish();
      let prev = this.stack.pop();
      if (!prev)
        throw new Error("invalid state, fork stack empty");
      this.chunks = prev.chunks;
      this.buf = prev.buf;
      this.uint32(chunk2.byteLength);
      return this.raw(chunk2);
    }
    /**
     * Writes a tag (field number and wire type).
     *
     * Equivalent to `uint32( (fieldNo << 3 | type) >>> 0 )`.
     *
     * Generated code should compute the tag ahead of time and call `uint32()`.
     */
    tag(fieldNo, type) {
      return this.uint32((fieldNo << 3 | type) >>> 0);
    }
    /**
     * Write a chunk of raw bytes.
     */
    raw(chunk2) {
      if (this.buf.length) {
        this.chunks.push(new Uint8Array(this.buf));
        this.buf = [];
      }
      this.chunks.push(chunk2);
      return this;
    }
    /**
     * Write a `uint32` value, an unsigned 32 bit varint.
     */
    uint32(value) {
      assertUInt32(value);
      while (value > 127) {
        this.buf.push(value & 127 | 128);
        value = value >>> 7;
      }
      this.buf.push(value);
      return this;
    }
    /**
     * Write a `int32` value, a signed 32 bit varint.
     */
    int32(value) {
      assertInt32(value);
      varint32write(value, this.buf);
      return this;
    }
    /**
     * Write a `bool` value, a variant.
     */
    bool(value) {
      this.buf.push(value ? 1 : 0);
      return this;
    }
    /**
     * Write a `bytes` value, length-delimited arbitrary data.
     */
    bytes(value) {
      this.uint32(value.byteLength);
      return this.raw(value);
    }
    /**
     * Write a `string` value, length-delimited data converted to UTF-8 text.
     */
    string(value) {
      let chunk2 = this.encodeUtf8(value);
      this.uint32(chunk2.byteLength);
      return this.raw(chunk2);
    }
    /**
     * Write a `float` value, 32-bit floating point number.
     */
    float(value) {
      assertFloat32(value);
      let chunk2 = new Uint8Array(4);
      new DataView(chunk2.buffer).setFloat32(0, value, true);
      return this.raw(chunk2);
    }
    /**
     * Write a `double` value, a 64-bit floating point number.
     */
    double(value) {
      let chunk2 = new Uint8Array(8);
      new DataView(chunk2.buffer).setFloat64(0, value, true);
      return this.raw(chunk2);
    }
    /**
     * Write a `fixed32` value, an unsigned, fixed-length 32-bit integer.
     */
    fixed32(value) {
      assertUInt32(value);
      let chunk2 = new Uint8Array(4);
      new DataView(chunk2.buffer).setUint32(0, value, true);
      return this.raw(chunk2);
    }
    /**
     * Write a `sfixed32` value, a signed, fixed-length 32-bit integer.
     */
    sfixed32(value) {
      assertInt32(value);
      let chunk2 = new Uint8Array(4);
      new DataView(chunk2.buffer).setInt32(0, value, true);
      return this.raw(chunk2);
    }
    /**
     * Write a `sint32` value, a signed, zigzag-encoded 32-bit varint.
     */
    sint32(value) {
      assertInt32(value);
      value = (value << 1 ^ value >> 31) >>> 0;
      varint32write(value, this.buf);
      return this;
    }
    /**
     * Write a `fixed64` value, a signed, fixed-length 64-bit integer.
     */
    sfixed64(value) {
      let chunk2 = new Uint8Array(8), view = new DataView(chunk2.buffer), tc = protoInt64.enc(value);
      view.setInt32(0, tc.lo, true);
      view.setInt32(4, tc.hi, true);
      return this.raw(chunk2);
    }
    /**
     * Write a `fixed64` value, an unsigned, fixed-length 64 bit integer.
     */
    fixed64(value) {
      let chunk2 = new Uint8Array(8), view = new DataView(chunk2.buffer), tc = protoInt64.uEnc(value);
      view.setInt32(0, tc.lo, true);
      view.setInt32(4, tc.hi, true);
      return this.raw(chunk2);
    }
    /**
     * Write a `int64` value, a signed 64-bit varint.
     */
    int64(value) {
      let tc = protoInt64.enc(value);
      varint64write(tc.lo, tc.hi, this.buf);
      return this;
    }
    /**
     * Write a `sint64` value, a signed, zig-zag-encoded 64-bit varint.
     */
    sint64(value) {
      const tc = protoInt64.enc(value), sign = tc.hi >> 31, lo = tc.lo << 1 ^ sign, hi = (tc.hi << 1 | tc.lo >>> 31) ^ sign;
      varint64write(lo, hi, this.buf);
      return this;
    }
    /**
     * Write a `uint64` value, an unsigned 64-bit varint.
     */
    uint64(value) {
      const tc = protoInt64.uEnc(value);
      varint64write(tc.lo, tc.hi, this.buf);
      return this;
    }
  };
  var BinaryReader = class {
    constructor(buf, decodeUtf8 = getTextEncoding().decodeUtf8) {
      this.decodeUtf8 = decodeUtf8;
      this.varint64 = varint64read;
      this.uint32 = varint32read;
      this.buf = buf;
      this.len = buf.length;
      this.pos = 0;
      this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
    }
    /**
     * Reads a tag - field number and wire type.
     */
    tag() {
      let tag = this.uint32(), fieldNo = tag >>> 3, wireType = tag & 7;
      if (fieldNo <= 0 || wireType < 0 || wireType > 5)
        throw new Error("illegal tag: field no " + fieldNo + " wire type " + wireType);
      return [fieldNo, wireType];
    }
    /**
     * Skip one element and return the skipped data.
     *
     * When skipping StartGroup, provide the tags field number to check for
     * matching field number in the EndGroup tag.
     */
    skip(wireType, fieldNo) {
      let start3 = this.pos;
      switch (wireType) {
        case WireType.Varint:
          while (this.buf[this.pos++] & 128) {
          }
          break;
        // @ts-ignore TS7029: Fallthrough case in switch -- ignore instead of expect-error for compiler settings without noFallthroughCasesInSwitch: true
        case WireType.Bit64:
          this.pos += 4;
        case WireType.Bit32:
          this.pos += 4;
          break;
        case WireType.LengthDelimited:
          let len = this.uint32();
          this.pos += len;
          break;
        case WireType.StartGroup:
          for (; ; ) {
            const [fn2, wt] = this.tag();
            if (wt === WireType.EndGroup) {
              if (fieldNo !== void 0 && fn2 !== fieldNo) {
                throw new Error("invalid end group tag");
              }
              break;
            }
            this.skip(wt, fn2);
          }
          break;
        default:
          throw new Error("cant skip wire type " + wireType);
      }
      this.assertBounds();
      return this.buf.subarray(start3, this.pos);
    }
    /**
     * Throws error if position in byte array is out of range.
     */
    assertBounds() {
      if (this.pos > this.len)
        throw new RangeError("premature EOF");
    }
    /**
     * Read a `int32` field, a signed 32 bit varint.
     */
    int32() {
      return this.uint32() | 0;
    }
    /**
     * Read a `sint32` field, a signed, zigzag-encoded 32-bit varint.
     */
    sint32() {
      let zze = this.uint32();
      return zze >>> 1 ^ -(zze & 1);
    }
    /**
     * Read a `int64` field, a signed 64-bit varint.
     */
    int64() {
      return protoInt64.dec(...this.varint64());
    }
    /**
     * Read a `uint64` field, an unsigned 64-bit varint.
     */
    uint64() {
      return protoInt64.uDec(...this.varint64());
    }
    /**
     * Read a `sint64` field, a signed, zig-zag-encoded 64-bit varint.
     */
    sint64() {
      let [lo, hi] = this.varint64();
      let s = -(lo & 1);
      lo = (lo >>> 1 | (hi & 1) << 31) ^ s;
      hi = hi >>> 1 ^ s;
      return protoInt64.dec(lo, hi);
    }
    /**
     * Read a `bool` field, a variant.
     */
    bool() {
      let [lo, hi] = this.varint64();
      return lo !== 0 || hi !== 0;
    }
    /**
     * Read a `fixed32` field, an unsigned, fixed-length 32-bit integer.
     */
    fixed32() {
      return this.view.getUint32((this.pos += 4) - 4, true);
    }
    /**
     * Read a `sfixed32` field, a signed, fixed-length 32-bit integer.
     */
    sfixed32() {
      return this.view.getInt32((this.pos += 4) - 4, true);
    }
    /**
     * Read a `fixed64` field, an unsigned, fixed-length 64 bit integer.
     */
    fixed64() {
      return protoInt64.uDec(this.sfixed32(), this.sfixed32());
    }
    /**
     * Read a `fixed64` field, a signed, fixed-length 64-bit integer.
     */
    sfixed64() {
      return protoInt64.dec(this.sfixed32(), this.sfixed32());
    }
    /**
     * Read a `float` field, 32-bit floating point number.
     */
    float() {
      return this.view.getFloat32((this.pos += 4) - 4, true);
    }
    /**
     * Read a `double` field, a 64-bit floating point number.
     */
    double() {
      return this.view.getFloat64((this.pos += 8) - 8, true);
    }
    /**
     * Read a `bytes` field, length-delimited arbitrary data.
     */
    bytes() {
      let len = this.uint32(), start3 = this.pos;
      this.pos += len;
      this.assertBounds();
      return this.buf.subarray(start3, start3 + len);
    }
    /**
     * Read a `string` field, length-delimited data converted to UTF-8 text.
     */
    string() {
      return this.decodeUtf8(this.bytes());
    }
  };
  function assertInt32(arg) {
    if (typeof arg == "string") {
      arg = Number(arg);
    } else if (typeof arg != "number") {
      throw new Error("invalid int32: " + typeof arg);
    }
    if (!Number.isInteger(arg) || arg > INT32_MAX || arg < INT32_MIN)
      throw new Error("invalid int32: " + arg);
  }
  function assertUInt32(arg) {
    if (typeof arg == "string") {
      arg = Number(arg);
    } else if (typeof arg != "number") {
      throw new Error("invalid uint32: " + typeof arg);
    }
    if (!Number.isInteger(arg) || arg > UINT32_MAX || arg < 0)
      throw new Error("invalid uint32: " + arg);
  }
  function assertFloat32(arg) {
    if (typeof arg == "string") {
      const o = arg;
      arg = Number(arg);
      if (Number.isNaN(arg) && o !== "NaN") {
        throw new Error("invalid float32: " + o);
      }
    } else if (typeof arg != "number") {
      throw new Error("invalid float32: " + typeof arg);
    }
    if (Number.isFinite(arg) && (arg > FLOAT32_MAX || arg < FLOAT32_MIN))
      throw new Error("invalid float32: " + arg);
  }

  // <eztb>/packages/sdk/src/generated/CommonReq.ts
  function createBaseCommonReq() {
    return {
      ClientType: 0,
      ClientVersion: "",
      ClientId: "",
      apid: "",
      PhoneImei: "",
      from: "",
      cuid: "",
      Timestamp: "0",
      model: "",
      BDUSS: "",
      tbs: "",
      netType: 0,
      subappType: "",
      PhoneNewimei: "",
      ka: "",
      mApi: "",
      mLogid: "",
      mCost: "",
      mResult: "",
      mSizeU: "",
      mSizeD: "",
      smallflow: "",
      sign: "",
      pversion: "",
      OsVersion: "",
      brand: "",
      brandType: "",
      legoLibVersion: "",
      applist: "",
      stoken: "",
      zId: "",
      cuidGalaxy2: "",
      cuidGid: "",
      oaid: "",
      c3Aid: "",
      sampleId: "",
      scrW: 0,
      scrH: 0,
      scrDip: 0,
      qType: 0,
      isTeenager: 0,
      sdkVer: "",
      frameworkVer: "",
      nawsGameVer: "",
      idfa: "",
      diac: "",
      activeTimestamp: "0",
      firstInstallTime: "0",
      lastUpdateTime: "0",
      eventDay: "",
      androidId: "",
      cmode: 0,
      startScheme: "",
      startType: 0,
      shoubaiCuid: "",
      mac: "",
      idfv: "",
      extra: "",
      userAgent: "",
      personalizedRecSwitch: 0,
      iemi: "",
      iemiwen: "",
      cam: "",
      afdi: "",
      diDiordna: "",
      vfdi: "",
      deviceScore: "",
      pureMode: 0,
      xcxMode: 0,
      ledom: "",
      diao: "",
      noisrevSo: "",
      dnarb: "",
      epytDnarb: "",
      wRcs: "",
      hRcs: "",
      pidRcs: "",
      needDecrypt: 0,
      needCamDecrypt: 0
    };
  }
  var CommonReq = {
    encode(message, writer = new BinaryWriter()) {
      if (message.ClientType !== 0) {
        writer.uint32(8).int32(message.ClientType);
      }
      if (message.ClientVersion !== "") {
        writer.uint32(18).string(message.ClientVersion);
      }
      if (message.ClientId !== "") {
        writer.uint32(26).string(message.ClientId);
      }
      if (message.apid !== "") {
        writer.uint32(34).string(message.apid);
      }
      if (message.PhoneImei !== "") {
        writer.uint32(42).string(message.PhoneImei);
      }
      if (message.from !== "") {
        writer.uint32(50).string(message.from);
      }
      if (message.cuid !== "") {
        writer.uint32(58).string(message.cuid);
      }
      if (message.Timestamp !== "0") {
        writer.uint32(64).int64(message.Timestamp);
      }
      if (message.model !== "") {
        writer.uint32(74).string(message.model);
      }
      if (message.BDUSS !== "") {
        writer.uint32(82).string(message.BDUSS);
      }
      if (message.tbs !== "") {
        writer.uint32(90).string(message.tbs);
      }
      if (message.netType !== 0) {
        writer.uint32(96).int32(message.netType);
      }
      if (message.subappType !== "") {
        writer.uint32(106).string(message.subappType);
      }
      if (message.PhoneNewimei !== "") {
        writer.uint32(114).string(message.PhoneNewimei);
      }
      if (message.ka !== "") {
        writer.uint32(122).string(message.ka);
      }
      if (message.mApi !== "") {
        writer.uint32(130).string(message.mApi);
      }
      if (message.mLogid !== "") {
        writer.uint32(138).string(message.mLogid);
      }
      if (message.mCost !== "") {
        writer.uint32(146).string(message.mCost);
      }
      if (message.mResult !== "") {
        writer.uint32(154).string(message.mResult);
      }
      if (message.mSizeU !== "") {
        writer.uint32(162).string(message.mSizeU);
      }
      if (message.mSizeD !== "") {
        writer.uint32(170).string(message.mSizeD);
      }
      if (message.smallflow !== "") {
        writer.uint32(178).string(message.smallflow);
      }
      if (message.sign !== "") {
        writer.uint32(186).string(message.sign);
      }
      if (message.pversion !== "") {
        writer.uint32(194).string(message.pversion);
      }
      if (message.OsVersion !== "") {
        writer.uint32(202).string(message.OsVersion);
      }
      if (message.brand !== "") {
        writer.uint32(210).string(message.brand);
      }
      if (message.brandType !== "") {
        writer.uint32(218).string(message.brandType);
      }
      if (message.legoLibVersion !== "") {
        writer.uint32(226).string(message.legoLibVersion);
      }
      if (message.applist !== "") {
        writer.uint32(234).string(message.applist);
      }
      if (message.stoken !== "") {
        writer.uint32(242).string(message.stoken);
      }
      if (message.zId !== "") {
        writer.uint32(250).string(message.zId);
      }
      if (message.cuidGalaxy2 !== "") {
        writer.uint32(258).string(message.cuidGalaxy2);
      }
      if (message.cuidGid !== "") {
        writer.uint32(266).string(message.cuidGid);
      }
      if (message.oaid !== "") {
        writer.uint32(274).string(message.oaid);
      }
      if (message.c3Aid !== "") {
        writer.uint32(282).string(message.c3Aid);
      }
      if (message.sampleId !== "") {
        writer.uint32(290).string(message.sampleId);
      }
      if (message.scrW !== 0) {
        writer.uint32(296).int32(message.scrW);
      }
      if (message.scrH !== 0) {
        writer.uint32(304).int32(message.scrH);
      }
      if (message.scrDip !== 0) {
        writer.uint32(313).double(message.scrDip);
      }
      if (message.qType !== 0) {
        writer.uint32(320).int32(message.qType);
      }
      if (message.isTeenager !== 0) {
        writer.uint32(328).int32(message.isTeenager);
      }
      if (message.sdkVer !== "") {
        writer.uint32(338).string(message.sdkVer);
      }
      if (message.frameworkVer !== "") {
        writer.uint32(346).string(message.frameworkVer);
      }
      if (message.nawsGameVer !== "") {
        writer.uint32(354).string(message.nawsGameVer);
      }
      if (message.idfa !== "") {
        writer.uint32(362).string(message.idfa);
      }
      if (message.diac !== "") {
        writer.uint32(370).string(message.diac);
      }
      if (message.activeTimestamp !== "0") {
        writer.uint32(392).int64(message.activeTimestamp);
      }
      if (message.firstInstallTime !== "0") {
        writer.uint32(400).int64(message.firstInstallTime);
      }
      if (message.lastUpdateTime !== "0") {
        writer.uint32(408).int64(message.lastUpdateTime);
      }
      if (message.eventDay !== "") {
        writer.uint32(426).string(message.eventDay);
      }
      if (message.androidId !== "") {
        writer.uint32(434).string(message.androidId);
      }
      if (message.cmode !== 0) {
        writer.uint32(440).int32(message.cmode);
      }
      if (message.startScheme !== "") {
        writer.uint32(450).string(message.startScheme);
      }
      if (message.startType !== 0) {
        writer.uint32(456).int32(message.startType);
      }
      if (message.shoubaiCuid !== "") {
        writer.uint32(466).string(message.shoubaiCuid);
      }
      if (message.mac !== "") {
        writer.uint32(474).string(message.mac);
      }
      if (message.idfv !== "") {
        writer.uint32(482).string(message.idfv);
      }
      if (message.extra !== "") {
        writer.uint32(490).string(message.extra);
      }
      if (message.userAgent !== "") {
        writer.uint32(498).string(message.userAgent);
      }
      if (message.personalizedRecSwitch !== 0) {
        writer.uint32(504).int32(message.personalizedRecSwitch);
      }
      if (message.iemi !== "") {
        writer.uint32(514).string(message.iemi);
      }
      if (message.iemiwen !== "") {
        writer.uint32(522).string(message.iemiwen);
      }
      if (message.cam !== "") {
        writer.uint32(530).string(message.cam);
      }
      if (message.afdi !== "") {
        writer.uint32(538).string(message.afdi);
      }
      if (message.diDiordna !== "") {
        writer.uint32(546).string(message.diDiordna);
      }
      if (message.vfdi !== "") {
        writer.uint32(554).string(message.vfdi);
      }
      if (message.deviceScore !== "") {
        writer.uint32(562).string(message.deviceScore);
      }
      if (message.pureMode !== 0) {
        writer.uint32(568).int32(message.pureMode);
      }
      if (message.xcxMode !== 0) {
        writer.uint32(576).int32(message.xcxMode);
      }
      if (message.ledom !== "") {
        writer.uint32(586).string(message.ledom);
      }
      if (message.diao !== "") {
        writer.uint32(594).string(message.diao);
      }
      if (message.noisrevSo !== "") {
        writer.uint32(602).string(message.noisrevSo);
      }
      if (message.dnarb !== "") {
        writer.uint32(610).string(message.dnarb);
      }
      if (message.epytDnarb !== "") {
        writer.uint32(618).string(message.epytDnarb);
      }
      if (message.wRcs !== "") {
        writer.uint32(626).string(message.wRcs);
      }
      if (message.hRcs !== "") {
        writer.uint32(634).string(message.hRcs);
      }
      if (message.pidRcs !== "") {
        writer.uint32(642).string(message.pidRcs);
      }
      if (message.needDecrypt !== 0) {
        writer.uint32(648).int32(message.needDecrypt);
      }
      if (message.needCamDecrypt !== 0) {
        writer.uint32(656).int32(message.needCamDecrypt);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseCommonReq();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.ClientType = reader.int32();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.ClientVersion = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.ClientId = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }
            message.apid = reader.string();
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }
            message.PhoneImei = reader.string();
            continue;
          }
          case 6: {
            if (tag !== 50) {
              break;
            }
            message.from = reader.string();
            continue;
          }
          case 7: {
            if (tag !== 58) {
              break;
            }
            message.cuid = reader.string();
            continue;
          }
          case 8: {
            if (tag !== 64) {
              break;
            }
            message.Timestamp = reader.int64().toString();
            continue;
          }
          case 9: {
            if (tag !== 74) {
              break;
            }
            message.model = reader.string();
            continue;
          }
          case 10: {
            if (tag !== 82) {
              break;
            }
            message.BDUSS = reader.string();
            continue;
          }
          case 11: {
            if (tag !== 90) {
              break;
            }
            message.tbs = reader.string();
            continue;
          }
          case 12: {
            if (tag !== 96) {
              break;
            }
            message.netType = reader.int32();
            continue;
          }
          case 13: {
            if (tag !== 106) {
              break;
            }
            message.subappType = reader.string();
            continue;
          }
          case 14: {
            if (tag !== 114) {
              break;
            }
            message.PhoneNewimei = reader.string();
            continue;
          }
          case 15: {
            if (tag !== 122) {
              break;
            }
            message.ka = reader.string();
            continue;
          }
          case 16: {
            if (tag !== 130) {
              break;
            }
            message.mApi = reader.string();
            continue;
          }
          case 17: {
            if (tag !== 138) {
              break;
            }
            message.mLogid = reader.string();
            continue;
          }
          case 18: {
            if (tag !== 146) {
              break;
            }
            message.mCost = reader.string();
            continue;
          }
          case 19: {
            if (tag !== 154) {
              break;
            }
            message.mResult = reader.string();
            continue;
          }
          case 20: {
            if (tag !== 162) {
              break;
            }
            message.mSizeU = reader.string();
            continue;
          }
          case 21: {
            if (tag !== 170) {
              break;
            }
            message.mSizeD = reader.string();
            continue;
          }
          case 22: {
            if (tag !== 178) {
              break;
            }
            message.smallflow = reader.string();
            continue;
          }
          case 23: {
            if (tag !== 186) {
              break;
            }
            message.sign = reader.string();
            continue;
          }
          case 24: {
            if (tag !== 194) {
              break;
            }
            message.pversion = reader.string();
            continue;
          }
          case 25: {
            if (tag !== 202) {
              break;
            }
            message.OsVersion = reader.string();
            continue;
          }
          case 26: {
            if (tag !== 210) {
              break;
            }
            message.brand = reader.string();
            continue;
          }
          case 27: {
            if (tag !== 218) {
              break;
            }
            message.brandType = reader.string();
            continue;
          }
          case 28: {
            if (tag !== 226) {
              break;
            }
            message.legoLibVersion = reader.string();
            continue;
          }
          case 29: {
            if (tag !== 234) {
              break;
            }
            message.applist = reader.string();
            continue;
          }
          case 30: {
            if (tag !== 242) {
              break;
            }
            message.stoken = reader.string();
            continue;
          }
          case 31: {
            if (tag !== 250) {
              break;
            }
            message.zId = reader.string();
            continue;
          }
          case 32: {
            if (tag !== 258) {
              break;
            }
            message.cuidGalaxy2 = reader.string();
            continue;
          }
          case 33: {
            if (tag !== 266) {
              break;
            }
            message.cuidGid = reader.string();
            continue;
          }
          case 34: {
            if (tag !== 274) {
              break;
            }
            message.oaid = reader.string();
            continue;
          }
          case 35: {
            if (tag !== 282) {
              break;
            }
            message.c3Aid = reader.string();
            continue;
          }
          case 36: {
            if (tag !== 290) {
              break;
            }
            message.sampleId = reader.string();
            continue;
          }
          case 37: {
            if (tag !== 296) {
              break;
            }
            message.scrW = reader.int32();
            continue;
          }
          case 38: {
            if (tag !== 304) {
              break;
            }
            message.scrH = reader.int32();
            continue;
          }
          case 39: {
            if (tag !== 313) {
              break;
            }
            message.scrDip = reader.double();
            continue;
          }
          case 40: {
            if (tag !== 320) {
              break;
            }
            message.qType = reader.int32();
            continue;
          }
          case 41: {
            if (tag !== 328) {
              break;
            }
            message.isTeenager = reader.int32();
            continue;
          }
          case 42: {
            if (tag !== 338) {
              break;
            }
            message.sdkVer = reader.string();
            continue;
          }
          case 43: {
            if (tag !== 346) {
              break;
            }
            message.frameworkVer = reader.string();
            continue;
          }
          case 44: {
            if (tag !== 354) {
              break;
            }
            message.nawsGameVer = reader.string();
            continue;
          }
          case 45: {
            if (tag !== 362) {
              break;
            }
            message.idfa = reader.string();
            continue;
          }
          case 46: {
            if (tag !== 370) {
              break;
            }
            message.diac = reader.string();
            continue;
          }
          case 49: {
            if (tag !== 392) {
              break;
            }
            message.activeTimestamp = reader.int64().toString();
            continue;
          }
          case 50: {
            if (tag !== 400) {
              break;
            }
            message.firstInstallTime = reader.int64().toString();
            continue;
          }
          case 51: {
            if (tag !== 408) {
              break;
            }
            message.lastUpdateTime = reader.int64().toString();
            continue;
          }
          case 53: {
            if (tag !== 426) {
              break;
            }
            message.eventDay = reader.string();
            continue;
          }
          case 54: {
            if (tag !== 434) {
              break;
            }
            message.androidId = reader.string();
            continue;
          }
          case 55: {
            if (tag !== 440) {
              break;
            }
            message.cmode = reader.int32();
            continue;
          }
          case 56: {
            if (tag !== 450) {
              break;
            }
            message.startScheme = reader.string();
            continue;
          }
          case 57: {
            if (tag !== 456) {
              break;
            }
            message.startType = reader.int32();
            continue;
          }
          case 58: {
            if (tag !== 466) {
              break;
            }
            message.shoubaiCuid = reader.string();
            continue;
          }
          case 59: {
            if (tag !== 474) {
              break;
            }
            message.mac = reader.string();
            continue;
          }
          case 60: {
            if (tag !== 482) {
              break;
            }
            message.idfv = reader.string();
            continue;
          }
          case 61: {
            if (tag !== 490) {
              break;
            }
            message.extra = reader.string();
            continue;
          }
          case 62: {
            if (tag !== 498) {
              break;
            }
            message.userAgent = reader.string();
            continue;
          }
          case 63: {
            if (tag !== 504) {
              break;
            }
            message.personalizedRecSwitch = reader.int32();
            continue;
          }
          case 64: {
            if (tag !== 514) {
              break;
            }
            message.iemi = reader.string();
            continue;
          }
          case 65: {
            if (tag !== 522) {
              break;
            }
            message.iemiwen = reader.string();
            continue;
          }
          case 66: {
            if (tag !== 530) {
              break;
            }
            message.cam = reader.string();
            continue;
          }
          case 67: {
            if (tag !== 538) {
              break;
            }
            message.afdi = reader.string();
            continue;
          }
          case 68: {
            if (tag !== 546) {
              break;
            }
            message.diDiordna = reader.string();
            continue;
          }
          case 69: {
            if (tag !== 554) {
              break;
            }
            message.vfdi = reader.string();
            continue;
          }
          case 70: {
            if (tag !== 562) {
              break;
            }
            message.deviceScore = reader.string();
            continue;
          }
          case 71: {
            if (tag !== 568) {
              break;
            }
            message.pureMode = reader.int32();
            continue;
          }
          case 72: {
            if (tag !== 576) {
              break;
            }
            message.xcxMode = reader.int32();
            continue;
          }
          case 73: {
            if (tag !== 586) {
              break;
            }
            message.ledom = reader.string();
            continue;
          }
          case 74: {
            if (tag !== 594) {
              break;
            }
            message.diao = reader.string();
            continue;
          }
          case 75: {
            if (tag !== 602) {
              break;
            }
            message.noisrevSo = reader.string();
            continue;
          }
          case 76: {
            if (tag !== 610) {
              break;
            }
            message.dnarb = reader.string();
            continue;
          }
          case 77: {
            if (tag !== 618) {
              break;
            }
            message.epytDnarb = reader.string();
            continue;
          }
          case 78: {
            if (tag !== 626) {
              break;
            }
            message.wRcs = reader.string();
            continue;
          }
          case 79: {
            if (tag !== 634) {
              break;
            }
            message.hRcs = reader.string();
            continue;
          }
          case 80: {
            if (tag !== 642) {
              break;
            }
            message.pidRcs = reader.string();
            continue;
          }
          case 81: {
            if (tag !== 648) {
              break;
            }
            message.needDecrypt = reader.int32();
            continue;
          }
          case 82: {
            if (tag !== 656) {
              break;
            }
            message.needCamDecrypt = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        ClientType: isSet(object.ClientType) ? globalThis.Number(object.ClientType) : isSet(object._client_type) ? globalThis.Number(object._client_type) : 0,
        ClientVersion: isSet(object.ClientVersion) ? globalThis.String(object.ClientVersion) : isSet(object._client_version) ? globalThis.String(object._client_version) : "",
        ClientId: isSet(object.ClientId) ? globalThis.String(object.ClientId) : isSet(object._client_id) ? globalThis.String(object._client_id) : "",
        apid: isSet(object.apid) ? globalThis.String(object.apid) : "",
        PhoneImei: isSet(object.PhoneImei) ? globalThis.String(object.PhoneImei) : isSet(object._phone_imei) ? globalThis.String(object._phone_imei) : "",
        from: isSet(object.from) ? globalThis.String(object.from) : "",
        cuid: isSet(object.cuid) ? globalThis.String(object.cuid) : "",
        Timestamp: isSet(object.Timestamp) ? globalThis.String(object.Timestamp) : isSet(object._timestamp) ? globalThis.String(object._timestamp) : "0",
        model: isSet(object.model) ? globalThis.String(object.model) : "",
        BDUSS: isSet(object.BDUSS) ? globalThis.String(object.BDUSS) : "",
        tbs: isSet(object.tbs) ? globalThis.String(object.tbs) : "",
        netType: isSet(object.netType) ? globalThis.Number(object.netType) : isSet(object.net_type) ? globalThis.Number(object.net_type) : 0,
        subappType: isSet(object.subappType) ? globalThis.String(object.subappType) : isSet(object.subapp_type) ? globalThis.String(object.subapp_type) : "",
        PhoneNewimei: isSet(object.PhoneNewimei) ? globalThis.String(object.PhoneNewimei) : isSet(object._phone_newimei) ? globalThis.String(object._phone_newimei) : "",
        ka: isSet(object.ka) ? globalThis.String(object.ka) : "",
        mApi: isSet(object.mApi) ? globalThis.String(object.mApi) : isSet(object.m_api) ? globalThis.String(object.m_api) : "",
        mLogid: isSet(object.mLogid) ? globalThis.String(object.mLogid) : isSet(object.m_logid) ? globalThis.String(object.m_logid) : "",
        mCost: isSet(object.mCost) ? globalThis.String(object.mCost) : isSet(object.m_cost) ? globalThis.String(object.m_cost) : "",
        mResult: isSet(object.mResult) ? globalThis.String(object.mResult) : isSet(object.m_result) ? globalThis.String(object.m_result) : "",
        mSizeU: isSet(object.mSizeU) ? globalThis.String(object.mSizeU) : isSet(object.m_size_u) ? globalThis.String(object.m_size_u) : "",
        mSizeD: isSet(object.mSizeD) ? globalThis.String(object.mSizeD) : isSet(object.m_size_d) ? globalThis.String(object.m_size_d) : "",
        smallflow: isSet(object.smallflow) ? globalThis.String(object.smallflow) : "",
        sign: isSet(object.sign) ? globalThis.String(object.sign) : "",
        pversion: isSet(object.pversion) ? globalThis.String(object.pversion) : "",
        OsVersion: isSet(object.OsVersion) ? globalThis.String(object.OsVersion) : isSet(object._os_version) ? globalThis.String(object._os_version) : "",
        brand: isSet(object.brand) ? globalThis.String(object.brand) : "",
        brandType: isSet(object.brandType) ? globalThis.String(object.brandType) : isSet(object.brand_type) ? globalThis.String(object.brand_type) : "",
        legoLibVersion: isSet(object.legoLibVersion) ? globalThis.String(object.legoLibVersion) : isSet(object.lego_lib_version) ? globalThis.String(object.lego_lib_version) : "",
        applist: isSet(object.applist) ? globalThis.String(object.applist) : "",
        stoken: isSet(object.stoken) ? globalThis.String(object.stoken) : "",
        zId: isSet(object.zId) ? globalThis.String(object.zId) : isSet(object.z_id) ? globalThis.String(object.z_id) : "",
        cuidGalaxy2: isSet(object.cuidGalaxy2) ? globalThis.String(object.cuidGalaxy2) : isSet(object.cuid_galaxy2) ? globalThis.String(object.cuid_galaxy2) : "",
        cuidGid: isSet(object.cuidGid) ? globalThis.String(object.cuidGid) : isSet(object.cuid_gid) ? globalThis.String(object.cuid_gid) : "",
        oaid: isSet(object.oaid) ? globalThis.String(object.oaid) : "",
        c3Aid: isSet(object.c3Aid) ? globalThis.String(object.c3Aid) : isSet(object.c3_aid) ? globalThis.String(object.c3_aid) : "",
        sampleId: isSet(object.sampleId) ? globalThis.String(object.sampleId) : isSet(object.sample_id) ? globalThis.String(object.sample_id) : "",
        scrW: isSet(object.scrW) ? globalThis.Number(object.scrW) : isSet(object.scr_w) ? globalThis.Number(object.scr_w) : 0,
        scrH: isSet(object.scrH) ? globalThis.Number(object.scrH) : isSet(object.scr_h) ? globalThis.Number(object.scr_h) : 0,
        scrDip: isSet(object.scrDip) ? globalThis.Number(object.scrDip) : isSet(object.scr_dip) ? globalThis.Number(object.scr_dip) : 0,
        qType: isSet(object.qType) ? globalThis.Number(object.qType) : isSet(object.q_type) ? globalThis.Number(object.q_type) : 0,
        isTeenager: isSet(object.isTeenager) ? globalThis.Number(object.isTeenager) : isSet(object.is_teenager) ? globalThis.Number(object.is_teenager) : 0,
        sdkVer: isSet(object.sdkVer) ? globalThis.String(object.sdkVer) : isSet(object.sdk_ver) ? globalThis.String(object.sdk_ver) : "",
        frameworkVer: isSet(object.frameworkVer) ? globalThis.String(object.frameworkVer) : isSet(object.framework_ver) ? globalThis.String(object.framework_ver) : "",
        nawsGameVer: isSet(object.nawsGameVer) ? globalThis.String(object.nawsGameVer) : isSet(object.naws_game_ver) ? globalThis.String(object.naws_game_ver) : "",
        idfa: isSet(object.idfa) ? globalThis.String(object.idfa) : "",
        diac: isSet(object.diac) ? globalThis.String(object.diac) : "",
        activeTimestamp: isSet(object.activeTimestamp) ? globalThis.String(object.activeTimestamp) : isSet(object.active_timestamp) ? globalThis.String(object.active_timestamp) : "0",
        firstInstallTime: isSet(object.firstInstallTime) ? globalThis.String(object.firstInstallTime) : isSet(object.first_install_time) ? globalThis.String(object.first_install_time) : "0",
        lastUpdateTime: isSet(object.lastUpdateTime) ? globalThis.String(object.lastUpdateTime) : isSet(object.last_update_time) ? globalThis.String(object.last_update_time) : "0",
        eventDay: isSet(object.eventDay) ? globalThis.String(object.eventDay) : isSet(object.event_day) ? globalThis.String(object.event_day) : "",
        androidId: isSet(object.androidId) ? globalThis.String(object.androidId) : isSet(object.android_id) ? globalThis.String(object.android_id) : "",
        cmode: isSet(object.cmode) ? globalThis.Number(object.cmode) : 0,
        startScheme: isSet(object.startScheme) ? globalThis.String(object.startScheme) : isSet(object.start_scheme) ? globalThis.String(object.start_scheme) : "",
        startType: isSet(object.startType) ? globalThis.Number(object.startType) : isSet(object.start_type) ? globalThis.Number(object.start_type) : 0,
        shoubaiCuid: isSet(object.shoubaiCuid) ? globalThis.String(object.shoubaiCuid) : isSet(object.shoubai_cuid) ? globalThis.String(object.shoubai_cuid) : "",
        mac: isSet(object.mac) ? globalThis.String(object.mac) : "",
        idfv: isSet(object.idfv) ? globalThis.String(object.idfv) : "",
        extra: isSet(object.extra) ? globalThis.String(object.extra) : "",
        userAgent: isSet(object.userAgent) ? globalThis.String(object.userAgent) : isSet(object.user_agent) ? globalThis.String(object.user_agent) : "",
        personalizedRecSwitch: isSet(object.personalizedRecSwitch) ? globalThis.Number(object.personalizedRecSwitch) : isSet(object.personalized_rec_switch) ? globalThis.Number(object.personalized_rec_switch) : 0,
        iemi: isSet(object.iemi) ? globalThis.String(object.iemi) : "",
        iemiwen: isSet(object.iemiwen) ? globalThis.String(object.iemiwen) : "",
        cam: isSet(object.cam) ? globalThis.String(object.cam) : "",
        afdi: isSet(object.afdi) ? globalThis.String(object.afdi) : "",
        diDiordna: isSet(object.diDiordna) ? globalThis.String(object.diDiordna) : isSet(object.di_diordna) ? globalThis.String(object.di_diordna) : "",
        vfdi: isSet(object.vfdi) ? globalThis.String(object.vfdi) : "",
        deviceScore: isSet(object.deviceScore) ? globalThis.String(object.deviceScore) : isSet(object.device_score) ? globalThis.String(object.device_score) : "",
        pureMode: isSet(object.pureMode) ? globalThis.Number(object.pureMode) : isSet(object.pure_mode) ? globalThis.Number(object.pure_mode) : 0,
        xcxMode: isSet(object.xcxMode) ? globalThis.Number(object.xcxMode) : isSet(object.xcx_mode) ? globalThis.Number(object.xcx_mode) : 0,
        ledom: isSet(object.ledom) ? globalThis.String(object.ledom) : "",
        diao: isSet(object.diao) ? globalThis.String(object.diao) : "",
        noisrevSo: isSet(object.noisrevSo) ? globalThis.String(object.noisrevSo) : isSet(object.noisrev_so) ? globalThis.String(object.noisrev_so) : "",
        dnarb: isSet(object.dnarb) ? globalThis.String(object.dnarb) : "",
        epytDnarb: isSet(object.epytDnarb) ? globalThis.String(object.epytDnarb) : isSet(object.epyt_dnarb) ? globalThis.String(object.epyt_dnarb) : "",
        wRcs: isSet(object.wRcs) ? globalThis.String(object.wRcs) : isSet(object.w_rcs) ? globalThis.String(object.w_rcs) : "",
        hRcs: isSet(object.hRcs) ? globalThis.String(object.hRcs) : isSet(object.h_rcs) ? globalThis.String(object.h_rcs) : "",
        pidRcs: isSet(object.pidRcs) ? globalThis.String(object.pidRcs) : isSet(object.pid_rcs) ? globalThis.String(object.pid_rcs) : "",
        needDecrypt: isSet(object.needDecrypt) ? globalThis.Number(object.needDecrypt) : isSet(object.need_decrypt) ? globalThis.Number(object.need_decrypt) : 0,
        needCamDecrypt: isSet(object.needCamDecrypt) ? globalThis.Number(object.needCamDecrypt) : isSet(object.need_cam_decrypt) ? globalThis.Number(object.need_cam_decrypt) : 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.ClientType !== 0) {
        obj.ClientType = Math.round(message.ClientType);
      }
      if (message.ClientVersion !== "") {
        obj.ClientVersion = message.ClientVersion;
      }
      if (message.ClientId !== "") {
        obj.ClientId = message.ClientId;
      }
      if (message.apid !== "") {
        obj.apid = message.apid;
      }
      if (message.PhoneImei !== "") {
        obj.PhoneImei = message.PhoneImei;
      }
      if (message.from !== "") {
        obj.from = message.from;
      }
      if (message.cuid !== "") {
        obj.cuid = message.cuid;
      }
      if (message.Timestamp !== "0") {
        obj.Timestamp = message.Timestamp;
      }
      if (message.model !== "") {
        obj.model = message.model;
      }
      if (message.BDUSS !== "") {
        obj.BDUSS = message.BDUSS;
      }
      if (message.tbs !== "") {
        obj.tbs = message.tbs;
      }
      if (message.netType !== 0) {
        obj.netType = Math.round(message.netType);
      }
      if (message.subappType !== "") {
        obj.subappType = message.subappType;
      }
      if (message.PhoneNewimei !== "") {
        obj.PhoneNewimei = message.PhoneNewimei;
      }
      if (message.ka !== "") {
        obj.ka = message.ka;
      }
      if (message.mApi !== "") {
        obj.mApi = message.mApi;
      }
      if (message.mLogid !== "") {
        obj.mLogid = message.mLogid;
      }
      if (message.mCost !== "") {
        obj.mCost = message.mCost;
      }
      if (message.mResult !== "") {
        obj.mResult = message.mResult;
      }
      if (message.mSizeU !== "") {
        obj.mSizeU = message.mSizeU;
      }
      if (message.mSizeD !== "") {
        obj.mSizeD = message.mSizeD;
      }
      if (message.smallflow !== "") {
        obj.smallflow = message.smallflow;
      }
      if (message.sign !== "") {
        obj.sign = message.sign;
      }
      if (message.pversion !== "") {
        obj.pversion = message.pversion;
      }
      if (message.OsVersion !== "") {
        obj.OsVersion = message.OsVersion;
      }
      if (message.brand !== "") {
        obj.brand = message.brand;
      }
      if (message.brandType !== "") {
        obj.brandType = message.brandType;
      }
      if (message.legoLibVersion !== "") {
        obj.legoLibVersion = message.legoLibVersion;
      }
      if (message.applist !== "") {
        obj.applist = message.applist;
      }
      if (message.stoken !== "") {
        obj.stoken = message.stoken;
      }
      if (message.zId !== "") {
        obj.zId = message.zId;
      }
      if (message.cuidGalaxy2 !== "") {
        obj.cuidGalaxy2 = message.cuidGalaxy2;
      }
      if (message.cuidGid !== "") {
        obj.cuidGid = message.cuidGid;
      }
      if (message.oaid !== "") {
        obj.oaid = message.oaid;
      }
      if (message.c3Aid !== "") {
        obj.c3Aid = message.c3Aid;
      }
      if (message.sampleId !== "") {
        obj.sampleId = message.sampleId;
      }
      if (message.scrW !== 0) {
        obj.scrW = Math.round(message.scrW);
      }
      if (message.scrH !== 0) {
        obj.scrH = Math.round(message.scrH);
      }
      if (message.scrDip !== 0) {
        obj.scrDip = message.scrDip;
      }
      if (message.qType !== 0) {
        obj.qType = Math.round(message.qType);
      }
      if (message.isTeenager !== 0) {
        obj.isTeenager = Math.round(message.isTeenager);
      }
      if (message.sdkVer !== "") {
        obj.sdkVer = message.sdkVer;
      }
      if (message.frameworkVer !== "") {
        obj.frameworkVer = message.frameworkVer;
      }
      if (message.nawsGameVer !== "") {
        obj.nawsGameVer = message.nawsGameVer;
      }
      if (message.idfa !== "") {
        obj.idfa = message.idfa;
      }
      if (message.diac !== "") {
        obj.diac = message.diac;
      }
      if (message.activeTimestamp !== "0") {
        obj.activeTimestamp = message.activeTimestamp;
      }
      if (message.firstInstallTime !== "0") {
        obj.firstInstallTime = message.firstInstallTime;
      }
      if (message.lastUpdateTime !== "0") {
        obj.lastUpdateTime = message.lastUpdateTime;
      }
      if (message.eventDay !== "") {
        obj.eventDay = message.eventDay;
      }
      if (message.androidId !== "") {
        obj.androidId = message.androidId;
      }
      if (message.cmode !== 0) {
        obj.cmode = Math.round(message.cmode);
      }
      if (message.startScheme !== "") {
        obj.startScheme = message.startScheme;
      }
      if (message.startType !== 0) {
        obj.startType = Math.round(message.startType);
      }
      if (message.shoubaiCuid !== "") {
        obj.shoubaiCuid = message.shoubaiCuid;
      }
      if (message.mac !== "") {
        obj.mac = message.mac;
      }
      if (message.idfv !== "") {
        obj.idfv = message.idfv;
      }
      if (message.extra !== "") {
        obj.extra = message.extra;
      }
      if (message.userAgent !== "") {
        obj.userAgent = message.userAgent;
      }
      if (message.personalizedRecSwitch !== 0) {
        obj.personalizedRecSwitch = Math.round(message.personalizedRecSwitch);
      }
      if (message.iemi !== "") {
        obj.iemi = message.iemi;
      }
      if (message.iemiwen !== "") {
        obj.iemiwen = message.iemiwen;
      }
      if (message.cam !== "") {
        obj.cam = message.cam;
      }
      if (message.afdi !== "") {
        obj.afdi = message.afdi;
      }
      if (message.diDiordna !== "") {
        obj.diDiordna = message.diDiordna;
      }
      if (message.vfdi !== "") {
        obj.vfdi = message.vfdi;
      }
      if (message.deviceScore !== "") {
        obj.deviceScore = message.deviceScore;
      }
      if (message.pureMode !== 0) {
        obj.pureMode = Math.round(message.pureMode);
      }
      if (message.xcxMode !== 0) {
        obj.xcxMode = Math.round(message.xcxMode);
      }
      if (message.ledom !== "") {
        obj.ledom = message.ledom;
      }
      if (message.diao !== "") {
        obj.diao = message.diao;
      }
      if (message.noisrevSo !== "") {
        obj.noisrevSo = message.noisrevSo;
      }
      if (message.dnarb !== "") {
        obj.dnarb = message.dnarb;
      }
      if (message.epytDnarb !== "") {
        obj.epytDnarb = message.epytDnarb;
      }
      if (message.wRcs !== "") {
        obj.wRcs = message.wRcs;
      }
      if (message.hRcs !== "") {
        obj.hRcs = message.hRcs;
      }
      if (message.pidRcs !== "") {
        obj.pidRcs = message.pidRcs;
      }
      if (message.needDecrypt !== 0) {
        obj.needDecrypt = Math.round(message.needDecrypt);
      }
      if (message.needCamDecrypt !== 0) {
        obj.needCamDecrypt = Math.round(message.needCamDecrypt);
      }
      return obj;
    },
    create(base) {
      return CommonReq.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseCommonReq();
      message.ClientType = object.ClientType ?? 0;
      message.ClientVersion = object.ClientVersion ?? "";
      message.ClientId = object.ClientId ?? "";
      message.apid = object.apid ?? "";
      message.PhoneImei = object.PhoneImei ?? "";
      message.from = object.from ?? "";
      message.cuid = object.cuid ?? "";
      message.Timestamp = object.Timestamp ?? "0";
      message.model = object.model ?? "";
      message.BDUSS = object.BDUSS ?? "";
      message.tbs = object.tbs ?? "";
      message.netType = object.netType ?? 0;
      message.subappType = object.subappType ?? "";
      message.PhoneNewimei = object.PhoneNewimei ?? "";
      message.ka = object.ka ?? "";
      message.mApi = object.mApi ?? "";
      message.mLogid = object.mLogid ?? "";
      message.mCost = object.mCost ?? "";
      message.mResult = object.mResult ?? "";
      message.mSizeU = object.mSizeU ?? "";
      message.mSizeD = object.mSizeD ?? "";
      message.smallflow = object.smallflow ?? "";
      message.sign = object.sign ?? "";
      message.pversion = object.pversion ?? "";
      message.OsVersion = object.OsVersion ?? "";
      message.brand = object.brand ?? "";
      message.brandType = object.brandType ?? "";
      message.legoLibVersion = object.legoLibVersion ?? "";
      message.applist = object.applist ?? "";
      message.stoken = object.stoken ?? "";
      message.zId = object.zId ?? "";
      message.cuidGalaxy2 = object.cuidGalaxy2 ?? "";
      message.cuidGid = object.cuidGid ?? "";
      message.oaid = object.oaid ?? "";
      message.c3Aid = object.c3Aid ?? "";
      message.sampleId = object.sampleId ?? "";
      message.scrW = object.scrW ?? 0;
      message.scrH = object.scrH ?? 0;
      message.scrDip = object.scrDip ?? 0;
      message.qType = object.qType ?? 0;
      message.isTeenager = object.isTeenager ?? 0;
      message.sdkVer = object.sdkVer ?? "";
      message.frameworkVer = object.frameworkVer ?? "";
      message.nawsGameVer = object.nawsGameVer ?? "";
      message.idfa = object.idfa ?? "";
      message.diac = object.diac ?? "";
      message.activeTimestamp = object.activeTimestamp ?? "0";
      message.firstInstallTime = object.firstInstallTime ?? "0";
      message.lastUpdateTime = object.lastUpdateTime ?? "0";
      message.eventDay = object.eventDay ?? "";
      message.androidId = object.androidId ?? "";
      message.cmode = object.cmode ?? 0;
      message.startScheme = object.startScheme ?? "";
      message.startType = object.startType ?? 0;
      message.shoubaiCuid = object.shoubaiCuid ?? "";
      message.mac = object.mac ?? "";
      message.idfv = object.idfv ?? "";
      message.extra = object.extra ?? "";
      message.userAgent = object.userAgent ?? "";
      message.personalizedRecSwitch = object.personalizedRecSwitch ?? 0;
      message.iemi = object.iemi ?? "";
      message.iemiwen = object.iemiwen ?? "";
      message.cam = object.cam ?? "";
      message.afdi = object.afdi ?? "";
      message.diDiordna = object.diDiordna ?? "";
      message.vfdi = object.vfdi ?? "";
      message.deviceScore = object.deviceScore ?? "";
      message.pureMode = object.pureMode ?? 0;
      message.xcxMode = object.xcxMode ?? 0;
      message.ledom = object.ledom ?? "";
      message.diao = object.diao ?? "";
      message.noisrevSo = object.noisrevSo ?? "";
      message.dnarb = object.dnarb ?? "";
      message.epytDnarb = object.epytDnarb ?? "";
      message.wRcs = object.wRcs ?? "";
      message.hRcs = object.hRcs ?? "";
      message.pidRcs = object.pidRcs ?? "";
      message.needDecrypt = object.needDecrypt ?? 0;
      message.needCamDecrypt = object.needCamDecrypt ?? 0;
      return message;
    }
  };
  function isSet(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/FrsPageReqIdl.ts
  function createBaseFrsPageReqIdl() {
    return { data: void 0 };
  }
  var FrsPageReqIdl = {
    encode(message, writer = new BinaryWriter()) {
      if (message.data !== void 0) {
        FrsPageReqIdl_DataReq.encode(message.data, writer.uint32(10).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseFrsPageReqIdl();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.data = FrsPageReqIdl_DataReq.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return { data: isSet2(object.data) ? FrsPageReqIdl_DataReq.fromJSON(object.data) : void 0 };
    },
    toJSON(message) {
      const obj = {};
      if (message.data !== void 0) {
        obj.data = FrsPageReqIdl_DataReq.toJSON(message.data);
      }
      return obj;
    },
    create(base) {
      return FrsPageReqIdl.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseFrsPageReqIdl();
      message.data = object.data !== void 0 && object.data !== null ? FrsPageReqIdl_DataReq.fromPartial(object.data) : void 0;
      return message;
    }
  };
  function createBaseFrsPageReqIdl_DataReq() {
    return { common: void 0, kw: "", rn: 0, rnNeed: 0, isGood: 0, cid: 0, pn: 0, sortType: 0 };
  }
  var FrsPageReqIdl_DataReq = {
    encode(message, writer = new BinaryWriter()) {
      if (message.common !== void 0) {
        CommonReq.encode(message.common, writer.uint32(314).fork()).join();
      }
      if (message.kw !== "") {
        writer.uint32(10).string(message.kw);
      }
      if (message.rn !== 0) {
        writer.uint32(16).int32(message.rn);
      }
      if (message.rnNeed !== 0) {
        writer.uint32(24).int32(message.rnNeed);
      }
      if (message.isGood !== 0) {
        writer.uint32(32).int32(message.isGood);
      }
      if (message.cid !== 0) {
        writer.uint32(40).int32(message.cid);
      }
      if (message.pn !== 0) {
        writer.uint32(120).int32(message.pn);
      }
      if (message.sortType !== 0) {
        writer.uint32(376).int32(message.sortType);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseFrsPageReqIdl_DataReq();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 39: {
            if (tag !== 314) {
              break;
            }
            message.common = CommonReq.decode(reader, reader.uint32());
            continue;
          }
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.kw = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.rn = reader.int32();
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }
            message.rnNeed = reader.int32();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }
            message.isGood = reader.int32();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }
            message.cid = reader.int32();
            continue;
          }
          case 15: {
            if (tag !== 120) {
              break;
            }
            message.pn = reader.int32();
            continue;
          }
          case 47: {
            if (tag !== 376) {
              break;
            }
            message.sortType = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        common: isSet2(object.common) ? CommonReq.fromJSON(object.common) : void 0,
        kw: isSet2(object.kw) ? globalThis.String(object.kw) : "",
        rn: isSet2(object.rn) ? globalThis.Number(object.rn) : 0,
        rnNeed: isSet2(object.rnNeed) ? globalThis.Number(object.rnNeed) : isSet2(object.rn_need) ? globalThis.Number(object.rn_need) : 0,
        isGood: isSet2(object.isGood) ? globalThis.Number(object.isGood) : isSet2(object.is_good) ? globalThis.Number(object.is_good) : 0,
        cid: isSet2(object.cid) ? globalThis.Number(object.cid) : 0,
        pn: isSet2(object.pn) ? globalThis.Number(object.pn) : 0,
        sortType: isSet2(object.sortType) ? globalThis.Number(object.sortType) : isSet2(object.sort_type) ? globalThis.Number(object.sort_type) : 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.common !== void 0) {
        obj.common = CommonReq.toJSON(message.common);
      }
      if (message.kw !== "") {
        obj.kw = message.kw;
      }
      if (message.rn !== 0) {
        obj.rn = Math.round(message.rn);
      }
      if (message.rnNeed !== 0) {
        obj.rnNeed = Math.round(message.rnNeed);
      }
      if (message.isGood !== 0) {
        obj.isGood = Math.round(message.isGood);
      }
      if (message.cid !== 0) {
        obj.cid = Math.round(message.cid);
      }
      if (message.pn !== 0) {
        obj.pn = Math.round(message.pn);
      }
      if (message.sortType !== 0) {
        obj.sortType = Math.round(message.sortType);
      }
      return obj;
    },
    create(base) {
      return FrsPageReqIdl_DataReq.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseFrsPageReqIdl_DataReq();
      message.common = object.common !== void 0 && object.common !== null ? CommonReq.fromPartial(object.common) : void 0;
      message.kw = object.kw ?? "";
      message.rn = object.rn ?? 0;
      message.rnNeed = object.rnNeed ?? 0;
      message.isGood = object.isGood ?? 0;
      message.cid = object.cid ?? 0;
      message.pn = object.pn ?? 0;
      message.sortType = object.sortType ?? 0;
      return message;
    }
  };
  function isSet2(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/Error.ts
  function createBaseError() {
    return { errorno: 0, errmsg: "", usermsg: "" };
  }
  var Error4 = {
    encode(message, writer = new BinaryWriter()) {
      if (message.errorno !== 0) {
        writer.uint32(8).int32(message.errorno);
      }
      if (message.errmsg !== "") {
        writer.uint32(18).string(message.errmsg);
      }
      if (message.usermsg !== "") {
        writer.uint32(26).string(message.usermsg);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseError();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.errorno = reader.int32();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.errmsg = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.usermsg = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        errorno: isSet3(object.errorno) ? globalThis.Number(object.errorno) : 0,
        errmsg: isSet3(object.errmsg) ? globalThis.String(object.errmsg) : "",
        usermsg: isSet3(object.usermsg) ? globalThis.String(object.usermsg) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.errorno !== 0) {
        obj.errorno = Math.round(message.errorno);
      }
      if (message.errmsg !== "") {
        obj.errmsg = message.errmsg;
      }
      if (message.usermsg !== "") {
        obj.usermsg = message.usermsg;
      }
      return obj;
    },
    create(base) {
      return Error4.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseError();
      message.errorno = object.errorno ?? 0;
      message.errmsg = object.errmsg ?? "";
      message.usermsg = object.usermsg ?? "";
      return message;
    }
  };
  function isSet3(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/FrsTabInfo.ts
  function createBaseFrsTabInfo() {
    return { tabId: 0, tabName: "" };
  }
  var FrsTabInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.tabId !== 0) {
        writer.uint32(8).int32(message.tabId);
      }
      if (message.tabName !== "") {
        writer.uint32(26).string(message.tabName);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseFrsTabInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.tabId = reader.int32();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.tabName = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        tabId: isSet4(object.tabId) ? globalThis.Number(object.tabId) : isSet4(object.tab_id) ? globalThis.Number(object.tab_id) : 0,
        tabName: isSet4(object.tabName) ? globalThis.String(object.tabName) : isSet4(object.tab_name) ? globalThis.String(object.tab_name) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.tabId !== 0) {
        obj.tabId = Math.round(message.tabId);
      }
      if (message.tabName !== "") {
        obj.tabName = message.tabName;
      }
      return obj;
    },
    create(base) {
      return FrsTabInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseFrsTabInfo();
      message.tabId = object.tabId ?? 0;
      message.tabName = object.tabName ?? "";
      return message;
    }
  };
  function isSet4(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/Page.ts
  function createBasePage() {
    return { pageSize: 0, currentPage: 0, totalCount: 0, totalPage: 0, hasMore: 0, hasPrev: 0 };
  }
  var Page = {
    encode(message, writer = new BinaryWriter()) {
      if (message.pageSize !== 0) {
        writer.uint32(8).int32(message.pageSize);
      }
      if (message.currentPage !== 0) {
        writer.uint32(24).int32(message.currentPage);
      }
      if (message.totalCount !== 0) {
        writer.uint32(32).int32(message.totalCount);
      }
      if (message.totalPage !== 0) {
        writer.uint32(40).int32(message.totalPage);
      }
      if (message.hasMore !== 0) {
        writer.uint32(48).int32(message.hasMore);
      }
      if (message.hasPrev !== 0) {
        writer.uint32(56).int32(message.hasPrev);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePage();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.pageSize = reader.int32();
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }
            message.currentPage = reader.int32();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }
            message.totalCount = reader.int32();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }
            message.totalPage = reader.int32();
            continue;
          }
          case 6: {
            if (tag !== 48) {
              break;
            }
            message.hasMore = reader.int32();
            continue;
          }
          case 7: {
            if (tag !== 56) {
              break;
            }
            message.hasPrev = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        pageSize: isSet5(object.pageSize) ? globalThis.Number(object.pageSize) : isSet5(object.page_size) ? globalThis.Number(object.page_size) : 0,
        currentPage: isSet5(object.currentPage) ? globalThis.Number(object.currentPage) : isSet5(object.current_page) ? globalThis.Number(object.current_page) : 0,
        totalCount: isSet5(object.totalCount) ? globalThis.Number(object.totalCount) : isSet5(object.total_count) ? globalThis.Number(object.total_count) : 0,
        totalPage: isSet5(object.totalPage) ? globalThis.Number(object.totalPage) : isSet5(object.total_page) ? globalThis.Number(object.total_page) : 0,
        hasMore: isSet5(object.hasMore) ? globalThis.Number(object.hasMore) : isSet5(object.has_more) ? globalThis.Number(object.has_more) : 0,
        hasPrev: isSet5(object.hasPrev) ? globalThis.Number(object.hasPrev) : isSet5(object.has_prev) ? globalThis.Number(object.has_prev) : 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.pageSize !== 0) {
        obj.pageSize = Math.round(message.pageSize);
      }
      if (message.currentPage !== 0) {
        obj.currentPage = Math.round(message.currentPage);
      }
      if (message.totalCount !== 0) {
        obj.totalCount = Math.round(message.totalCount);
      }
      if (message.totalPage !== 0) {
        obj.totalPage = Math.round(message.totalPage);
      }
      if (message.hasMore !== 0) {
        obj.hasMore = Math.round(message.hasMore);
      }
      if (message.hasPrev !== 0) {
        obj.hasPrev = Math.round(message.hasPrev);
      }
      return obj;
    },
    create(base) {
      return Page.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePage();
      message.pageSize = object.pageSize ?? 0;
      message.currentPage = object.currentPage ?? 0;
      message.totalCount = object.totalCount ?? 0;
      message.totalPage = object.totalPage ?? 0;
      message.hasMore = object.hasMore ?? 0;
      message.hasPrev = object.hasPrev ?? 0;
      return message;
    }
  };
  function isSet5(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/Agree.ts
  function createBaseAgree() {
    return { agreeNum: "0", hasAgree: 0, agreeType: 0, disagreeNum: "0", diffAgreeNum: "0", lzAgree: 0 };
  }
  var Agree = {
    encode(message, writer = new BinaryWriter()) {
      if (message.agreeNum !== "0") {
        writer.uint32(8).int64(message.agreeNum);
      }
      if (message.hasAgree !== 0) {
        writer.uint32(16).int32(message.hasAgree);
      }
      if (message.agreeType !== 0) {
        writer.uint32(24).int32(message.agreeType);
      }
      if (message.disagreeNum !== "0") {
        writer.uint32(32).int64(message.disagreeNum);
      }
      if (message.diffAgreeNum !== "0") {
        writer.uint32(40).int64(message.diffAgreeNum);
      }
      if (message.lzAgree !== 0) {
        writer.uint32(48).int32(message.lzAgree);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseAgree();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.agreeNum = reader.int64().toString();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.hasAgree = reader.int32();
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }
            message.agreeType = reader.int32();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }
            message.disagreeNum = reader.int64().toString();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }
            message.diffAgreeNum = reader.int64().toString();
            continue;
          }
          case 6: {
            if (tag !== 48) {
              break;
            }
            message.lzAgree = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        agreeNum: isSet6(object.agreeNum) ? globalThis.String(object.agreeNum) : isSet6(object.agree_num) ? globalThis.String(object.agree_num) : "0",
        hasAgree: isSet6(object.hasAgree) ? globalThis.Number(object.hasAgree) : isSet6(object.has_agree) ? globalThis.Number(object.has_agree) : 0,
        agreeType: isSet6(object.agreeType) ? globalThis.Number(object.agreeType) : isSet6(object.agree_type) ? globalThis.Number(object.agree_type) : 0,
        disagreeNum: isSet6(object.disagreeNum) ? globalThis.String(object.disagreeNum) : isSet6(object.disagree_num) ? globalThis.String(object.disagree_num) : "0",
        diffAgreeNum: isSet6(object.diffAgreeNum) ? globalThis.String(object.diffAgreeNum) : isSet6(object.diff_agree_num) ? globalThis.String(object.diff_agree_num) : "0",
        lzAgree: isSet6(object.lzAgree) ? globalThis.Number(object.lzAgree) : isSet6(object.lz_agree) ? globalThis.Number(object.lz_agree) : 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.agreeNum !== "0") {
        obj.agreeNum = message.agreeNum;
      }
      if (message.hasAgree !== 0) {
        obj.hasAgree = Math.round(message.hasAgree);
      }
      if (message.agreeType !== 0) {
        obj.agreeType = Math.round(message.agreeType);
      }
      if (message.disagreeNum !== "0") {
        obj.disagreeNum = message.disagreeNum;
      }
      if (message.diffAgreeNum !== "0") {
        obj.diffAgreeNum = message.diffAgreeNum;
      }
      if (message.lzAgree !== 0) {
        obj.lzAgree = Math.round(message.lzAgree);
      }
      return obj;
    },
    create(base) {
      return Agree.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseAgree();
      message.agreeNum = object.agreeNum ?? "0";
      message.hasAgree = object.hasAgree ?? 0;
      message.agreeType = object.agreeType ?? 0;
      message.disagreeNum = object.disagreeNum ?? "0";
      message.diffAgreeNum = object.diffAgreeNum ?? "0";
      message.lzAgree = object.lzAgree ?? 0;
      return message;
    }
  };
  function isSet6(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/Media.ts
  function createBaseMedia() {
    return { type: 0, smallPic: "", bigPic: "", waterPic: "", width: 0, height: 0, originPic: "", originSize: 0 };
  }
  var Media = {
    encode(message, writer = new BinaryWriter()) {
      if (message.type !== 0) {
        writer.uint32(8).int32(message.type);
      }
      if (message.smallPic !== "") {
        writer.uint32(18).string(message.smallPic);
      }
      if (message.bigPic !== "") {
        writer.uint32(26).string(message.bigPic);
      }
      if (message.waterPic !== "") {
        writer.uint32(34).string(message.waterPic);
      }
      if (message.width !== 0) {
        writer.uint32(80).uint32(message.width);
      }
      if (message.height !== 0) {
        writer.uint32(88).uint32(message.height);
      }
      if (message.originPic !== "") {
        writer.uint32(122).string(message.originPic);
      }
      if (message.originSize !== 0) {
        writer.uint32(128).uint32(message.originSize);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseMedia();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.type = reader.int32();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.smallPic = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.bigPic = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }
            message.waterPic = reader.string();
            continue;
          }
          case 10: {
            if (tag !== 80) {
              break;
            }
            message.width = reader.uint32();
            continue;
          }
          case 11: {
            if (tag !== 88) {
              break;
            }
            message.height = reader.uint32();
            continue;
          }
          case 15: {
            if (tag !== 122) {
              break;
            }
            message.originPic = reader.string();
            continue;
          }
          case 16: {
            if (tag !== 128) {
              break;
            }
            message.originSize = reader.uint32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        type: isSet7(object.type) ? globalThis.Number(object.type) : 0,
        smallPic: isSet7(object.smallPic) ? globalThis.String(object.smallPic) : isSet7(object.small_pic) ? globalThis.String(object.small_pic) : "",
        bigPic: isSet7(object.bigPic) ? globalThis.String(object.bigPic) : isSet7(object.big_pic) ? globalThis.String(object.big_pic) : "",
        waterPic: isSet7(object.waterPic) ? globalThis.String(object.waterPic) : isSet7(object.water_pic) ? globalThis.String(object.water_pic) : "",
        width: isSet7(object.width) ? globalThis.Number(object.width) : 0,
        height: isSet7(object.height) ? globalThis.Number(object.height) : 0,
        originPic: isSet7(object.originPic) ? globalThis.String(object.originPic) : isSet7(object.origin_pic) ? globalThis.String(object.origin_pic) : "",
        originSize: isSet7(object.originSize) ? globalThis.Number(object.originSize) : isSet7(object.origin_size) ? globalThis.Number(object.origin_size) : 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.type !== 0) {
        obj.type = Math.round(message.type);
      }
      if (message.smallPic !== "") {
        obj.smallPic = message.smallPic;
      }
      if (message.bigPic !== "") {
        obj.bigPic = message.bigPic;
      }
      if (message.waterPic !== "") {
        obj.waterPic = message.waterPic;
      }
      if (message.width !== 0) {
        obj.width = Math.round(message.width);
      }
      if (message.height !== 0) {
        obj.height = Math.round(message.height);
      }
      if (message.originPic !== "") {
        obj.originPic = message.originPic;
      }
      if (message.originSize !== 0) {
        obj.originSize = Math.round(message.originSize);
      }
      return obj;
    },
    create(base) {
      return Media.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseMedia();
      message.type = object.type ?? 0;
      message.smallPic = object.smallPic ?? "";
      message.bigPic = object.bigPic ?? "";
      message.waterPic = object.waterPic ?? "";
      message.width = object.width ?? 0;
      message.height = object.height ?? 0;
      message.originPic = object.originPic ?? "";
      message.originSize = object.originSize ?? 0;
      return message;
    }
  };
  function isSet7(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/PbContent.ts
  function createBasePbContent() {
    return {
      type: 0,
      text: "",
      link: "",
      src: "",
      bsize: "",
      cdnSrc: "",
      bigCdnSrc: "",
      c: "",
      voiceMd5: "",
      duringTime: 0,
      uid: "0",
      width: 0,
      height: 0,
      originSrc: "",
      originSize: 0,
      count: 0,
      tiebaplusInfo: void 0,
      item: void 0
    };
  }
  var PbContent = {
    encode(message, writer = new BinaryWriter()) {
      if (message.type !== 0) {
        writer.uint32(8).uint32(message.type);
      }
      if (message.text !== "") {
        writer.uint32(18).string(message.text);
      }
      if (message.link !== "") {
        writer.uint32(26).string(message.link);
      }
      if (message.src !== "") {
        writer.uint32(34).string(message.src);
      }
      if (message.bsize !== "") {
        writer.uint32(42).string(message.bsize);
      }
      if (message.cdnSrc !== "") {
        writer.uint32(66).string(message.cdnSrc);
      }
      if (message.bigCdnSrc !== "") {
        writer.uint32(74).string(message.bigCdnSrc);
      }
      if (message.c !== "") {
        writer.uint32(90).string(message.c);
      }
      if (message.voiceMd5 !== "") {
        writer.uint32(98).string(message.voiceMd5);
      }
      if (message.duringTime !== 0) {
        writer.uint32(104).uint32(message.duringTime);
      }
      if (message.uid !== "0") {
        writer.uint32(120).int64(message.uid);
      }
      if (message.width !== 0) {
        writer.uint32(144).uint32(message.width);
      }
      if (message.height !== 0) {
        writer.uint32(152).uint32(message.height);
      }
      if (message.originSrc !== "") {
        writer.uint32(202).string(message.originSrc);
      }
      if (message.originSize !== 0) {
        writer.uint32(216).uint32(message.originSize);
      }
      if (message.count !== 0) {
        writer.uint32(224).int32(message.count);
      }
      if (message.tiebaplusInfo !== void 0) {
        PbContent_TiebaPlusInfo.encode(message.tiebaplusInfo, writer.uint32(322).fork()).join();
      }
      if (message.item !== void 0) {
        PbContent_Item.encode(message.item, writer.uint32(330).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePbContent();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.type = reader.uint32();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.text = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.link = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }
            message.src = reader.string();
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }
            message.bsize = reader.string();
            continue;
          }
          case 8: {
            if (tag !== 66) {
              break;
            }
            message.cdnSrc = reader.string();
            continue;
          }
          case 9: {
            if (tag !== 74) {
              break;
            }
            message.bigCdnSrc = reader.string();
            continue;
          }
          case 11: {
            if (tag !== 90) {
              break;
            }
            message.c = reader.string();
            continue;
          }
          case 12: {
            if (tag !== 98) {
              break;
            }
            message.voiceMd5 = reader.string();
            continue;
          }
          case 13: {
            if (tag !== 104) {
              break;
            }
            message.duringTime = reader.uint32();
            continue;
          }
          case 15: {
            if (tag !== 120) {
              break;
            }
            message.uid = reader.int64().toString();
            continue;
          }
          case 18: {
            if (tag !== 144) {
              break;
            }
            message.width = reader.uint32();
            continue;
          }
          case 19: {
            if (tag !== 152) {
              break;
            }
            message.height = reader.uint32();
            continue;
          }
          case 25: {
            if (tag !== 202) {
              break;
            }
            message.originSrc = reader.string();
            continue;
          }
          case 27: {
            if (tag !== 216) {
              break;
            }
            message.originSize = reader.uint32();
            continue;
          }
          case 28: {
            if (tag !== 224) {
              break;
            }
            message.count = reader.int32();
            continue;
          }
          case 40: {
            if (tag !== 322) {
              break;
            }
            message.tiebaplusInfo = PbContent_TiebaPlusInfo.decode(reader, reader.uint32());
            continue;
          }
          case 41: {
            if (tag !== 330) {
              break;
            }
            message.item = PbContent_Item.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        type: isSet8(object.type) ? globalThis.Number(object.type) : 0,
        text: isSet8(object.text) ? globalThis.String(object.text) : "",
        link: isSet8(object.link) ? globalThis.String(object.link) : "",
        src: isSet8(object.src) ? globalThis.String(object.src) : "",
        bsize: isSet8(object.bsize) ? globalThis.String(object.bsize) : "",
        cdnSrc: isSet8(object.cdnSrc) ? globalThis.String(object.cdnSrc) : isSet8(object.cdn_src) ? globalThis.String(object.cdn_src) : "",
        bigCdnSrc: isSet8(object.bigCdnSrc) ? globalThis.String(object.bigCdnSrc) : isSet8(object.big_cdn_src) ? globalThis.String(object.big_cdn_src) : "",
        c: isSet8(object.c) ? globalThis.String(object.c) : "",
        voiceMd5: isSet8(object.voiceMd5) ? globalThis.String(object.voiceMd5) : isSet8(object.voice_md5) ? globalThis.String(object.voice_md5) : "",
        duringTime: isSet8(object.duringTime) ? globalThis.Number(object.duringTime) : isSet8(object.during_time) ? globalThis.Number(object.during_time) : 0,
        uid: isSet8(object.uid) ? globalThis.String(object.uid) : "0",
        width: isSet8(object.width) ? globalThis.Number(object.width) : 0,
        height: isSet8(object.height) ? globalThis.Number(object.height) : 0,
        originSrc: isSet8(object.originSrc) ? globalThis.String(object.originSrc) : isSet8(object.origin_src) ? globalThis.String(object.origin_src) : "",
        originSize: isSet8(object.originSize) ? globalThis.Number(object.originSize) : isSet8(object.origin_size) ? globalThis.Number(object.origin_size) : 0,
        count: isSet8(object.count) ? globalThis.Number(object.count) : 0,
        tiebaplusInfo: isSet8(object.tiebaplusInfo) ? PbContent_TiebaPlusInfo.fromJSON(object.tiebaplusInfo) : isSet8(object.tiebaplus_info) ? PbContent_TiebaPlusInfo.fromJSON(object.tiebaplus_info) : void 0,
        item: isSet8(object.item) ? PbContent_Item.fromJSON(object.item) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.type !== 0) {
        obj.type = Math.round(message.type);
      }
      if (message.text !== "") {
        obj.text = message.text;
      }
      if (message.link !== "") {
        obj.link = message.link;
      }
      if (message.src !== "") {
        obj.src = message.src;
      }
      if (message.bsize !== "") {
        obj.bsize = message.bsize;
      }
      if (message.cdnSrc !== "") {
        obj.cdnSrc = message.cdnSrc;
      }
      if (message.bigCdnSrc !== "") {
        obj.bigCdnSrc = message.bigCdnSrc;
      }
      if (message.c !== "") {
        obj.c = message.c;
      }
      if (message.voiceMd5 !== "") {
        obj.voiceMd5 = message.voiceMd5;
      }
      if (message.duringTime !== 0) {
        obj.duringTime = Math.round(message.duringTime);
      }
      if (message.uid !== "0") {
        obj.uid = message.uid;
      }
      if (message.width !== 0) {
        obj.width = Math.round(message.width);
      }
      if (message.height !== 0) {
        obj.height = Math.round(message.height);
      }
      if (message.originSrc !== "") {
        obj.originSrc = message.originSrc;
      }
      if (message.originSize !== 0) {
        obj.originSize = Math.round(message.originSize);
      }
      if (message.count !== 0) {
        obj.count = Math.round(message.count);
      }
      if (message.tiebaplusInfo !== void 0) {
        obj.tiebaplusInfo = PbContent_TiebaPlusInfo.toJSON(message.tiebaplusInfo);
      }
      if (message.item !== void 0) {
        obj.item = PbContent_Item.toJSON(message.item);
      }
      return obj;
    },
    create(base) {
      return PbContent.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePbContent();
      message.type = object.type ?? 0;
      message.text = object.text ?? "";
      message.link = object.link ?? "";
      message.src = object.src ?? "";
      message.bsize = object.bsize ?? "";
      message.cdnSrc = object.cdnSrc ?? "";
      message.bigCdnSrc = object.bigCdnSrc ?? "";
      message.c = object.c ?? "";
      message.voiceMd5 = object.voiceMd5 ?? "";
      message.duringTime = object.duringTime ?? 0;
      message.uid = object.uid ?? "0";
      message.width = object.width ?? 0;
      message.height = object.height ?? 0;
      message.originSrc = object.originSrc ?? "";
      message.originSize = object.originSize ?? 0;
      message.count = object.count ?? 0;
      message.tiebaplusInfo = object.tiebaplusInfo !== void 0 && object.tiebaplusInfo !== null ? PbContent_TiebaPlusInfo.fromPartial(object.tiebaplusInfo) : void 0;
      message.item = object.item !== void 0 && object.item !== null ? PbContent_Item.fromPartial(object.item) : void 0;
      return message;
    }
  };
  function createBasePbContent_TiebaPlusInfo() {
    return {
      title: "",
      desc: "",
      jumpUrl: "",
      appIcon: "",
      targetType: 0,
      h5JumpType: 0,
      h5JumpNumber: "",
      h5JumpParam: "",
      jumpType: 0,
      buttonDesc: ""
    };
  }
  var PbContent_TiebaPlusInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.title !== "") {
        writer.uint32(10).string(message.title);
      }
      if (message.desc !== "") {
        writer.uint32(18).string(message.desc);
      }
      if (message.jumpUrl !== "") {
        writer.uint32(26).string(message.jumpUrl);
      }
      if (message.appIcon !== "") {
        writer.uint32(50).string(message.appIcon);
      }
      if (message.targetType !== 0) {
        writer.uint32(96).int32(message.targetType);
      }
      if (message.h5JumpType !== 0) {
        writer.uint32(104).int32(message.h5JumpType);
      }
      if (message.h5JumpNumber !== "") {
        writer.uint32(114).string(message.h5JumpNumber);
      }
      if (message.h5JumpParam !== "") {
        writer.uint32(122).string(message.h5JumpParam);
      }
      if (message.jumpType !== 0) {
        writer.uint32(128).int32(message.jumpType);
      }
      if (message.buttonDesc !== "") {
        writer.uint32(186).string(message.buttonDesc);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePbContent_TiebaPlusInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.title = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.desc = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.jumpUrl = reader.string();
            continue;
          }
          case 6: {
            if (tag !== 50) {
              break;
            }
            message.appIcon = reader.string();
            continue;
          }
          case 12: {
            if (tag !== 96) {
              break;
            }
            message.targetType = reader.int32();
            continue;
          }
          case 13: {
            if (tag !== 104) {
              break;
            }
            message.h5JumpType = reader.int32();
            continue;
          }
          case 14: {
            if (tag !== 114) {
              break;
            }
            message.h5JumpNumber = reader.string();
            continue;
          }
          case 15: {
            if (tag !== 122) {
              break;
            }
            message.h5JumpParam = reader.string();
            continue;
          }
          case 16: {
            if (tag !== 128) {
              break;
            }
            message.jumpType = reader.int32();
            continue;
          }
          case 23: {
            if (tag !== 186) {
              break;
            }
            message.buttonDesc = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        title: isSet8(object.title) ? globalThis.String(object.title) : "",
        desc: isSet8(object.desc) ? globalThis.String(object.desc) : "",
        jumpUrl: isSet8(object.jumpUrl) ? globalThis.String(object.jumpUrl) : isSet8(object.jump_url) ? globalThis.String(object.jump_url) : "",
        appIcon: isSet8(object.appIcon) ? globalThis.String(object.appIcon) : isSet8(object.app_icon) ? globalThis.String(object.app_icon) : "",
        targetType: isSet8(object.targetType) ? globalThis.Number(object.targetType) : isSet8(object.target_type) ? globalThis.Number(object.target_type) : 0,
        h5JumpType: isSet8(object.h5JumpType) ? globalThis.Number(object.h5JumpType) : isSet8(object.h5_jump_type) ? globalThis.Number(object.h5_jump_type) : 0,
        h5JumpNumber: isSet8(object.h5JumpNumber) ? globalThis.String(object.h5JumpNumber) : isSet8(object.h5_jump_number) ? globalThis.String(object.h5_jump_number) : "",
        h5JumpParam: isSet8(object.h5JumpParam) ? globalThis.String(object.h5JumpParam) : isSet8(object.h5_jump_param) ? globalThis.String(object.h5_jump_param) : "",
        jumpType: isSet8(object.jumpType) ? globalThis.Number(object.jumpType) : isSet8(object.jump_type) ? globalThis.Number(object.jump_type) : 0,
        buttonDesc: isSet8(object.buttonDesc) ? globalThis.String(object.buttonDesc) : isSet8(object.button_desc) ? globalThis.String(object.button_desc) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.title !== "") {
        obj.title = message.title;
      }
      if (message.desc !== "") {
        obj.desc = message.desc;
      }
      if (message.jumpUrl !== "") {
        obj.jumpUrl = message.jumpUrl;
      }
      if (message.appIcon !== "") {
        obj.appIcon = message.appIcon;
      }
      if (message.targetType !== 0) {
        obj.targetType = Math.round(message.targetType);
      }
      if (message.h5JumpType !== 0) {
        obj.h5JumpType = Math.round(message.h5JumpType);
      }
      if (message.h5JumpNumber !== "") {
        obj.h5JumpNumber = message.h5JumpNumber;
      }
      if (message.h5JumpParam !== "") {
        obj.h5JumpParam = message.h5JumpParam;
      }
      if (message.jumpType !== 0) {
        obj.jumpType = Math.round(message.jumpType);
      }
      if (message.buttonDesc !== "") {
        obj.buttonDesc = message.buttonDesc;
      }
      return obj;
    },
    create(base) {
      return PbContent_TiebaPlusInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePbContent_TiebaPlusInfo();
      message.title = object.title ?? "";
      message.desc = object.desc ?? "";
      message.jumpUrl = object.jumpUrl ?? "";
      message.appIcon = object.appIcon ?? "";
      message.targetType = object.targetType ?? 0;
      message.h5JumpType = object.h5JumpType ?? 0;
      message.h5JumpNumber = object.h5JumpNumber ?? "";
      message.h5JumpParam = object.h5JumpParam ?? "";
      message.jumpType = object.jumpType ?? 0;
      message.buttonDesc = object.buttonDesc ?? "";
      return message;
    }
  };
  function createBasePbContent_Item() {
    return { itemName: "" };
  }
  var PbContent_Item = {
    encode(message, writer = new BinaryWriter()) {
      if (message.itemName !== "") {
        writer.uint32(18).string(message.itemName);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePbContent_Item();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.itemName = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        itemName: isSet8(object.itemName) ? globalThis.String(object.itemName) : isSet8(object.item_name) ? globalThis.String(object.item_name) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.itemName !== "") {
        obj.itemName = message.itemName;
      }
      return obj;
    },
    create(base) {
      return PbContent_Item.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePbContent_Item();
      message.itemName = object.itemName ?? "";
      return message;
    }
  };
  function isSet8(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/PollInfo.ts
  function createBasePollInfo() {
    return { isMulti: 0, totalNum: "0", options: [], totalPoll: "0", title: "" };
  }
  var PollInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.isMulti !== 0) {
        writer.uint32(16).int32(message.isMulti);
      }
      if (message.totalNum !== "0") {
        writer.uint32(24).int64(message.totalNum);
      }
      for (const v of message.options) {
        PollInfo_PollOption.encode(v, writer.uint32(74).fork()).join();
      }
      if (message.totalPoll !== "0") {
        writer.uint32(88).int64(message.totalPoll);
      }
      if (message.title !== "") {
        writer.uint32(98).string(message.title);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePollInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.isMulti = reader.int32();
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }
            message.totalNum = reader.int64().toString();
            continue;
          }
          case 9: {
            if (tag !== 74) {
              break;
            }
            message.options.push(PollInfo_PollOption.decode(reader, reader.uint32()));
            continue;
          }
          case 11: {
            if (tag !== 88) {
              break;
            }
            message.totalPoll = reader.int64().toString();
            continue;
          }
          case 12: {
            if (tag !== 98) {
              break;
            }
            message.title = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        isMulti: isSet9(object.isMulti) ? globalThis.Number(object.isMulti) : isSet9(object.is_multi) ? globalThis.Number(object.is_multi) : 0,
        totalNum: isSet9(object.totalNum) ? globalThis.String(object.totalNum) : isSet9(object.total_num) ? globalThis.String(object.total_num) : "0",
        options: globalThis.Array.isArray(object?.options) ? object.options.map((e) => PollInfo_PollOption.fromJSON(e)) : [],
        totalPoll: isSet9(object.totalPoll) ? globalThis.String(object.totalPoll) : isSet9(object.total_poll) ? globalThis.String(object.total_poll) : "0",
        title: isSet9(object.title) ? globalThis.String(object.title) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.isMulti !== 0) {
        obj.isMulti = Math.round(message.isMulti);
      }
      if (message.totalNum !== "0") {
        obj.totalNum = message.totalNum;
      }
      if (message.options?.length) {
        obj.options = message.options.map((e) => PollInfo_PollOption.toJSON(e));
      }
      if (message.totalPoll !== "0") {
        obj.totalPoll = message.totalPoll;
      }
      if (message.title !== "") {
        obj.title = message.title;
      }
      return obj;
    },
    create(base) {
      return PollInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePollInfo();
      message.isMulti = object.isMulti ?? 0;
      message.totalNum = object.totalNum ?? "0";
      message.options = object.options?.map((e) => PollInfo_PollOption.fromPartial(e)) || [];
      message.totalPoll = object.totalPoll ?? "0";
      message.title = object.title ?? "";
      return message;
    }
  };
  function createBasePollInfo_PollOption() {
    return { num: "0", text: "" };
  }
  var PollInfo_PollOption = {
    encode(message, writer = new BinaryWriter()) {
      if (message.num !== "0") {
        writer.uint32(16).int64(message.num);
      }
      if (message.text !== "") {
        writer.uint32(26).string(message.text);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePollInfo_PollOption();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.num = reader.int64().toString();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.text = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        num: isSet9(object.num) ? globalThis.String(object.num) : "0",
        text: isSet9(object.text) ? globalThis.String(object.text) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.num !== "0") {
        obj.num = message.num;
      }
      if (message.text !== "") {
        obj.text = message.text;
      }
      return obj;
    },
    create(base) {
      return PollInfo_PollOption.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePollInfo_PollOption();
      message.num = object.num ?? "0";
      message.text = object.text ?? "";
      return message;
    }
  };
  function isSet9(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/User.ts
  function createBaseUser() {
    return {
      id: "0",
      name: "",
      nameShow: "",
      portrait: "",
      iconinfo: [],
      isCoreuser: 0,
      levelId: 0,
      isBawu: 0,
      bawuType: "",
      BDUSS: "",
      fansNum: 0,
      concernNum: 0,
      sex: 0,
      myLikeNum: 0,
      intro: "",
      postNum: 0,
      tbAge: "",
      gender: 0,
      privSets: void 0,
      isFriend: 0,
      likeForum: [],
      isGuanfang: 0,
      vipInfo: void 0,
      newTshowIcon: [],
      isFans: 0,
      newGodData: void 0,
      isDefaultAvatar: 0,
      tiebaUid: "",
      ipAddress: "",
      virtualImageInfo: void 0,
      userGrowth: void 0
    };
  }
  var User = {
    encode(message, writer = new BinaryWriter()) {
      if (message.id !== "0") {
        writer.uint32(16).int64(message.id);
      }
      if (message.name !== "") {
        writer.uint32(26).string(message.name);
      }
      if (message.nameShow !== "") {
        writer.uint32(34).string(message.nameShow);
      }
      if (message.portrait !== "") {
        writer.uint32(42).string(message.portrait);
      }
      for (const v of message.iconinfo) {
        User_Icon.encode(v, writer.uint32(138).fork()).join();
      }
      if (message.isCoreuser !== 0) {
        writer.uint32(160).int32(message.isCoreuser);
      }
      if (message.levelId !== 0) {
        writer.uint32(184).int32(message.levelId);
      }
      if (message.isBawu !== 0) {
        writer.uint32(200).int32(message.isBawu);
      }
      if (message.bawuType !== "") {
        writer.uint32(210).string(message.bawuType);
      }
      if (message.BDUSS !== "") {
        writer.uint32(234).string(message.BDUSS);
      }
      if (message.fansNum !== 0) {
        writer.uint32(240).int32(message.fansNum);
      }
      if (message.concernNum !== 0) {
        writer.uint32(248).int32(message.concernNum);
      }
      if (message.sex !== 0) {
        writer.uint32(256).int32(message.sex);
      }
      if (message.myLikeNum !== 0) {
        writer.uint32(264).int32(message.myLikeNum);
      }
      if (message.intro !== "") {
        writer.uint32(274).string(message.intro);
      }
      if (message.postNum !== 0) {
        writer.uint32(296).int32(message.postNum);
      }
      if (message.tbAge !== "") {
        writer.uint32(306).string(message.tbAge);
      }
      if (message.gender !== 0) {
        writer.uint32(336).int32(message.gender);
      }
      if (message.privSets !== void 0) {
        User_PrivSets.encode(message.privSets, writer.uint32(362).fork()).join();
      }
      if (message.isFriend !== 0) {
        writer.uint32(368).int32(message.isFriend);
      }
      for (const v of message.likeForum) {
        User_LikeForumInfo.encode(v, writer.uint32(378).fork()).join();
      }
      if (message.isGuanfang !== 0) {
        writer.uint32(416).int32(message.isGuanfang);
      }
      if (message.vipInfo !== void 0) {
        User_UserVipInfo.encode(message.vipInfo, writer.uint32(490).fork()).join();
      }
      for (const v of message.newTshowIcon) {
        User_TshowInfo.encode(v, writer.uint32(522).fork()).join();
      }
      if (message.isFans !== 0) {
        writer.uint32(728).int32(message.isFans);
      }
      if (message.newGodData !== void 0) {
        User_NewGodInfo.encode(message.newGodData, writer.uint32(810).fork()).join();
      }
      if (message.isDefaultAvatar !== 0) {
        writer.uint32(848).int32(message.isDefaultAvatar);
      }
      if (message.tiebaUid !== "") {
        writer.uint32(962).string(message.tiebaUid);
      }
      if (message.ipAddress !== "") {
        writer.uint32(1018).string(message.ipAddress);
      }
      if (message.virtualImageInfo !== void 0) {
        User_VirtualImageInfo.encode(message.virtualImageInfo, writer.uint32(1090).fork()).join();
      }
      if (message.userGrowth !== void 0) {
        User_UserGrowth.encode(message.userGrowth, writer.uint32(1098).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseUser();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.id = reader.int64().toString();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.name = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }
            message.nameShow = reader.string();
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }
            message.portrait = reader.string();
            continue;
          }
          case 17: {
            if (tag !== 138) {
              break;
            }
            message.iconinfo.push(User_Icon.decode(reader, reader.uint32()));
            continue;
          }
          case 20: {
            if (tag !== 160) {
              break;
            }
            message.isCoreuser = reader.int32();
            continue;
          }
          case 23: {
            if (tag !== 184) {
              break;
            }
            message.levelId = reader.int32();
            continue;
          }
          case 25: {
            if (tag !== 200) {
              break;
            }
            message.isBawu = reader.int32();
            continue;
          }
          case 26: {
            if (tag !== 210) {
              break;
            }
            message.bawuType = reader.string();
            continue;
          }
          case 29: {
            if (tag !== 234) {
              break;
            }
            message.BDUSS = reader.string();
            continue;
          }
          case 30: {
            if (tag !== 240) {
              break;
            }
            message.fansNum = reader.int32();
            continue;
          }
          case 31: {
            if (tag !== 248) {
              break;
            }
            message.concernNum = reader.int32();
            continue;
          }
          case 32: {
            if (tag !== 256) {
              break;
            }
            message.sex = reader.int32();
            continue;
          }
          case 33: {
            if (tag !== 264) {
              break;
            }
            message.myLikeNum = reader.int32();
            continue;
          }
          case 34: {
            if (tag !== 274) {
              break;
            }
            message.intro = reader.string();
            continue;
          }
          case 37: {
            if (tag !== 296) {
              break;
            }
            message.postNum = reader.int32();
            continue;
          }
          case 38: {
            if (tag !== 306) {
              break;
            }
            message.tbAge = reader.string();
            continue;
          }
          case 42: {
            if (tag !== 336) {
              break;
            }
            message.gender = reader.int32();
            continue;
          }
          case 45: {
            if (tag !== 362) {
              break;
            }
            message.privSets = User_PrivSets.decode(reader, reader.uint32());
            continue;
          }
          case 46: {
            if (tag !== 368) {
              break;
            }
            message.isFriend = reader.int32();
            continue;
          }
          case 47: {
            if (tag !== 378) {
              break;
            }
            message.likeForum.push(User_LikeForumInfo.decode(reader, reader.uint32()));
            continue;
          }
          case 52: {
            if (tag !== 416) {
              break;
            }
            message.isGuanfang = reader.int32();
            continue;
          }
          case 61: {
            if (tag !== 490) {
              break;
            }
            message.vipInfo = User_UserVipInfo.decode(reader, reader.uint32());
            continue;
          }
          case 65: {
            if (tag !== 522) {
              break;
            }
            message.newTshowIcon.push(User_TshowInfo.decode(reader, reader.uint32()));
            continue;
          }
          case 91: {
            if (tag !== 728) {
              break;
            }
            message.isFans = reader.int32();
            continue;
          }
          case 101: {
            if (tag !== 810) {
              break;
            }
            message.newGodData = User_NewGodInfo.decode(reader, reader.uint32());
            continue;
          }
          case 106: {
            if (tag !== 848) {
              break;
            }
            message.isDefaultAvatar = reader.int32();
            continue;
          }
          case 120: {
            if (tag !== 962) {
              break;
            }
            message.tiebaUid = reader.string();
            continue;
          }
          case 127: {
            if (tag !== 1018) {
              break;
            }
            message.ipAddress = reader.string();
            continue;
          }
          case 136: {
            if (tag !== 1090) {
              break;
            }
            message.virtualImageInfo = User_VirtualImageInfo.decode(reader, reader.uint32());
            continue;
          }
          case 137: {
            if (tag !== 1098) {
              break;
            }
            message.userGrowth = User_UserGrowth.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        id: isSet10(object.id) ? globalThis.String(object.id) : "0",
        name: isSet10(object.name) ? globalThis.String(object.name) : "",
        nameShow: isSet10(object.nameShow) ? globalThis.String(object.nameShow) : isSet10(object.name_show) ? globalThis.String(object.name_show) : "",
        portrait: isSet10(object.portrait) ? globalThis.String(object.portrait) : "",
        iconinfo: globalThis.Array.isArray(object?.iconinfo) ? object.iconinfo.map((e) => User_Icon.fromJSON(e)) : [],
        isCoreuser: isSet10(object.isCoreuser) ? globalThis.Number(object.isCoreuser) : isSet10(object.is_coreuser) ? globalThis.Number(object.is_coreuser) : 0,
        levelId: isSet10(object.levelId) ? globalThis.Number(object.levelId) : isSet10(object.level_id) ? globalThis.Number(object.level_id) : 0,
        isBawu: isSet10(object.isBawu) ? globalThis.Number(object.isBawu) : isSet10(object.is_bawu) ? globalThis.Number(object.is_bawu) : 0,
        bawuType: isSet10(object.bawuType) ? globalThis.String(object.bawuType) : isSet10(object.bawu_type) ? globalThis.String(object.bawu_type) : "",
        BDUSS: isSet10(object.BDUSS) ? globalThis.String(object.BDUSS) : "",
        fansNum: isSet10(object.fansNum) ? globalThis.Number(object.fansNum) : isSet10(object.fans_num) ? globalThis.Number(object.fans_num) : 0,
        concernNum: isSet10(object.concernNum) ? globalThis.Number(object.concernNum) : isSet10(object.concern_num) ? globalThis.Number(object.concern_num) : 0,
        sex: isSet10(object.sex) ? globalThis.Number(object.sex) : 0,
        myLikeNum: isSet10(object.myLikeNum) ? globalThis.Number(object.myLikeNum) : isSet10(object.my_like_num) ? globalThis.Number(object.my_like_num) : 0,
        intro: isSet10(object.intro) ? globalThis.String(object.intro) : "",
        postNum: isSet10(object.postNum) ? globalThis.Number(object.postNum) : isSet10(object.post_num) ? globalThis.Number(object.post_num) : 0,
        tbAge: isSet10(object.tbAge) ? globalThis.String(object.tbAge) : isSet10(object.tb_age) ? globalThis.String(object.tb_age) : "",
        gender: isSet10(object.gender) ? globalThis.Number(object.gender) : 0,
        privSets: isSet10(object.privSets) ? User_PrivSets.fromJSON(object.privSets) : isSet10(object.priv_sets) ? User_PrivSets.fromJSON(object.priv_sets) : void 0,
        isFriend: isSet10(object.isFriend) ? globalThis.Number(object.isFriend) : isSet10(object.is_friend) ? globalThis.Number(object.is_friend) : 0,
        likeForum: globalThis.Array.isArray(object?.likeForum) ? object.likeForum.map((e) => User_LikeForumInfo.fromJSON(e)) : [],
        isGuanfang: isSet10(object.isGuanfang) ? globalThis.Number(object.isGuanfang) : isSet10(object.is_guanfang) ? globalThis.Number(object.is_guanfang) : 0,
        vipInfo: isSet10(object.vipInfo) ? User_UserVipInfo.fromJSON(object.vipInfo) : void 0,
        newTshowIcon: globalThis.Array.isArray(object?.newTshowIcon) ? object.newTshowIcon.map((e) => User_TshowInfo.fromJSON(e)) : globalThis.Array.isArray(object?.new_tshow_icon) ? object.new_tshow_icon.map((e) => User_TshowInfo.fromJSON(e)) : [],
        isFans: isSet10(object.isFans) ? globalThis.Number(object.isFans) : isSet10(object.is_fans) ? globalThis.Number(object.is_fans) : 0,
        newGodData: isSet10(object.newGodData) ? User_NewGodInfo.fromJSON(object.newGodData) : isSet10(object.new_god_data) ? User_NewGodInfo.fromJSON(object.new_god_data) : void 0,
        isDefaultAvatar: isSet10(object.isDefaultAvatar) ? globalThis.Number(object.isDefaultAvatar) : isSet10(object.is_default_avatar) ? globalThis.Number(object.is_default_avatar) : 0,
        tiebaUid: isSet10(object.tiebaUid) ? globalThis.String(object.tiebaUid) : isSet10(object.tieba_uid) ? globalThis.String(object.tieba_uid) : "",
        ipAddress: isSet10(object.ipAddress) ? globalThis.String(object.ipAddress) : isSet10(object.ip_address) ? globalThis.String(object.ip_address) : "",
        virtualImageInfo: isSet10(object.virtualImageInfo) ? User_VirtualImageInfo.fromJSON(object.virtualImageInfo) : isSet10(object.virtual_image_info) ? User_VirtualImageInfo.fromJSON(object.virtual_image_info) : void 0,
        userGrowth: isSet10(object.userGrowth) ? User_UserGrowth.fromJSON(object.userGrowth) : isSet10(object.user_growth) ? User_UserGrowth.fromJSON(object.user_growth) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.id !== "0") {
        obj.id = message.id;
      }
      if (message.name !== "") {
        obj.name = message.name;
      }
      if (message.nameShow !== "") {
        obj.nameShow = message.nameShow;
      }
      if (message.portrait !== "") {
        obj.portrait = message.portrait;
      }
      if (message.iconinfo?.length) {
        obj.iconinfo = message.iconinfo.map((e) => User_Icon.toJSON(e));
      }
      if (message.isCoreuser !== 0) {
        obj.isCoreuser = Math.round(message.isCoreuser);
      }
      if (message.levelId !== 0) {
        obj.levelId = Math.round(message.levelId);
      }
      if (message.isBawu !== 0) {
        obj.isBawu = Math.round(message.isBawu);
      }
      if (message.bawuType !== "") {
        obj.bawuType = message.bawuType;
      }
      if (message.BDUSS !== "") {
        obj.BDUSS = message.BDUSS;
      }
      if (message.fansNum !== 0) {
        obj.fansNum = Math.round(message.fansNum);
      }
      if (message.concernNum !== 0) {
        obj.concernNum = Math.round(message.concernNum);
      }
      if (message.sex !== 0) {
        obj.sex = Math.round(message.sex);
      }
      if (message.myLikeNum !== 0) {
        obj.myLikeNum = Math.round(message.myLikeNum);
      }
      if (message.intro !== "") {
        obj.intro = message.intro;
      }
      if (message.postNum !== 0) {
        obj.postNum = Math.round(message.postNum);
      }
      if (message.tbAge !== "") {
        obj.tbAge = message.tbAge;
      }
      if (message.gender !== 0) {
        obj.gender = Math.round(message.gender);
      }
      if (message.privSets !== void 0) {
        obj.privSets = User_PrivSets.toJSON(message.privSets);
      }
      if (message.isFriend !== 0) {
        obj.isFriend = Math.round(message.isFriend);
      }
      if (message.likeForum?.length) {
        obj.likeForum = message.likeForum.map((e) => User_LikeForumInfo.toJSON(e));
      }
      if (message.isGuanfang !== 0) {
        obj.isGuanfang = Math.round(message.isGuanfang);
      }
      if (message.vipInfo !== void 0) {
        obj.vipInfo = User_UserVipInfo.toJSON(message.vipInfo);
      }
      if (message.newTshowIcon?.length) {
        obj.newTshowIcon = message.newTshowIcon.map((e) => User_TshowInfo.toJSON(e));
      }
      if (message.isFans !== 0) {
        obj.isFans = Math.round(message.isFans);
      }
      if (message.newGodData !== void 0) {
        obj.newGodData = User_NewGodInfo.toJSON(message.newGodData);
      }
      if (message.isDefaultAvatar !== 0) {
        obj.isDefaultAvatar = Math.round(message.isDefaultAvatar);
      }
      if (message.tiebaUid !== "") {
        obj.tiebaUid = message.tiebaUid;
      }
      if (message.ipAddress !== "") {
        obj.ipAddress = message.ipAddress;
      }
      if (message.virtualImageInfo !== void 0) {
        obj.virtualImageInfo = User_VirtualImageInfo.toJSON(message.virtualImageInfo);
      }
      if (message.userGrowth !== void 0) {
        obj.userGrowth = User_UserGrowth.toJSON(message.userGrowth);
      }
      return obj;
    },
    create(base) {
      return User.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseUser();
      message.id = object.id ?? "0";
      message.name = object.name ?? "";
      message.nameShow = object.nameShow ?? "";
      message.portrait = object.portrait ?? "";
      message.iconinfo = object.iconinfo?.map((e) => User_Icon.fromPartial(e)) || [];
      message.isCoreuser = object.isCoreuser ?? 0;
      message.levelId = object.levelId ?? 0;
      message.isBawu = object.isBawu ?? 0;
      message.bawuType = object.bawuType ?? "";
      message.BDUSS = object.BDUSS ?? "";
      message.fansNum = object.fansNum ?? 0;
      message.concernNum = object.concernNum ?? 0;
      message.sex = object.sex ?? 0;
      message.myLikeNum = object.myLikeNum ?? 0;
      message.intro = object.intro ?? "";
      message.postNum = object.postNum ?? 0;
      message.tbAge = object.tbAge ?? "";
      message.gender = object.gender ?? 0;
      message.privSets = object.privSets !== void 0 && object.privSets !== null ? User_PrivSets.fromPartial(object.privSets) : void 0;
      message.isFriend = object.isFriend ?? 0;
      message.likeForum = object.likeForum?.map((e) => User_LikeForumInfo.fromPartial(e)) || [];
      message.isGuanfang = object.isGuanfang ?? 0;
      message.vipInfo = object.vipInfo !== void 0 && object.vipInfo !== null ? User_UserVipInfo.fromPartial(object.vipInfo) : void 0;
      message.newTshowIcon = object.newTshowIcon?.map((e) => User_TshowInfo.fromPartial(e)) || [];
      message.isFans = object.isFans ?? 0;
      message.newGodData = object.newGodData !== void 0 && object.newGodData !== null ? User_NewGodInfo.fromPartial(object.newGodData) : void 0;
      message.isDefaultAvatar = object.isDefaultAvatar ?? 0;
      message.tiebaUid = object.tiebaUid ?? "";
      message.ipAddress = object.ipAddress ?? "";
      message.virtualImageInfo = object.virtualImageInfo !== void 0 && object.virtualImageInfo !== null ? User_VirtualImageInfo.fromPartial(object.virtualImageInfo) : void 0;
      message.userGrowth = object.userGrowth !== void 0 && object.userGrowth !== null ? User_UserGrowth.fromPartial(object.userGrowth) : void 0;
      return message;
    }
  };
  function createBaseUser_Icon() {
    return { name: "" };
  }
  var User_Icon = {
    encode(message, writer = new BinaryWriter()) {
      if (message.name !== "") {
        writer.uint32(10).string(message.name);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseUser_Icon();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.name = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return { name: isSet10(object.name) ? globalThis.String(object.name) : "" };
    },
    toJSON(message) {
      const obj = {};
      if (message.name !== "") {
        obj.name = message.name;
      }
      return obj;
    },
    create(base) {
      return User_Icon.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseUser_Icon();
      message.name = object.name ?? "";
      return message;
    }
  };
  function createBaseUser_PrivSets() {
    return {
      location: 0,
      like: 0,
      group: 0,
      post: 0,
      friend: 0,
      live: 0,
      reply: 0,
      bazhuShowInside: 0,
      bazhuShowOutside: 0
    };
  }
  var User_PrivSets = {
    encode(message, writer = new BinaryWriter()) {
      if (message.location !== 0) {
        writer.uint32(8).int32(message.location);
      }
      if (message.like !== 0) {
        writer.uint32(16).int32(message.like);
      }
      if (message.group !== 0) {
        writer.uint32(24).int32(message.group);
      }
      if (message.post !== 0) {
        writer.uint32(32).int32(message.post);
      }
      if (message.friend !== 0) {
        writer.uint32(40).int32(message.friend);
      }
      if (message.live !== 0) {
        writer.uint32(48).int32(message.live);
      }
      if (message.reply !== 0) {
        writer.uint32(56).int32(message.reply);
      }
      if (message.bazhuShowInside !== 0) {
        writer.uint32(64).int32(message.bazhuShowInside);
      }
      if (message.bazhuShowOutside !== 0) {
        writer.uint32(72).int32(message.bazhuShowOutside);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseUser_PrivSets();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.location = reader.int32();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.like = reader.int32();
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }
            message.group = reader.int32();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }
            message.post = reader.int32();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }
            message.friend = reader.int32();
            continue;
          }
          case 6: {
            if (tag !== 48) {
              break;
            }
            message.live = reader.int32();
            continue;
          }
          case 7: {
            if (tag !== 56) {
              break;
            }
            message.reply = reader.int32();
            continue;
          }
          case 8: {
            if (tag !== 64) {
              break;
            }
            message.bazhuShowInside = reader.int32();
            continue;
          }
          case 9: {
            if (tag !== 72) {
              break;
            }
            message.bazhuShowOutside = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        location: isSet10(object.location) ? globalThis.Number(object.location) : 0,
        like: isSet10(object.like) ? globalThis.Number(object.like) : 0,
        group: isSet10(object.group) ? globalThis.Number(object.group) : 0,
        post: isSet10(object.post) ? globalThis.Number(object.post) : 0,
        friend: isSet10(object.friend) ? globalThis.Number(object.friend) : 0,
        live: isSet10(object.live) ? globalThis.Number(object.live) : 0,
        reply: isSet10(object.reply) ? globalThis.Number(object.reply) : 0,
        bazhuShowInside: isSet10(object.bazhuShowInside) ? globalThis.Number(object.bazhuShowInside) : isSet10(object.bazhu_show_inside) ? globalThis.Number(object.bazhu_show_inside) : 0,
        bazhuShowOutside: isSet10(object.bazhuShowOutside) ? globalThis.Number(object.bazhuShowOutside) : isSet10(object.bazhu_show_outside) ? globalThis.Number(object.bazhu_show_outside) : 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.location !== 0) {
        obj.location = Math.round(message.location);
      }
      if (message.like !== 0) {
        obj.like = Math.round(message.like);
      }
      if (message.group !== 0) {
        obj.group = Math.round(message.group);
      }
      if (message.post !== 0) {
        obj.post = Math.round(message.post);
      }
      if (message.friend !== 0) {
        obj.friend = Math.round(message.friend);
      }
      if (message.live !== 0) {
        obj.live = Math.round(message.live);
      }
      if (message.reply !== 0) {
        obj.reply = Math.round(message.reply);
      }
      if (message.bazhuShowInside !== 0) {
        obj.bazhuShowInside = Math.round(message.bazhuShowInside);
      }
      if (message.bazhuShowOutside !== 0) {
        obj.bazhuShowOutside = Math.round(message.bazhuShowOutside);
      }
      return obj;
    },
    create(base) {
      return User_PrivSets.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseUser_PrivSets();
      message.location = object.location ?? 0;
      message.like = object.like ?? 0;
      message.group = object.group ?? 0;
      message.post = object.post ?? 0;
      message.friend = object.friend ?? 0;
      message.live = object.live ?? 0;
      message.reply = object.reply ?? 0;
      message.bazhuShowInside = object.bazhuShowInside ?? 0;
      message.bazhuShowOutside = object.bazhuShowOutside ?? 0;
      return message;
    }
  };
  function createBaseUser_LikeForumInfo() {
    return { forumName: "", forumId: "0" };
  }
  var User_LikeForumInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.forumName !== "") {
        writer.uint32(10).string(message.forumName);
      }
      if (message.forumId !== "0") {
        writer.uint32(16).uint64(message.forumId);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseUser_LikeForumInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.forumName = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.forumId = reader.uint64().toString();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        forumName: isSet10(object.forumName) ? globalThis.String(object.forumName) : isSet10(object.forum_name) ? globalThis.String(object.forum_name) : "",
        forumId: isSet10(object.forumId) ? globalThis.String(object.forumId) : isSet10(object.forum_id) ? globalThis.String(object.forum_id) : "0"
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.forumName !== "") {
        obj.forumName = message.forumName;
      }
      if (message.forumId !== "0") {
        obj.forumId = message.forumId;
      }
      return obj;
    },
    create(base) {
      return User_LikeForumInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseUser_LikeForumInfo();
      message.forumName = object.forumName ?? "";
      message.forumId = object.forumId ?? "0";
      return message;
    }
  };
  function createBaseUser_UserVipInfo() {
    return { vStatus: 0, vLevel: 0 };
  }
  var User_UserVipInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.vStatus !== 0) {
        writer.uint32(8).uint32(message.vStatus);
      }
      if (message.vLevel !== 0) {
        writer.uint32(40).uint32(message.vLevel);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseUser_UserVipInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.vStatus = reader.uint32();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }
            message.vLevel = reader.uint32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        vStatus: isSet10(object.vStatus) ? globalThis.Number(object.vStatus) : isSet10(object.v_status) ? globalThis.Number(object.v_status) : 0,
        vLevel: isSet10(object.vLevel) ? globalThis.Number(object.vLevel) : isSet10(object.v_level) ? globalThis.Number(object.v_level) : 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.vStatus !== 0) {
        obj.vStatus = Math.round(message.vStatus);
      }
      if (message.vLevel !== 0) {
        obj.vLevel = Math.round(message.vLevel);
      }
      return obj;
    },
    create(base) {
      return User_UserVipInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseUser_UserVipInfo();
      message.vStatus = object.vStatus ?? 0;
      message.vLevel = object.vLevel ?? 0;
      return message;
    }
  };
  function createBaseUser_TshowInfo() {
    return { name: "" };
  }
  var User_TshowInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.name !== "") {
        writer.uint32(18).string(message.name);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseUser_TshowInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.name = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return { name: isSet10(object.name) ? globalThis.String(object.name) : "" };
    },
    toJSON(message) {
      const obj = {};
      if (message.name !== "") {
        obj.name = message.name;
      }
      return obj;
    },
    create(base) {
      return User_TshowInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseUser_TshowInfo();
      message.name = object.name ?? "";
      return message;
    }
  };
  function createBaseUser_NewGodInfo() {
    return { status: 0, fieldId: 0, fieldName: "" };
  }
  var User_NewGodInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.status !== 0) {
        writer.uint32(8).int32(message.status);
      }
      if (message.fieldId !== 0) {
        writer.uint32(16).uint32(message.fieldId);
      }
      if (message.fieldName !== "") {
        writer.uint32(26).string(message.fieldName);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseUser_NewGodInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.status = reader.int32();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.fieldId = reader.uint32();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.fieldName = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        status: isSet10(object.status) ? globalThis.Number(object.status) : 0,
        fieldId: isSet10(object.fieldId) ? globalThis.Number(object.fieldId) : isSet10(object.field_id) ? globalThis.Number(object.field_id) : 0,
        fieldName: isSet10(object.fieldName) ? globalThis.String(object.fieldName) : isSet10(object.field_name) ? globalThis.String(object.field_name) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.status !== 0) {
        obj.status = Math.round(message.status);
      }
      if (message.fieldId !== 0) {
        obj.fieldId = Math.round(message.fieldId);
      }
      if (message.fieldName !== "") {
        obj.fieldName = message.fieldName;
      }
      return obj;
    },
    create(base) {
      return User_NewGodInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseUser_NewGodInfo();
      message.status = object.status ?? 0;
      message.fieldId = object.fieldId ?? 0;
      message.fieldName = object.fieldName ?? "";
      return message;
    }
  };
  function createBaseUser_VirtualImageInfo() {
    return { issetVirtualImage: 0, personalState: void 0 };
  }
  var User_VirtualImageInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.issetVirtualImage !== 0) {
        writer.uint32(8).int32(message.issetVirtualImage);
      }
      if (message.personalState !== void 0) {
        User_VirtualImageInfo_StateInfo.encode(message.personalState, writer.uint32(74).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseUser_VirtualImageInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.issetVirtualImage = reader.int32();
            continue;
          }
          case 9: {
            if (tag !== 74) {
              break;
            }
            message.personalState = User_VirtualImageInfo_StateInfo.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        issetVirtualImage: isSet10(object.issetVirtualImage) ? globalThis.Number(object.issetVirtualImage) : isSet10(object.isset_virtual_image) ? globalThis.Number(object.isset_virtual_image) : 0,
        personalState: isSet10(object.personalState) ? User_VirtualImageInfo_StateInfo.fromJSON(object.personalState) : isSet10(object.personal_state) ? User_VirtualImageInfo_StateInfo.fromJSON(object.personal_state) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.issetVirtualImage !== 0) {
        obj.issetVirtualImage = Math.round(message.issetVirtualImage);
      }
      if (message.personalState !== void 0) {
        obj.personalState = User_VirtualImageInfo_StateInfo.toJSON(message.personalState);
      }
      return obj;
    },
    create(base) {
      return User_VirtualImageInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseUser_VirtualImageInfo();
      message.issetVirtualImage = object.issetVirtualImage ?? 0;
      message.personalState = object.personalState !== void 0 && object.personalState !== null ? User_VirtualImageInfo_StateInfo.fromPartial(object.personalState) : void 0;
      return message;
    }
  };
  function createBaseUser_VirtualImageInfo_StateInfo() {
    return { text: "" };
  }
  var User_VirtualImageInfo_StateInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.text !== "") {
        writer.uint32(18).string(message.text);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseUser_VirtualImageInfo_StateInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.text = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return { text: isSet10(object.text) ? globalThis.String(object.text) : "" };
    },
    toJSON(message) {
      const obj = {};
      if (message.text !== "") {
        obj.text = message.text;
      }
      return obj;
    },
    create(base) {
      return User_VirtualImageInfo_StateInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseUser_VirtualImageInfo_StateInfo();
      message.text = object.text ?? "";
      return message;
    }
  };
  function createBaseUser_UserGrowth() {
    return { levelId: 0 };
  }
  var User_UserGrowth = {
    encode(message, writer = new BinaryWriter()) {
      if (message.levelId !== 0) {
        writer.uint32(8).uint32(message.levelId);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseUser_UserGrowth();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.levelId = reader.uint32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        levelId: isSet10(object.levelId) ? globalThis.Number(object.levelId) : isSet10(object.level_id) ? globalThis.Number(object.level_id) : 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.levelId !== 0) {
        obj.levelId = Math.round(message.levelId);
      }
      return obj;
    },
    create(base) {
      return User_UserGrowth.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseUser_UserGrowth();
      message.levelId = object.levelId ?? 0;
      return message;
    }
  };
  function isSet10(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/VideoInfo.ts
  function createBaseVideoInfo() {
    return { videoUrl: "", videoDuration: 0, videoWidth: 0, videoHeight: 0, thumbnailUrl: "", playCount: 0 };
  }
  var VideoInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.videoUrl !== "") {
        writer.uint32(18).string(message.videoUrl);
      }
      if (message.videoDuration !== 0) {
        writer.uint32(24).uint32(message.videoDuration);
      }
      if (message.videoWidth !== 0) {
        writer.uint32(32).uint32(message.videoWidth);
      }
      if (message.videoHeight !== 0) {
        writer.uint32(40).uint32(message.videoHeight);
      }
      if (message.thumbnailUrl !== "") {
        writer.uint32(50).string(message.thumbnailUrl);
      }
      if (message.playCount !== 0) {
        writer.uint32(80).int32(message.playCount);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseVideoInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.videoUrl = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }
            message.videoDuration = reader.uint32();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }
            message.videoWidth = reader.uint32();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }
            message.videoHeight = reader.uint32();
            continue;
          }
          case 6: {
            if (tag !== 50) {
              break;
            }
            message.thumbnailUrl = reader.string();
            continue;
          }
          case 10: {
            if (tag !== 80) {
              break;
            }
            message.playCount = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        videoUrl: isSet11(object.videoUrl) ? globalThis.String(object.videoUrl) : isSet11(object.video_url) ? globalThis.String(object.video_url) : "",
        videoDuration: isSet11(object.videoDuration) ? globalThis.Number(object.videoDuration) : isSet11(object.video_duration) ? globalThis.Number(object.video_duration) : 0,
        videoWidth: isSet11(object.videoWidth) ? globalThis.Number(object.videoWidth) : isSet11(object.video_width) ? globalThis.Number(object.video_width) : 0,
        videoHeight: isSet11(object.videoHeight) ? globalThis.Number(object.videoHeight) : isSet11(object.video_height) ? globalThis.Number(object.video_height) : 0,
        thumbnailUrl: isSet11(object.thumbnailUrl) ? globalThis.String(object.thumbnailUrl) : isSet11(object.thumbnail_url) ? globalThis.String(object.thumbnail_url) : "",
        playCount: isSet11(object.playCount) ? globalThis.Number(object.playCount) : isSet11(object.play_count) ? globalThis.Number(object.play_count) : 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.videoUrl !== "") {
        obj.videoUrl = message.videoUrl;
      }
      if (message.videoDuration !== 0) {
        obj.videoDuration = Math.round(message.videoDuration);
      }
      if (message.videoWidth !== 0) {
        obj.videoWidth = Math.round(message.videoWidth);
      }
      if (message.videoHeight !== 0) {
        obj.videoHeight = Math.round(message.videoHeight);
      }
      if (message.thumbnailUrl !== "") {
        obj.thumbnailUrl = message.thumbnailUrl;
      }
      if (message.playCount !== 0) {
        obj.playCount = Math.round(message.playCount);
      }
      return obj;
    },
    create(base) {
      return VideoInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseVideoInfo();
      message.videoUrl = object.videoUrl ?? "";
      message.videoDuration = object.videoDuration ?? 0;
      message.videoWidth = object.videoWidth ?? 0;
      message.videoHeight = object.videoHeight ?? 0;
      message.thumbnailUrl = object.thumbnailUrl ?? "";
      message.playCount = object.playCount ?? 0;
      return message;
    }
  };
  function isSet11(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/Voice.ts
  function createBaseVoice() {
    return { type: 0, duringTime: 0, voiceMd5: "", voiceUrl: "", uid: "0" };
  }
  var Voice = {
    encode(message, writer = new BinaryWriter()) {
      if (message.type !== 0) {
        writer.uint32(8).int32(message.type);
      }
      if (message.duringTime !== 0) {
        writer.uint32(16).int32(message.duringTime);
      }
      if (message.voiceMd5 !== "") {
        writer.uint32(26).string(message.voiceMd5);
      }
      if (message.voiceUrl !== "") {
        writer.uint32(34).string(message.voiceUrl);
      }
      if (message.uid !== "0") {
        writer.uint32(40).int64(message.uid);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseVoice();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.type = reader.int32();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.duringTime = reader.int32();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.voiceMd5 = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }
            message.voiceUrl = reader.string();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }
            message.uid = reader.int64().toString();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        type: isSet12(object.type) ? globalThis.Number(object.type) : 0,
        duringTime: isSet12(object.duringTime) ? globalThis.Number(object.duringTime) : isSet12(object.during_time) ? globalThis.Number(object.during_time) : 0,
        voiceMd5: isSet12(object.voiceMd5) ? globalThis.String(object.voiceMd5) : isSet12(object.voice_md5) ? globalThis.String(object.voice_md5) : "",
        voiceUrl: isSet12(object.voiceUrl) ? globalThis.String(object.voiceUrl) : isSet12(object.voice_url) ? globalThis.String(object.voice_url) : "",
        uid: isSet12(object.uid) ? globalThis.String(object.uid) : "0"
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.type !== 0) {
        obj.type = Math.round(message.type);
      }
      if (message.duringTime !== 0) {
        obj.duringTime = Math.round(message.duringTime);
      }
      if (message.voiceMd5 !== "") {
        obj.voiceMd5 = message.voiceMd5;
      }
      if (message.voiceUrl !== "") {
        obj.voiceUrl = message.voiceUrl;
      }
      if (message.uid !== "0") {
        obj.uid = message.uid;
      }
      return obj;
    },
    create(base) {
      return Voice.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseVoice();
      message.type = object.type ?? 0;
      message.duringTime = object.duringTime ?? 0;
      message.voiceMd5 = object.voiceMd5 ?? "";
      message.voiceUrl = object.voiceUrl ?? "";
      message.uid = object.uid ?? "0";
      return message;
    }
  };
  function isSet12(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/ThreadInfo.ts
  function createBaseThreadInfo() {
    return {
      id: "0",
      title: "",
      replyNum: 0,
      viewNum: 0,
      lastTimeInt: 0,
      isTop: 0,
      isGood: 0,
      isVoiceThread: 0,
      author: void 0,
      voiceInfo: [],
      threadType: 0,
      fid: "0",
      fname: "",
      isLivepost: 0,
      firstPostId: "0",
      createTime: 0,
      postId: "0",
      authorId: "0",
      isAd: 0,
      pollInfo: void 0,
      videoInfo: void 0,
      isGodthreadRecommend: 0,
      agree: void 0,
      shareNum: 0,
      originThreadInfo: void 0,
      firstPostContent: [],
      isShareThread: 0,
      tabId: 0,
      isDeleted: 0,
      isFrsMask: 0,
      customFigure: void 0,
      customState: void 0
    };
  }
  var ThreadInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.id !== "0") {
        writer.uint32(8).int64(message.id);
      }
      if (message.title !== "") {
        writer.uint32(26).string(message.title);
      }
      if (message.replyNum !== 0) {
        writer.uint32(32).int32(message.replyNum);
      }
      if (message.viewNum !== 0) {
        writer.uint32(40).int32(message.viewNum);
      }
      if (message.lastTimeInt !== 0) {
        writer.uint32(56).int32(message.lastTimeInt);
      }
      if (message.isTop !== 0) {
        writer.uint32(72).int32(message.isTop);
      }
      if (message.isGood !== 0) {
        writer.uint32(80).int32(message.isGood);
      }
      if (message.isVoiceThread !== 0) {
        writer.uint32(120).int32(message.isVoiceThread);
      }
      if (message.author !== void 0) {
        User.encode(message.author, writer.uint32(146).fork()).join();
      }
      for (const v of message.voiceInfo) {
        Voice.encode(v, writer.uint32(186).fork()).join();
      }
      if (message.threadType !== 0) {
        writer.uint32(208).int32(message.threadType);
      }
      if (message.fid !== "0") {
        writer.uint32(216).int64(message.fid);
      }
      if (message.fname !== "") {
        writer.uint32(226).string(message.fname);
      }
      if (message.isLivepost !== 0) {
        writer.uint32(240).int32(message.isLivepost);
      }
      if (message.firstPostId !== "0") {
        writer.uint32(320).int64(message.firstPostId);
      }
      if (message.createTime !== 0) {
        writer.uint32(360).int32(message.createTime);
      }
      if (message.postId !== "0") {
        writer.uint32(416).int64(message.postId);
      }
      if (message.authorId !== "0") {
        writer.uint32(448).int64(message.authorId);
      }
      if (message.isAd !== 0) {
        writer.uint32(472).uint32(message.isAd);
      }
      if (message.pollInfo !== void 0) {
        PollInfo.encode(message.pollInfo, writer.uint32(594).fork()).join();
      }
      if (message.videoInfo !== void 0) {
        VideoInfo.encode(message.videoInfo, writer.uint32(634).fork()).join();
      }
      if (message.isGodthreadRecommend !== 0) {
        writer.uint32(680).int32(message.isGodthreadRecommend);
      }
      if (message.agree !== void 0) {
        Agree.encode(message.agree, writer.uint32(1010).fork()).join();
      }
      if (message.shareNum !== 0) {
        writer.uint32(1080).int32(message.shareNum);
      }
      if (message.originThreadInfo !== void 0) {
        ThreadInfo_OriginThreadInfo.encode(message.originThreadInfo, writer.uint32(1130).fork()).join();
      }
      for (const v of message.firstPostContent) {
        PbContent.encode(v, writer.uint32(1138).fork()).join();
      }
      if (message.isShareThread !== 0) {
        writer.uint32(1144).int32(message.isShareThread);
      }
      if (message.tabId !== 0) {
        writer.uint32(1400).int32(message.tabId);
      }
      if (message.isDeleted !== 0) {
        writer.uint32(1448).int32(message.isDeleted);
      }
      if (message.isFrsMask !== 0) {
        writer.uint32(1584).int32(message.isFrsMask);
      }
      if (message.customFigure !== void 0) {
        ThreadInfo_CustomFigure.encode(message.customFigure, writer.uint32(1690).fork()).join();
      }
      if (message.customState !== void 0) {
        ThreadInfo_CustomState.encode(message.customState, writer.uint32(1698).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseThreadInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.id = reader.int64().toString();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.title = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }
            message.replyNum = reader.int32();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }
            message.viewNum = reader.int32();
            continue;
          }
          case 7: {
            if (tag !== 56) {
              break;
            }
            message.lastTimeInt = reader.int32();
            continue;
          }
          case 9: {
            if (tag !== 72) {
              break;
            }
            message.isTop = reader.int32();
            continue;
          }
          case 10: {
            if (tag !== 80) {
              break;
            }
            message.isGood = reader.int32();
            continue;
          }
          case 15: {
            if (tag !== 120) {
              break;
            }
            message.isVoiceThread = reader.int32();
            continue;
          }
          case 18: {
            if (tag !== 146) {
              break;
            }
            message.author = User.decode(reader, reader.uint32());
            continue;
          }
          case 23: {
            if (tag !== 186) {
              break;
            }
            message.voiceInfo.push(Voice.decode(reader, reader.uint32()));
            continue;
          }
          case 26: {
            if (tag !== 208) {
              break;
            }
            message.threadType = reader.int32();
            continue;
          }
          case 27: {
            if (tag !== 216) {
              break;
            }
            message.fid = reader.int64().toString();
            continue;
          }
          case 28: {
            if (tag !== 226) {
              break;
            }
            message.fname = reader.string();
            continue;
          }
          case 30: {
            if (tag !== 240) {
              break;
            }
            message.isLivepost = reader.int32();
            continue;
          }
          case 40: {
            if (tag !== 320) {
              break;
            }
            message.firstPostId = reader.int64().toString();
            continue;
          }
          case 45: {
            if (tag !== 360) {
              break;
            }
            message.createTime = reader.int32();
            continue;
          }
          case 52: {
            if (tag !== 416) {
              break;
            }
            message.postId = reader.int64().toString();
            continue;
          }
          case 56: {
            if (tag !== 448) {
              break;
            }
            message.authorId = reader.int64().toString();
            continue;
          }
          case 59: {
            if (tag !== 472) {
              break;
            }
            message.isAd = reader.uint32();
            continue;
          }
          case 74: {
            if (tag !== 594) {
              break;
            }
            message.pollInfo = PollInfo.decode(reader, reader.uint32());
            continue;
          }
          case 79: {
            if (tag !== 634) {
              break;
            }
            message.videoInfo = VideoInfo.decode(reader, reader.uint32());
            continue;
          }
          case 85: {
            if (tag !== 680) {
              break;
            }
            message.isGodthreadRecommend = reader.int32();
            continue;
          }
          case 126: {
            if (tag !== 1010) {
              break;
            }
            message.agree = Agree.decode(reader, reader.uint32());
            continue;
          }
          case 135: {
            if (tag !== 1080) {
              break;
            }
            message.shareNum = reader.int32();
            continue;
          }
          case 141: {
            if (tag !== 1130) {
              break;
            }
            message.originThreadInfo = ThreadInfo_OriginThreadInfo.decode(reader, reader.uint32());
            continue;
          }
          case 142: {
            if (tag !== 1138) {
              break;
            }
            message.firstPostContent.push(PbContent.decode(reader, reader.uint32()));
            continue;
          }
          case 143: {
            if (tag !== 1144) {
              break;
            }
            message.isShareThread = reader.int32();
            continue;
          }
          case 175: {
            if (tag !== 1400) {
              break;
            }
            message.tabId = reader.int32();
            continue;
          }
          case 181: {
            if (tag !== 1448) {
              break;
            }
            message.isDeleted = reader.int32();
            continue;
          }
          case 198: {
            if (tag !== 1584) {
              break;
            }
            message.isFrsMask = reader.int32();
            continue;
          }
          case 211: {
            if (tag !== 1690) {
              break;
            }
            message.customFigure = ThreadInfo_CustomFigure.decode(reader, reader.uint32());
            continue;
          }
          case 212: {
            if (tag !== 1698) {
              break;
            }
            message.customState = ThreadInfo_CustomState.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        id: isSet13(object.id) ? globalThis.String(object.id) : "0",
        title: isSet13(object.title) ? globalThis.String(object.title) : "",
        replyNum: isSet13(object.replyNum) ? globalThis.Number(object.replyNum) : isSet13(object.reply_num) ? globalThis.Number(object.reply_num) : 0,
        viewNum: isSet13(object.viewNum) ? globalThis.Number(object.viewNum) : isSet13(object.view_num) ? globalThis.Number(object.view_num) : 0,
        lastTimeInt: isSet13(object.lastTimeInt) ? globalThis.Number(object.lastTimeInt) : isSet13(object.last_time_int) ? globalThis.Number(object.last_time_int) : 0,
        isTop: isSet13(object.isTop) ? globalThis.Number(object.isTop) : isSet13(object.is_top) ? globalThis.Number(object.is_top) : 0,
        isGood: isSet13(object.isGood) ? globalThis.Number(object.isGood) : isSet13(object.is_good) ? globalThis.Number(object.is_good) : 0,
        isVoiceThread: isSet13(object.isVoiceThread) ? globalThis.Number(object.isVoiceThread) : isSet13(object.is_voice_thread) ? globalThis.Number(object.is_voice_thread) : 0,
        author: isSet13(object.author) ? User.fromJSON(object.author) : void 0,
        voiceInfo: globalThis.Array.isArray(object?.voiceInfo) ? object.voiceInfo.map((e) => Voice.fromJSON(e)) : globalThis.Array.isArray(object?.voice_info) ? object.voice_info.map((e) => Voice.fromJSON(e)) : [],
        threadType: isSet13(object.threadType) ? globalThis.Number(object.threadType) : isSet13(object.thread_type) ? globalThis.Number(object.thread_type) : 0,
        fid: isSet13(object.fid) ? globalThis.String(object.fid) : "0",
        fname: isSet13(object.fname) ? globalThis.String(object.fname) : "",
        isLivepost: isSet13(object.isLivepost) ? globalThis.Number(object.isLivepost) : isSet13(object.is_livepost) ? globalThis.Number(object.is_livepost) : 0,
        firstPostId: isSet13(object.firstPostId) ? globalThis.String(object.firstPostId) : isSet13(object.first_post_id) ? globalThis.String(object.first_post_id) : "0",
        createTime: isSet13(object.createTime) ? globalThis.Number(object.createTime) : isSet13(object.create_time) ? globalThis.Number(object.create_time) : 0,
        postId: isSet13(object.postId) ? globalThis.String(object.postId) : isSet13(object.post_id) ? globalThis.String(object.post_id) : "0",
        authorId: isSet13(object.authorId) ? globalThis.String(object.authorId) : isSet13(object.author_id) ? globalThis.String(object.author_id) : "0",
        isAd: isSet13(object.isAd) ? globalThis.Number(object.isAd) : isSet13(object.is_ad) ? globalThis.Number(object.is_ad) : 0,
        pollInfo: isSet13(object.pollInfo) ? PollInfo.fromJSON(object.pollInfo) : isSet13(object.poll_info) ? PollInfo.fromJSON(object.poll_info) : void 0,
        videoInfo: isSet13(object.videoInfo) ? VideoInfo.fromJSON(object.videoInfo) : isSet13(object.video_info) ? VideoInfo.fromJSON(object.video_info) : void 0,
        isGodthreadRecommend: isSet13(object.isGodthreadRecommend) ? globalThis.Number(object.isGodthreadRecommend) : isSet13(object.is_godthread_recommend) ? globalThis.Number(object.is_godthread_recommend) : 0,
        agree: isSet13(object.agree) ? Agree.fromJSON(object.agree) : void 0,
        shareNum: isSet13(object.shareNum) ? globalThis.Number(object.shareNum) : isSet13(object.share_num) ? globalThis.Number(object.share_num) : 0,
        originThreadInfo: isSet13(object.originThreadInfo) ? ThreadInfo_OriginThreadInfo.fromJSON(object.originThreadInfo) : isSet13(object.origin_thread_info) ? ThreadInfo_OriginThreadInfo.fromJSON(object.origin_thread_info) : void 0,
        firstPostContent: globalThis.Array.isArray(object?.firstPostContent) ? object.firstPostContent.map((e) => PbContent.fromJSON(e)) : globalThis.Array.isArray(object?.first_post_content) ? object.first_post_content.map((e) => PbContent.fromJSON(e)) : [],
        isShareThread: isSet13(object.isShareThread) ? globalThis.Number(object.isShareThread) : isSet13(object.is_share_thread) ? globalThis.Number(object.is_share_thread) : 0,
        tabId: isSet13(object.tabId) ? globalThis.Number(object.tabId) : isSet13(object.tab_id) ? globalThis.Number(object.tab_id) : 0,
        isDeleted: isSet13(object.isDeleted) ? globalThis.Number(object.isDeleted) : isSet13(object.is_deleted) ? globalThis.Number(object.is_deleted) : 0,
        isFrsMask: isSet13(object.isFrsMask) ? globalThis.Number(object.isFrsMask) : isSet13(object.is_frs_mask) ? globalThis.Number(object.is_frs_mask) : 0,
        customFigure: isSet13(object.customFigure) ? ThreadInfo_CustomFigure.fromJSON(object.customFigure) : isSet13(object.custom_figure) ? ThreadInfo_CustomFigure.fromJSON(object.custom_figure) : void 0,
        customState: isSet13(object.customState) ? ThreadInfo_CustomState.fromJSON(object.customState) : isSet13(object.custom_state) ? ThreadInfo_CustomState.fromJSON(object.custom_state) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.id !== "0") {
        obj.id = message.id;
      }
      if (message.title !== "") {
        obj.title = message.title;
      }
      if (message.replyNum !== 0) {
        obj.replyNum = Math.round(message.replyNum);
      }
      if (message.viewNum !== 0) {
        obj.viewNum = Math.round(message.viewNum);
      }
      if (message.lastTimeInt !== 0) {
        obj.lastTimeInt = Math.round(message.lastTimeInt);
      }
      if (message.isTop !== 0) {
        obj.isTop = Math.round(message.isTop);
      }
      if (message.isGood !== 0) {
        obj.isGood = Math.round(message.isGood);
      }
      if (message.isVoiceThread !== 0) {
        obj.isVoiceThread = Math.round(message.isVoiceThread);
      }
      if (message.author !== void 0) {
        obj.author = User.toJSON(message.author);
      }
      if (message.voiceInfo?.length) {
        obj.voiceInfo = message.voiceInfo.map((e) => Voice.toJSON(e));
      }
      if (message.threadType !== 0) {
        obj.threadType = Math.round(message.threadType);
      }
      if (message.fid !== "0") {
        obj.fid = message.fid;
      }
      if (message.fname !== "") {
        obj.fname = message.fname;
      }
      if (message.isLivepost !== 0) {
        obj.isLivepost = Math.round(message.isLivepost);
      }
      if (message.firstPostId !== "0") {
        obj.firstPostId = message.firstPostId;
      }
      if (message.createTime !== 0) {
        obj.createTime = Math.round(message.createTime);
      }
      if (message.postId !== "0") {
        obj.postId = message.postId;
      }
      if (message.authorId !== "0") {
        obj.authorId = message.authorId;
      }
      if (message.isAd !== 0) {
        obj.isAd = Math.round(message.isAd);
      }
      if (message.pollInfo !== void 0) {
        obj.pollInfo = PollInfo.toJSON(message.pollInfo);
      }
      if (message.videoInfo !== void 0) {
        obj.videoInfo = VideoInfo.toJSON(message.videoInfo);
      }
      if (message.isGodthreadRecommend !== 0) {
        obj.isGodthreadRecommend = Math.round(message.isGodthreadRecommend);
      }
      if (message.agree !== void 0) {
        obj.agree = Agree.toJSON(message.agree);
      }
      if (message.shareNum !== 0) {
        obj.shareNum = Math.round(message.shareNum);
      }
      if (message.originThreadInfo !== void 0) {
        obj.originThreadInfo = ThreadInfo_OriginThreadInfo.toJSON(message.originThreadInfo);
      }
      if (message.firstPostContent?.length) {
        obj.firstPostContent = message.firstPostContent.map((e) => PbContent.toJSON(e));
      }
      if (message.isShareThread !== 0) {
        obj.isShareThread = Math.round(message.isShareThread);
      }
      if (message.tabId !== 0) {
        obj.tabId = Math.round(message.tabId);
      }
      if (message.isDeleted !== 0) {
        obj.isDeleted = Math.round(message.isDeleted);
      }
      if (message.isFrsMask !== 0) {
        obj.isFrsMask = Math.round(message.isFrsMask);
      }
      if (message.customFigure !== void 0) {
        obj.customFigure = ThreadInfo_CustomFigure.toJSON(message.customFigure);
      }
      if (message.customState !== void 0) {
        obj.customState = ThreadInfo_CustomState.toJSON(message.customState);
      }
      return obj;
    },
    create(base) {
      return ThreadInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseThreadInfo();
      message.id = object.id ?? "0";
      message.title = object.title ?? "";
      message.replyNum = object.replyNum ?? 0;
      message.viewNum = object.viewNum ?? 0;
      message.lastTimeInt = object.lastTimeInt ?? 0;
      message.isTop = object.isTop ?? 0;
      message.isGood = object.isGood ?? 0;
      message.isVoiceThread = object.isVoiceThread ?? 0;
      message.author = object.author !== void 0 && object.author !== null ? User.fromPartial(object.author) : void 0;
      message.voiceInfo = object.voiceInfo?.map((e) => Voice.fromPartial(e)) || [];
      message.threadType = object.threadType ?? 0;
      message.fid = object.fid ?? "0";
      message.fname = object.fname ?? "";
      message.isLivepost = object.isLivepost ?? 0;
      message.firstPostId = object.firstPostId ?? "0";
      message.createTime = object.createTime ?? 0;
      message.postId = object.postId ?? "0";
      message.authorId = object.authorId ?? "0";
      message.isAd = object.isAd ?? 0;
      message.pollInfo = object.pollInfo !== void 0 && object.pollInfo !== null ? PollInfo.fromPartial(object.pollInfo) : void 0;
      message.videoInfo = object.videoInfo !== void 0 && object.videoInfo !== null ? VideoInfo.fromPartial(object.videoInfo) : void 0;
      message.isGodthreadRecommend = object.isGodthreadRecommend ?? 0;
      message.agree = object.agree !== void 0 && object.agree !== null ? Agree.fromPartial(object.agree) : void 0;
      message.shareNum = object.shareNum ?? 0;
      message.originThreadInfo = object.originThreadInfo !== void 0 && object.originThreadInfo !== null ? ThreadInfo_OriginThreadInfo.fromPartial(object.originThreadInfo) : void 0;
      message.firstPostContent = object.firstPostContent?.map((e) => PbContent.fromPartial(e)) || [];
      message.isShareThread = object.isShareThread ?? 0;
      message.tabId = object.tabId ?? 0;
      message.isDeleted = object.isDeleted ?? 0;
      message.isFrsMask = object.isFrsMask ?? 0;
      message.customFigure = object.customFigure !== void 0 && object.customFigure !== null ? ThreadInfo_CustomFigure.fromPartial(object.customFigure) : void 0;
      message.customState = object.customState !== void 0 && object.customState !== null ? ThreadInfo_CustomState.fromPartial(object.customState) : void 0;
      return message;
    }
  };
  function createBaseThreadInfo_OriginThreadInfo() {
    return {
      title: "",
      media: [],
      fname: "",
      tid: "",
      fid: "0",
      voiceInfo: [],
      videoInfo: void 0,
      content: [],
      pollInfo: void 0,
      pid: "0"
    };
  }
  var ThreadInfo_OriginThreadInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.title !== "") {
        writer.uint32(10).string(message.title);
      }
      for (const v of message.media) {
        Media.encode(v, writer.uint32(18).fork()).join();
      }
      if (message.fname !== "") {
        writer.uint32(34).string(message.fname);
      }
      if (message.tid !== "") {
        writer.uint32(42).string(message.tid);
      }
      if (message.fid !== "0") {
        writer.uint32(56).int64(message.fid);
      }
      for (const v of message.voiceInfo) {
        Voice.encode(v, writer.uint32(98).fork()).join();
      }
      if (message.videoInfo !== void 0) {
        VideoInfo.encode(message.videoInfo, writer.uint32(106).fork()).join();
      }
      for (const v of message.content) {
        PbContent.encode(v, writer.uint32(114).fork()).join();
      }
      if (message.pollInfo !== void 0) {
        PollInfo.encode(message.pollInfo, writer.uint32(170).fork()).join();
      }
      if (message.pid !== "0") {
        writer.uint32(200).int64(message.pid);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseThreadInfo_OriginThreadInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.title = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.media.push(Media.decode(reader, reader.uint32()));
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }
            message.fname = reader.string();
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }
            message.tid = reader.string();
            continue;
          }
          case 7: {
            if (tag !== 56) {
              break;
            }
            message.fid = reader.int64().toString();
            continue;
          }
          case 12: {
            if (tag !== 98) {
              break;
            }
            message.voiceInfo.push(Voice.decode(reader, reader.uint32()));
            continue;
          }
          case 13: {
            if (tag !== 106) {
              break;
            }
            message.videoInfo = VideoInfo.decode(reader, reader.uint32());
            continue;
          }
          case 14: {
            if (tag !== 114) {
              break;
            }
            message.content.push(PbContent.decode(reader, reader.uint32()));
            continue;
          }
          case 21: {
            if (tag !== 170) {
              break;
            }
            message.pollInfo = PollInfo.decode(reader, reader.uint32());
            continue;
          }
          case 25: {
            if (tag !== 200) {
              break;
            }
            message.pid = reader.int64().toString();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        title: isSet13(object.title) ? globalThis.String(object.title) : "",
        media: globalThis.Array.isArray(object?.media) ? object.media.map((e) => Media.fromJSON(e)) : [],
        fname: isSet13(object.fname) ? globalThis.String(object.fname) : "",
        tid: isSet13(object.tid) ? globalThis.String(object.tid) : "",
        fid: isSet13(object.fid) ? globalThis.String(object.fid) : "0",
        voiceInfo: globalThis.Array.isArray(object?.voiceInfo) ? object.voiceInfo.map((e) => Voice.fromJSON(e)) : globalThis.Array.isArray(object?.voice_info) ? object.voice_info.map((e) => Voice.fromJSON(e)) : [],
        videoInfo: isSet13(object.videoInfo) ? VideoInfo.fromJSON(object.videoInfo) : isSet13(object.video_info) ? VideoInfo.fromJSON(object.video_info) : void 0,
        content: globalThis.Array.isArray(object?.content) ? object.content.map((e) => PbContent.fromJSON(e)) : [],
        pollInfo: isSet13(object.pollInfo) ? PollInfo.fromJSON(object.pollInfo) : isSet13(object.poll_info) ? PollInfo.fromJSON(object.poll_info) : void 0,
        pid: isSet13(object.pid) ? globalThis.String(object.pid) : "0"
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.title !== "") {
        obj.title = message.title;
      }
      if (message.media?.length) {
        obj.media = message.media.map((e) => Media.toJSON(e));
      }
      if (message.fname !== "") {
        obj.fname = message.fname;
      }
      if (message.tid !== "") {
        obj.tid = message.tid;
      }
      if (message.fid !== "0") {
        obj.fid = message.fid;
      }
      if (message.voiceInfo?.length) {
        obj.voiceInfo = message.voiceInfo.map((e) => Voice.toJSON(e));
      }
      if (message.videoInfo !== void 0) {
        obj.videoInfo = VideoInfo.toJSON(message.videoInfo);
      }
      if (message.content?.length) {
        obj.content = message.content.map((e) => PbContent.toJSON(e));
      }
      if (message.pollInfo !== void 0) {
        obj.pollInfo = PollInfo.toJSON(message.pollInfo);
      }
      if (message.pid !== "0") {
        obj.pid = message.pid;
      }
      return obj;
    },
    create(base) {
      return ThreadInfo_OriginThreadInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseThreadInfo_OriginThreadInfo();
      message.title = object.title ?? "";
      message.media = object.media?.map((e) => Media.fromPartial(e)) || [];
      message.fname = object.fname ?? "";
      message.tid = object.tid ?? "";
      message.fid = object.fid ?? "0";
      message.voiceInfo = object.voiceInfo?.map((e) => Voice.fromPartial(e)) || [];
      message.videoInfo = object.videoInfo !== void 0 && object.videoInfo !== null ? VideoInfo.fromPartial(object.videoInfo) : void 0;
      message.content = object.content?.map((e) => PbContent.fromPartial(e)) || [];
      message.pollInfo = object.pollInfo !== void 0 && object.pollInfo !== null ? PollInfo.fromPartial(object.pollInfo) : void 0;
      message.pid = object.pid ?? "0";
      return message;
    }
  };
  function createBaseThreadInfo_CustomFigure() {
    return { backgroundValue: "" };
  }
  var ThreadInfo_CustomFigure = {
    encode(message, writer = new BinaryWriter()) {
      if (message.backgroundValue !== "") {
        writer.uint32(26).string(message.backgroundValue);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseThreadInfo_CustomFigure();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.backgroundValue = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        backgroundValue: isSet13(object.backgroundValue) ? globalThis.String(object.backgroundValue) : isSet13(object.background_value) ? globalThis.String(object.background_value) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.backgroundValue !== "") {
        obj.backgroundValue = message.backgroundValue;
      }
      return obj;
    },
    create(base) {
      return ThreadInfo_CustomFigure.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseThreadInfo_CustomFigure();
      message.backgroundValue = object.backgroundValue ?? "";
      return message;
    }
  };
  function createBaseThreadInfo_CustomState() {
    return { content: "" };
  }
  var ThreadInfo_CustomState = {
    encode(message, writer = new BinaryWriter()) {
      if (message.content !== "") {
        writer.uint32(18).string(message.content);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseThreadInfo_CustomState();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.content = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return { content: isSet13(object.content) ? globalThis.String(object.content) : "" };
    },
    toJSON(message) {
      const obj = {};
      if (message.content !== "") {
        obj.content = message.content;
      }
      return obj;
    },
    create(base) {
      return ThreadInfo_CustomState.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseThreadInfo_CustomState();
      message.content = object.content ?? "";
      return message;
    }
  };
  function isSet13(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/FrsPageResIdl.ts
  function createBaseFrsPageResIdl() {
    return { error: void 0, data: void 0 };
  }
  var FrsPageResIdl = {
    encode(message, writer = new BinaryWriter()) {
      if (message.error !== void 0) {
        Error4.encode(message.error, writer.uint32(10).fork()).join();
      }
      if (message.data !== void 0) {
        FrsPageResIdl_DataRes.encode(message.data, writer.uint32(18).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseFrsPageResIdl();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.error = Error4.decode(reader, reader.uint32());
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.data = FrsPageResIdl_DataRes.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        error: isSet14(object.error) ? Error4.fromJSON(object.error) : void 0,
        data: isSet14(object.data) ? FrsPageResIdl_DataRes.fromJSON(object.data) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.error !== void 0) {
        obj.error = Error4.toJSON(message.error);
      }
      if (message.data !== void 0) {
        obj.data = FrsPageResIdl_DataRes.toJSON(message.data);
      }
      return obj;
    },
    create(base) {
      return FrsPageResIdl.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseFrsPageResIdl();
      message.error = object.error !== void 0 && object.error !== null ? Error4.fromPartial(object.error) : void 0;
      message.data = object.data !== void 0 && object.data !== null ? FrsPageResIdl_DataRes.fromPartial(object.data) : void 0;
      return message;
    }
  };
  function createBaseFrsPageResIdl_DataRes() {
    return {
      forum: void 0,
      page: void 0,
      threadList: [],
      userList: [],
      navTabInfo: void 0,
      forumRule: void 0
    };
  }
  var FrsPageResIdl_DataRes = {
    encode(message, writer = new BinaryWriter()) {
      if (message.forum !== void 0) {
        FrsPageResIdl_DataRes_ForumInfo.encode(message.forum, writer.uint32(18).fork()).join();
      }
      if (message.page !== void 0) {
        Page.encode(message.page, writer.uint32(34).fork()).join();
      }
      for (const v of message.threadList) {
        ThreadInfo.encode(v, writer.uint32(58).fork()).join();
      }
      for (const v of message.userList) {
        User.encode(v, writer.uint32(138).fork()).join();
      }
      if (message.navTabInfo !== void 0) {
        FrsPageResIdl_DataRes_NavTabInfo.encode(message.navTabInfo, writer.uint32(298).fork()).join();
      }
      if (message.forumRule !== void 0) {
        FrsPageResIdl_DataRes_ForumRuleStatus.encode(message.forumRule, writer.uint32(842).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseFrsPageResIdl_DataRes();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.forum = FrsPageResIdl_DataRes_ForumInfo.decode(reader, reader.uint32());
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }
            message.page = Page.decode(reader, reader.uint32());
            continue;
          }
          case 7: {
            if (tag !== 58) {
              break;
            }
            message.threadList.push(ThreadInfo.decode(reader, reader.uint32()));
            continue;
          }
          case 17: {
            if (tag !== 138) {
              break;
            }
            message.userList.push(User.decode(reader, reader.uint32()));
            continue;
          }
          case 37: {
            if (tag !== 298) {
              break;
            }
            message.navTabInfo = FrsPageResIdl_DataRes_NavTabInfo.decode(reader, reader.uint32());
            continue;
          }
          case 105: {
            if (tag !== 842) {
              break;
            }
            message.forumRule = FrsPageResIdl_DataRes_ForumRuleStatus.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        forum: isSet14(object.forum) ? FrsPageResIdl_DataRes_ForumInfo.fromJSON(object.forum) : void 0,
        page: isSet14(object.page) ? Page.fromJSON(object.page) : void 0,
        threadList: globalThis.Array.isArray(object?.threadList) ? object.threadList.map((e) => ThreadInfo.fromJSON(e)) : globalThis.Array.isArray(object?.thread_list) ? object.thread_list.map((e) => ThreadInfo.fromJSON(e)) : [],
        userList: globalThis.Array.isArray(object?.userList) ? object.userList.map((e) => User.fromJSON(e)) : globalThis.Array.isArray(object?.user_list) ? object.user_list.map((e) => User.fromJSON(e)) : [],
        navTabInfo: isSet14(object.navTabInfo) ? FrsPageResIdl_DataRes_NavTabInfo.fromJSON(object.navTabInfo) : isSet14(object.nav_tab_info) ? FrsPageResIdl_DataRes_NavTabInfo.fromJSON(object.nav_tab_info) : void 0,
        forumRule: isSet14(object.forumRule) ? FrsPageResIdl_DataRes_ForumRuleStatus.fromJSON(object.forumRule) : isSet14(object.forum_rule) ? FrsPageResIdl_DataRes_ForumRuleStatus.fromJSON(object.forum_rule) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.forum !== void 0) {
        obj.forum = FrsPageResIdl_DataRes_ForumInfo.toJSON(message.forum);
      }
      if (message.page !== void 0) {
        obj.page = Page.toJSON(message.page);
      }
      if (message.threadList?.length) {
        obj.threadList = message.threadList.map((e) => ThreadInfo.toJSON(e));
      }
      if (message.userList?.length) {
        obj.userList = message.userList.map((e) => User.toJSON(e));
      }
      if (message.navTabInfo !== void 0) {
        obj.navTabInfo = FrsPageResIdl_DataRes_NavTabInfo.toJSON(message.navTabInfo);
      }
      if (message.forumRule !== void 0) {
        obj.forumRule = FrsPageResIdl_DataRes_ForumRuleStatus.toJSON(message.forumRule);
      }
      return obj;
    },
    create(base) {
      return FrsPageResIdl_DataRes.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseFrsPageResIdl_DataRes();
      message.forum = object.forum !== void 0 && object.forum !== null ? FrsPageResIdl_DataRes_ForumInfo.fromPartial(object.forum) : void 0;
      message.page = object.page !== void 0 && object.page !== null ? Page.fromPartial(object.page) : void 0;
      message.threadList = object.threadList?.map((e) => ThreadInfo.fromPartial(e)) || [];
      message.userList = object.userList?.map((e) => User.fromPartial(e)) || [];
      message.navTabInfo = object.navTabInfo !== void 0 && object.navTabInfo !== null ? FrsPageResIdl_DataRes_NavTabInfo.fromPartial(object.navTabInfo) : void 0;
      message.forumRule = object.forumRule !== void 0 && object.forumRule !== null ? FrsPageResIdl_DataRes_ForumRuleStatus.fromPartial(object.forumRule) : void 0;
      return message;
    }
  };
  function createBaseFrsPageResIdl_DataRes_ForumInfo() {
    return { id: "0", name: "", firstClass: "", secondClass: "", memberNum: 0, threadNum: 0, postNum: 0, managers: [] };
  }
  var FrsPageResIdl_DataRes_ForumInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.id !== "0") {
        writer.uint32(8).int64(message.id);
      }
      if (message.name !== "") {
        writer.uint32(18).string(message.name);
      }
      if (message.firstClass !== "") {
        writer.uint32(26).string(message.firstClass);
      }
      if (message.secondClass !== "") {
        writer.uint32(34).string(message.secondClass);
      }
      if (message.memberNum !== 0) {
        writer.uint32(72).int32(message.memberNum);
      }
      if (message.threadNum !== 0) {
        writer.uint32(80).int32(message.threadNum);
      }
      if (message.postNum !== 0) {
        writer.uint32(88).int32(message.postNum);
      }
      for (const v of message.managers) {
        FrsPageResIdl_DataRes_ForumInfo_Manager.encode(v, writer.uint32(138).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseFrsPageResIdl_DataRes_ForumInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.id = reader.int64().toString();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.name = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.firstClass = reader.string();
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }
            message.secondClass = reader.string();
            continue;
          }
          case 9: {
            if (tag !== 72) {
              break;
            }
            message.memberNum = reader.int32();
            continue;
          }
          case 10: {
            if (tag !== 80) {
              break;
            }
            message.threadNum = reader.int32();
            continue;
          }
          case 11: {
            if (tag !== 88) {
              break;
            }
            message.postNum = reader.int32();
            continue;
          }
          case 17: {
            if (tag !== 138) {
              break;
            }
            message.managers.push(FrsPageResIdl_DataRes_ForumInfo_Manager.decode(reader, reader.uint32()));
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        id: isSet14(object.id) ? globalThis.String(object.id) : "0",
        name: isSet14(object.name) ? globalThis.String(object.name) : "",
        firstClass: isSet14(object.firstClass) ? globalThis.String(object.firstClass) : isSet14(object.first_class) ? globalThis.String(object.first_class) : "",
        secondClass: isSet14(object.secondClass) ? globalThis.String(object.secondClass) : isSet14(object.second_class) ? globalThis.String(object.second_class) : "",
        memberNum: isSet14(object.memberNum) ? globalThis.Number(object.memberNum) : isSet14(object.member_num) ? globalThis.Number(object.member_num) : 0,
        threadNum: isSet14(object.threadNum) ? globalThis.Number(object.threadNum) : isSet14(object.thread_num) ? globalThis.Number(object.thread_num) : 0,
        postNum: isSet14(object.postNum) ? globalThis.Number(object.postNum) : isSet14(object.post_num) ? globalThis.Number(object.post_num) : 0,
        managers: globalThis.Array.isArray(object?.managers) ? object.managers.map((e) => FrsPageResIdl_DataRes_ForumInfo_Manager.fromJSON(e)) : []
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.id !== "0") {
        obj.id = message.id;
      }
      if (message.name !== "") {
        obj.name = message.name;
      }
      if (message.firstClass !== "") {
        obj.firstClass = message.firstClass;
      }
      if (message.secondClass !== "") {
        obj.secondClass = message.secondClass;
      }
      if (message.memberNum !== 0) {
        obj.memberNum = Math.round(message.memberNum);
      }
      if (message.threadNum !== 0) {
        obj.threadNum = Math.round(message.threadNum);
      }
      if (message.postNum !== 0) {
        obj.postNum = Math.round(message.postNum);
      }
      if (message.managers?.length) {
        obj.managers = message.managers.map((e) => FrsPageResIdl_DataRes_ForumInfo_Manager.toJSON(e));
      }
      return obj;
    },
    create(base) {
      return FrsPageResIdl_DataRes_ForumInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseFrsPageResIdl_DataRes_ForumInfo();
      message.id = object.id ?? "0";
      message.name = object.name ?? "";
      message.firstClass = object.firstClass ?? "";
      message.secondClass = object.secondClass ?? "";
      message.memberNum = object.memberNum ?? 0;
      message.threadNum = object.threadNum ?? 0;
      message.postNum = object.postNum ?? 0;
      message.managers = object.managers?.map((e) => FrsPageResIdl_DataRes_ForumInfo_Manager.fromPartial(e)) || [];
      return message;
    }
  };
  function createBaseFrsPageResIdl_DataRes_ForumInfo_Manager() {
    return {};
  }
  var FrsPageResIdl_DataRes_ForumInfo_Manager = {
    encode(_, writer = new BinaryWriter()) {
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseFrsPageResIdl_DataRes_ForumInfo_Manager();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(_) {
      return {};
    },
    toJSON(_) {
      const obj = {};
      return obj;
    },
    create(base) {
      return FrsPageResIdl_DataRes_ForumInfo_Manager.fromPartial(base ?? {});
    },
    fromPartial(_) {
      const message = createBaseFrsPageResIdl_DataRes_ForumInfo_Manager();
      return message;
    }
  };
  function createBaseFrsPageResIdl_DataRes_NavTabInfo() {
    return { tab: [] };
  }
  var FrsPageResIdl_DataRes_NavTabInfo = {
    encode(message, writer = new BinaryWriter()) {
      for (const v of message.tab) {
        FrsTabInfo.encode(v, writer.uint32(10).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseFrsPageResIdl_DataRes_NavTabInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.tab.push(FrsTabInfo.decode(reader, reader.uint32()));
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return { tab: globalThis.Array.isArray(object?.tab) ? object.tab.map((e) => FrsTabInfo.fromJSON(e)) : [] };
    },
    toJSON(message) {
      const obj = {};
      if (message.tab?.length) {
        obj.tab = message.tab.map((e) => FrsTabInfo.toJSON(e));
      }
      return obj;
    },
    create(base) {
      return FrsPageResIdl_DataRes_NavTabInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseFrsPageResIdl_DataRes_NavTabInfo();
      message.tab = object.tab?.map((e) => FrsTabInfo.fromPartial(e)) || [];
      return message;
    }
  };
  function createBaseFrsPageResIdl_DataRes_ForumRuleStatus() {
    return { hasForumRule: 0 };
  }
  var FrsPageResIdl_DataRes_ForumRuleStatus = {
    encode(message, writer = new BinaryWriter()) {
      if (message.hasForumRule !== 0) {
        writer.uint32(32).int32(message.hasForumRule);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseFrsPageResIdl_DataRes_ForumRuleStatus();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 4: {
            if (tag !== 32) {
              break;
            }
            message.hasForumRule = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        hasForumRule: isSet14(object.hasForumRule) ? globalThis.Number(object.hasForumRule) : isSet14(object.has_forum_rule) ? globalThis.Number(object.has_forum_rule) : 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.hasForumRule !== 0) {
        obj.hasForumRule = Math.round(message.hasForumRule);
      }
      return obj;
    },
    create(base) {
      return FrsPageResIdl_DataRes_ForumRuleStatus.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseFrsPageResIdl_DataRes_ForumRuleStatus();
      message.hasForumRule = object.hasForumRule ?? 0;
      return message;
    }
  };
  function isSet14(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/GetForumDetailReqIdl.ts
  function createBaseGetForumDetailReqIdl() {
    return { data: void 0 };
  }
  var GetForumDetailReqIdl = {
    encode(message, writer = new BinaryWriter()) {
      if (message.data !== void 0) {
        GetForumDetailReqIdl_DataReq.encode(message.data, writer.uint32(10).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseGetForumDetailReqIdl();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.data = GetForumDetailReqIdl_DataReq.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return { data: isSet15(object.data) ? GetForumDetailReqIdl_DataReq.fromJSON(object.data) : void 0 };
    },
    toJSON(message) {
      const obj = {};
      if (message.data !== void 0) {
        obj.data = GetForumDetailReqIdl_DataReq.toJSON(message.data);
      }
      return obj;
    },
    create(base) {
      return GetForumDetailReqIdl.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseGetForumDetailReqIdl();
      message.data = object.data !== void 0 && object.data !== null ? GetForumDetailReqIdl_DataReq.fromPartial(object.data) : void 0;
      return message;
    }
  };
  function createBaseGetForumDetailReqIdl_DataReq() {
    return { forumId: "0", common: void 0 };
  }
  var GetForumDetailReqIdl_DataReq = {
    encode(message, writer = new BinaryWriter()) {
      if (message.forumId !== "0") {
        writer.uint32(8).int64(message.forumId);
      }
      if (message.common !== void 0) {
        CommonReq.encode(message.common, writer.uint32(18).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseGetForumDetailReqIdl_DataReq();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.forumId = reader.int64().toString();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.common = CommonReq.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        forumId: isSet15(object.forumId) ? globalThis.String(object.forumId) : isSet15(object.forum_id) ? globalThis.String(object.forum_id) : "0",
        common: isSet15(object.common) ? CommonReq.fromJSON(object.common) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.forumId !== "0") {
        obj.forumId = message.forumId;
      }
      if (message.common !== void 0) {
        obj.common = CommonReq.toJSON(message.common);
      }
      return obj;
    },
    create(base) {
      return GetForumDetailReqIdl_DataReq.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseGetForumDetailReqIdl_DataReq();
      message.forumId = object.forumId ?? "0";
      message.common = object.common !== void 0 && object.common !== null ? CommonReq.fromPartial(object.common) : void 0;
      return message;
    }
  };
  function isSet15(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/GetForumDetailResIdl.ts
  function createBaseGetForumDetailResIdl() {
    return { error: void 0, data: void 0 };
  }
  var GetForumDetailResIdl = {
    encode(message, writer = new BinaryWriter()) {
      if (message.error !== void 0) {
        Error4.encode(message.error, writer.uint32(10).fork()).join();
      }
      if (message.data !== void 0) {
        GetForumDetailResIdl_DataRes.encode(message.data, writer.uint32(18).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseGetForumDetailResIdl();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.error = Error4.decode(reader, reader.uint32());
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.data = GetForumDetailResIdl_DataRes.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        error: isSet16(object.error) ? Error4.fromJSON(object.error) : void 0,
        data: isSet16(object.data) ? GetForumDetailResIdl_DataRes.fromJSON(object.data) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.error !== void 0) {
        obj.error = Error4.toJSON(message.error);
      }
      if (message.data !== void 0) {
        obj.data = GetForumDetailResIdl_DataRes.toJSON(message.data);
      }
      return obj;
    },
    create(base) {
      return GetForumDetailResIdl.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseGetForumDetailResIdl();
      message.error = object.error !== void 0 && object.error !== null ? Error4.fromPartial(object.error) : void 0;
      message.data = object.data !== void 0 && object.data !== null ? GetForumDetailResIdl_DataRes.fromPartial(object.data) : void 0;
      return message;
    }
  };
  function createBaseGetForumDetailResIdl_DataRes() {
    return { forumInfo: void 0, electionTab: void 0 };
  }
  var GetForumDetailResIdl_DataRes = {
    encode(message, writer = new BinaryWriter()) {
      if (message.forumInfo !== void 0) {
        GetForumDetailResIdl_DataRes_RecommendForumInfo.encode(message.forumInfo, writer.uint32(10).fork()).join();
      }
      if (message.electionTab !== void 0) {
        GetForumDetailResIdl_DataRes_ManagerElectionTab.encode(message.electionTab, writer.uint32(66).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseGetForumDetailResIdl_DataRes();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.forumInfo = GetForumDetailResIdl_DataRes_RecommendForumInfo.decode(reader, reader.uint32());
            continue;
          }
          case 8: {
            if (tag !== 66) {
              break;
            }
            message.electionTab = GetForumDetailResIdl_DataRes_ManagerElectionTab.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        forumInfo: isSet16(object.forumInfo) ? GetForumDetailResIdl_DataRes_RecommendForumInfo.fromJSON(object.forumInfo) : isSet16(object.forum_info) ? GetForumDetailResIdl_DataRes_RecommendForumInfo.fromJSON(object.forum_info) : void 0,
        electionTab: isSet16(object.electionTab) ? GetForumDetailResIdl_DataRes_ManagerElectionTab.fromJSON(object.electionTab) : isSet16(object.election_tab) ? GetForumDetailResIdl_DataRes_ManagerElectionTab.fromJSON(object.election_tab) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.forumInfo !== void 0) {
        obj.forumInfo = GetForumDetailResIdl_DataRes_RecommendForumInfo.toJSON(message.forumInfo);
      }
      if (message.electionTab !== void 0) {
        obj.electionTab = GetForumDetailResIdl_DataRes_ManagerElectionTab.toJSON(message.electionTab);
      }
      return obj;
    },
    create(base) {
      return GetForumDetailResIdl_DataRes.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseGetForumDetailResIdl_DataRes();
      message.forumInfo = object.forumInfo !== void 0 && object.forumInfo !== null ? GetForumDetailResIdl_DataRes_RecommendForumInfo.fromPartial(object.forumInfo) : void 0;
      message.electionTab = object.electionTab !== void 0 && object.electionTab !== null ? GetForumDetailResIdl_DataRes_ManagerElectionTab.fromPartial(object.electionTab) : void 0;
      return message;
    }
  };
  function createBaseGetForumDetailResIdl_DataRes_RecommendForumInfo() {
    return {
      avatar: "",
      forumId: "0",
      forumName: "",
      memberCount: 0,
      threadCount: 0,
      slogan: "",
      lv1Name: "",
      avatarOrigin: ""
    };
  }
  var GetForumDetailResIdl_DataRes_RecommendForumInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.avatar !== "") {
        writer.uint32(10).string(message.avatar);
      }
      if (message.forumId !== "0") {
        writer.uint32(16).uint64(message.forumId);
      }
      if (message.forumName !== "") {
        writer.uint32(26).string(message.forumName);
      }
      if (message.memberCount !== 0) {
        writer.uint32(40).uint32(message.memberCount);
      }
      if (message.threadCount !== 0) {
        writer.uint32(48).uint32(message.threadCount);
      }
      if (message.slogan !== "") {
        writer.uint32(58).string(message.slogan);
      }
      if (message.lv1Name !== "") {
        writer.uint32(146).string(message.lv1Name);
      }
      if (message.avatarOrigin !== "") {
        writer.uint32(162).string(message.avatarOrigin);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseGetForumDetailResIdl_DataRes_RecommendForumInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.avatar = reader.string();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.forumId = reader.uint64().toString();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.forumName = reader.string();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }
            message.memberCount = reader.uint32();
            continue;
          }
          case 6: {
            if (tag !== 48) {
              break;
            }
            message.threadCount = reader.uint32();
            continue;
          }
          case 7: {
            if (tag !== 58) {
              break;
            }
            message.slogan = reader.string();
            continue;
          }
          case 18: {
            if (tag !== 146) {
              break;
            }
            message.lv1Name = reader.string();
            continue;
          }
          case 20: {
            if (tag !== 162) {
              break;
            }
            message.avatarOrigin = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        avatar: isSet16(object.avatar) ? globalThis.String(object.avatar) : "",
        forumId: isSet16(object.forumId) ? globalThis.String(object.forumId) : isSet16(object.forum_id) ? globalThis.String(object.forum_id) : "0",
        forumName: isSet16(object.forumName) ? globalThis.String(object.forumName) : isSet16(object.forum_name) ? globalThis.String(object.forum_name) : "",
        memberCount: isSet16(object.memberCount) ? globalThis.Number(object.memberCount) : isSet16(object.member_count) ? globalThis.Number(object.member_count) : 0,
        threadCount: isSet16(object.threadCount) ? globalThis.Number(object.threadCount) : isSet16(object.thread_count) ? globalThis.Number(object.thread_count) : 0,
        slogan: isSet16(object.slogan) ? globalThis.String(object.slogan) : "",
        lv1Name: isSet16(object.lv1Name) ? globalThis.String(object.lv1Name) : isSet16(object.lv1_name) ? globalThis.String(object.lv1_name) : "",
        avatarOrigin: isSet16(object.avatarOrigin) ? globalThis.String(object.avatarOrigin) : isSet16(object.avatar_origin) ? globalThis.String(object.avatar_origin) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.avatar !== "") {
        obj.avatar = message.avatar;
      }
      if (message.forumId !== "0") {
        obj.forumId = message.forumId;
      }
      if (message.forumName !== "") {
        obj.forumName = message.forumName;
      }
      if (message.memberCount !== 0) {
        obj.memberCount = Math.round(message.memberCount);
      }
      if (message.threadCount !== 0) {
        obj.threadCount = Math.round(message.threadCount);
      }
      if (message.slogan !== "") {
        obj.slogan = message.slogan;
      }
      if (message.lv1Name !== "") {
        obj.lv1Name = message.lv1Name;
      }
      if (message.avatarOrigin !== "") {
        obj.avatarOrigin = message.avatarOrigin;
      }
      return obj;
    },
    create(base) {
      return GetForumDetailResIdl_DataRes_RecommendForumInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseGetForumDetailResIdl_DataRes_RecommendForumInfo();
      message.avatar = object.avatar ?? "";
      message.forumId = object.forumId ?? "0";
      message.forumName = object.forumName ?? "";
      message.memberCount = object.memberCount ?? 0;
      message.threadCount = object.threadCount ?? 0;
      message.slogan = object.slogan ?? "";
      message.lv1Name = object.lv1Name ?? "";
      message.avatarOrigin = object.avatarOrigin ?? "";
      return message;
    }
  };
  function createBaseGetForumDetailResIdl_DataRes_ManagerElectionTab() {
    return { newStrategyText: "" };
  }
  var GetForumDetailResIdl_DataRes_ManagerElectionTab = {
    encode(message, writer = new BinaryWriter()) {
      if (message.newStrategyText !== "") {
        writer.uint32(42).string(message.newStrategyText);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseGetForumDetailResIdl_DataRes_ManagerElectionTab();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 5: {
            if (tag !== 42) {
              break;
            }
            message.newStrategyText = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        newStrategyText: isSet16(object.newStrategyText) ? globalThis.String(object.newStrategyText) : isSet16(object.new_strategy_text) ? globalThis.String(object.new_strategy_text) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.newStrategyText !== "") {
        obj.newStrategyText = message.newStrategyText;
      }
      return obj;
    },
    create(base) {
      return GetForumDetailResIdl_DataRes_ManagerElectionTab.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseGetForumDetailResIdl_DataRes_ManagerElectionTab();
      message.newStrategyText = object.newStrategyText ?? "";
      return message;
    }
  };
  function isSet16(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/api/forum.ts
  var getThreads = createProtoApi({
    endpoint: "/c/f/frs/page?cmd=303002",
    reqCodec: FrsPageReqIdl,
    resCodec: FrsPageResIdl,
    buildRequest: (params) => {
      const rnNeed = params.rn ? Math.min(Math.max(params.rn, 30), 100) : 30;
      return {
        data: {
          kw: params.fname,
          pn: params.page || 1,
          rn: 105,
          // rnNeed 最大 100，最小 30
          rnNeed,
          isGood: params.onlyGood ? 1 : 0,
          sortType: params.sort || 1,
          common: {
            ClientType: CLIENT_TYPE,
            ClientVersion: CLIENT_VERSION
          }
        }
      };
    },
    extractResult: (res) => res.data
  });
  var getForumDetail = createProtoApi({
    endpoint: "/c/f/forum/getforumdetail?cmd=303021",
    reqCodec: GetForumDetailReqIdl,
    resCodec: GetForumDetailResIdl,
    buildRequest: (forumId) => ({
      data: {
        forumId: forumId.toString(),
        common: { ClientVersion: CLIENT_VERSION }
      }
    }),
    extractResult: (res) => res.data
  });
  function getForumName(forumId) {
    return pipe(
      getForumDetail(forumId),
      Effect_exports.map((data) => data?.forumInfo?.forumName ?? "")
    );
  }
  var followForum = createFormApi({
    endpoint: "/c/c/forum/like",
    buildParams: (params) => ({
      fid: params.fid.toString()
    })
  });
  var unfollowForum = createFormApi({
    endpoint: "/c/c/forum/unfavolike",
    buildParams: (params) => ({
      fid: params.fid.toString()
    })
  });
  var signForum = createFormApi({
    endpoint: "/c/c/forum/sign",
    buildParams: (params) => ({
      kw: params.fname
    })
  });

  // <eztb>/packages/sdk/src/api/moderation.ts
  var blockUser = createFormApi({
    endpoint: "/c/c/bawu/commitprison",
    buildParams: (params) => ({
      fid: params.fid.toString(),
      portrait: params.portrait,
      reason: params.reason ?? "",
      day: (params.day ?? 1).toString(),
      ntn: "banid",
      word: "-",
      z: "6"
    })
  });
  var unblockUser = createFormApi({
    endpoint: "/c/c/bawu/unblock",
    buildParams: (params) => ({
      word: params.fname,
      un: params.uid
    })
  });
  var goodThread = createFormApi({
    endpoint: "/c/c/bawu/nopicset",
    buildParams: (params) => ({
      word: params.fname,
      fid: params.fid.toString(),
      z: params.tid.toString(),
      cname: params.cname ?? ""
    })
  });
  var ungoodThread = createFormApi({
    endpoint: "/c/c/bawu/delpicset",
    buildParams: (params) => ({
      word: params.fname,
      fid: params.fid.toString(),
      z: params.tid.toString()
    })
  });
  var topThread = createFormApi({
    endpoint: "/c/c/bawu/top",
    buildParams: (params) => ({
      word: params.fname,
      fid: params.fid.toString(),
      z: params.tid.toString()
    })
  });
  var untopThread = createFormApi({
    endpoint: "/c/c/bawu/untop",
    buildParams: (params) => ({
      word: params.fname,
      fid: params.fid.toString(),
      z: params.tid.toString()
    })
  });
  var recoverThread = createFormApi({
    endpoint: "/c/c/bawu/recover",
    buildParams: (params) => ({
      word: params.fname,
      fid: params.fid.toString(),
      z: params.tid.toString(),
      is_frs_mask: "1"
    })
  });
  var recoverPost = createFormApi({
    endpoint: "/c/c/bawu/recover",
    buildParams: (params) => ({
      word: params.fname,
      fid: params.fid.toString(),
      z: params.tid.toString(),
      pid: params.pid.toString(),
      is_frs_mask: "0"
    })
  });

  // <eztb>/packages/sdk/src/generated/PbFloorReqIdl.ts
  function createBasePbFloorReqIdl() {
    return { data: void 0 };
  }
  var PbFloorReqIdl = {
    encode(message, writer = new BinaryWriter()) {
      if (message.data !== void 0) {
        PbFloorReqIdl_DataReq.encode(message.data, writer.uint32(10).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePbFloorReqIdl();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.data = PbFloorReqIdl_DataReq.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return { data: isSet17(object.data) ? PbFloorReqIdl_DataReq.fromJSON(object.data) : void 0 };
    },
    toJSON(message) {
      const obj = {};
      if (message.data !== void 0) {
        obj.data = PbFloorReqIdl_DataReq.toJSON(message.data);
      }
      return obj;
    },
    create(base) {
      return PbFloorReqIdl.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePbFloorReqIdl();
      message.data = object.data !== void 0 && object.data !== null ? PbFloorReqIdl_DataReq.fromPartial(object.data) : void 0;
      return message;
    }
  };
  function createBasePbFloorReqIdl_DataReq() {
    return { common: void 0, kz: "0", pid: "0", spid: "0", pn: 0 };
  }
  var PbFloorReqIdl_DataReq = {
    encode(message, writer = new BinaryWriter()) {
      if (message.common !== void 0) {
        CommonReq.encode(message.common, writer.uint32(74).fork()).join();
      }
      if (message.kz !== "0") {
        writer.uint32(8).int64(message.kz);
      }
      if (message.pid !== "0") {
        writer.uint32(16).int64(message.pid);
      }
      if (message.spid !== "0") {
        writer.uint32(24).int64(message.spid);
      }
      if (message.pn !== 0) {
        writer.uint32(32).int32(message.pn);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePbFloorReqIdl_DataReq();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 9: {
            if (tag !== 74) {
              break;
            }
            message.common = CommonReq.decode(reader, reader.uint32());
            continue;
          }
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.kz = reader.int64().toString();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.pid = reader.int64().toString();
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }
            message.spid = reader.int64().toString();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }
            message.pn = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        common: isSet17(object.common) ? CommonReq.fromJSON(object.common) : void 0,
        kz: isSet17(object.kz) ? globalThis.String(object.kz) : "0",
        pid: isSet17(object.pid) ? globalThis.String(object.pid) : "0",
        spid: isSet17(object.spid) ? globalThis.String(object.spid) : "0",
        pn: isSet17(object.pn) ? globalThis.Number(object.pn) : 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.common !== void 0) {
        obj.common = CommonReq.toJSON(message.common);
      }
      if (message.kz !== "0") {
        obj.kz = message.kz;
      }
      if (message.pid !== "0") {
        obj.pid = message.pid;
      }
      if (message.spid !== "0") {
        obj.spid = message.spid;
      }
      if (message.pn !== 0) {
        obj.pn = Math.round(message.pn);
      }
      return obj;
    },
    create(base) {
      return PbFloorReqIdl_DataReq.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePbFloorReqIdl_DataReq();
      message.common = object.common !== void 0 && object.common !== null ? CommonReq.fromPartial(object.common) : void 0;
      message.kz = object.kz ?? "0";
      message.pid = object.pid ?? "0";
      message.spid = object.spid ?? "0";
      message.pn = object.pn ?? 0;
      return message;
    }
  };
  function isSet17(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/SubPostList.ts
  function createBaseSubPostList() {
    return { id: "0", content: [], time: 0, authorId: "0", title: "", floor: 0, author: void 0, agree: void 0 };
  }
  var SubPostList = {
    encode(message, writer = new BinaryWriter()) {
      if (message.id !== "0") {
        writer.uint32(8).int64(message.id);
      }
      for (const v of message.content) {
        PbContent.encode(v, writer.uint32(18).fork()).join();
      }
      if (message.time !== 0) {
        writer.uint32(24).uint32(message.time);
      }
      if (message.authorId !== "0") {
        writer.uint32(32).int64(message.authorId);
      }
      if (message.title !== "") {
        writer.uint32(42).string(message.title);
      }
      if (message.floor !== 0) {
        writer.uint32(48).uint32(message.floor);
      }
      if (message.author !== void 0) {
        User.encode(message.author, writer.uint32(58).fork()).join();
      }
      if (message.agree !== void 0) {
        Agree.encode(message.agree, writer.uint32(74).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseSubPostList();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.id = reader.int64().toString();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.content.push(PbContent.decode(reader, reader.uint32()));
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }
            message.time = reader.uint32();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }
            message.authorId = reader.int64().toString();
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }
            message.title = reader.string();
            continue;
          }
          case 6: {
            if (tag !== 48) {
              break;
            }
            message.floor = reader.uint32();
            continue;
          }
          case 7: {
            if (tag !== 58) {
              break;
            }
            message.author = User.decode(reader, reader.uint32());
            continue;
          }
          case 9: {
            if (tag !== 74) {
              break;
            }
            message.agree = Agree.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        id: isSet18(object.id) ? globalThis.String(object.id) : "0",
        content: globalThis.Array.isArray(object?.content) ? object.content.map((e) => PbContent.fromJSON(e)) : [],
        time: isSet18(object.time) ? globalThis.Number(object.time) : 0,
        authorId: isSet18(object.authorId) ? globalThis.String(object.authorId) : isSet18(object.author_id) ? globalThis.String(object.author_id) : "0",
        title: isSet18(object.title) ? globalThis.String(object.title) : "",
        floor: isSet18(object.floor) ? globalThis.Number(object.floor) : 0,
        author: isSet18(object.author) ? User.fromJSON(object.author) : void 0,
        agree: isSet18(object.agree) ? Agree.fromJSON(object.agree) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.id !== "0") {
        obj.id = message.id;
      }
      if (message.content?.length) {
        obj.content = message.content.map((e) => PbContent.toJSON(e));
      }
      if (message.time !== 0) {
        obj.time = Math.round(message.time);
      }
      if (message.authorId !== "0") {
        obj.authorId = message.authorId;
      }
      if (message.title !== "") {
        obj.title = message.title;
      }
      if (message.floor !== 0) {
        obj.floor = Math.round(message.floor);
      }
      if (message.author !== void 0) {
        obj.author = User.toJSON(message.author);
      }
      if (message.agree !== void 0) {
        obj.agree = Agree.toJSON(message.agree);
      }
      return obj;
    },
    create(base) {
      return SubPostList.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseSubPostList();
      message.id = object.id ?? "0";
      message.content = object.content?.map((e) => PbContent.fromPartial(e)) || [];
      message.time = object.time ?? 0;
      message.authorId = object.authorId ?? "0";
      message.title = object.title ?? "";
      message.floor = object.floor ?? 0;
      message.author = object.author !== void 0 && object.author !== null ? User.fromPartial(object.author) : void 0;
      message.agree = object.agree !== void 0 && object.agree !== null ? Agree.fromPartial(object.agree) : void 0;
      return message;
    }
  };
  function isSet18(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/Post.ts
  function createBasePost() {
    return {
      id: "0",
      floor: 0,
      time: 0,
      content: [],
      subPostNumber: 0,
      authorId: "0",
      subPostList: void 0,
      signature: void 0,
      author: void 0,
      agree: void 0,
      tid: "0",
      customFigure: void 0,
      customState: void 0,
      chatContent: void 0,
      spriteMemeInfo: void 0
    };
  }
  var Post = {
    encode(message, writer = new BinaryWriter()) {
      if (message.id !== "0") {
        writer.uint32(8).int64(message.id);
      }
      if (message.floor !== 0) {
        writer.uint32(24).uint32(message.floor);
      }
      if (message.time !== 0) {
        writer.uint32(32).uint32(message.time);
      }
      for (const v of message.content) {
        PbContent.encode(v, writer.uint32(42).fork()).join();
      }
      if (message.subPostNumber !== 0) {
        writer.uint32(104).uint32(message.subPostNumber);
      }
      if (message.authorId !== "0") {
        writer.uint32(152).int64(message.authorId);
      }
      if (message.subPostList !== void 0) {
        Post_SubPost.encode(message.subPostList, writer.uint32(122).fork()).join();
      }
      if (message.signature !== void 0) {
        Post_SignatureData.encode(message.signature, writer.uint32(170).fork()).join();
      }
      if (message.author !== void 0) {
        User.encode(message.author, writer.uint32(186).fork()).join();
      }
      if (message.agree !== void 0) {
        Agree.encode(message.agree, writer.uint32(298).fork()).join();
      }
      if (message.tid !== "0") {
        writer.uint32(368).int64(message.tid);
      }
      if (message.customFigure !== void 0) {
        Post_CustomFigure.encode(message.customFigure, writer.uint32(482).fork()).join();
      }
      if (message.customState !== void 0) {
        Post_CustomState.encode(message.customState, writer.uint32(490).fork()).join();
      }
      if (message.chatContent !== void 0) {
        Post_ChatContent.encode(message.chatContent, writer.uint32(626).fork()).join();
      }
      if (message.spriteMemeInfo !== void 0) {
        Post_SpriteMemeInfo.encode(message.spriteMemeInfo, writer.uint32(634).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePost();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.id = reader.int64().toString();
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }
            message.floor = reader.uint32();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }
            message.time = reader.uint32();
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }
            message.content.push(PbContent.decode(reader, reader.uint32()));
            continue;
          }
          case 13: {
            if (tag !== 104) {
              break;
            }
            message.subPostNumber = reader.uint32();
            continue;
          }
          case 19: {
            if (tag !== 152) {
              break;
            }
            message.authorId = reader.int64().toString();
            continue;
          }
          case 15: {
            if (tag !== 122) {
              break;
            }
            message.subPostList = Post_SubPost.decode(reader, reader.uint32());
            continue;
          }
          case 21: {
            if (tag !== 170) {
              break;
            }
            message.signature = Post_SignatureData.decode(reader, reader.uint32());
            continue;
          }
          case 23: {
            if (tag !== 186) {
              break;
            }
            message.author = User.decode(reader, reader.uint32());
            continue;
          }
          case 37: {
            if (tag !== 298) {
              break;
            }
            message.agree = Agree.decode(reader, reader.uint32());
            continue;
          }
          case 46: {
            if (tag !== 368) {
              break;
            }
            message.tid = reader.int64().toString();
            continue;
          }
          case 60: {
            if (tag !== 482) {
              break;
            }
            message.customFigure = Post_CustomFigure.decode(reader, reader.uint32());
            continue;
          }
          case 61: {
            if (tag !== 490) {
              break;
            }
            message.customState = Post_CustomState.decode(reader, reader.uint32());
            continue;
          }
          case 78: {
            if (tag !== 626) {
              break;
            }
            message.chatContent = Post_ChatContent.decode(reader, reader.uint32());
            continue;
          }
          case 79: {
            if (tag !== 634) {
              break;
            }
            message.spriteMemeInfo = Post_SpriteMemeInfo.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        id: isSet19(object.id) ? globalThis.String(object.id) : "0",
        floor: isSet19(object.floor) ? globalThis.Number(object.floor) : 0,
        time: isSet19(object.time) ? globalThis.Number(object.time) : 0,
        content: globalThis.Array.isArray(object?.content) ? object.content.map((e) => PbContent.fromJSON(e)) : [],
        subPostNumber: isSet19(object.subPostNumber) ? globalThis.Number(object.subPostNumber) : isSet19(object.sub_post_number) ? globalThis.Number(object.sub_post_number) : 0,
        authorId: isSet19(object.authorId) ? globalThis.String(object.authorId) : isSet19(object.author_id) ? globalThis.String(object.author_id) : "0",
        subPostList: isSet19(object.subPostList) ? Post_SubPost.fromJSON(object.subPostList) : isSet19(object.sub_post_list) ? Post_SubPost.fromJSON(object.sub_post_list) : void 0,
        signature: isSet19(object.signature) ? Post_SignatureData.fromJSON(object.signature) : void 0,
        author: isSet19(object.author) ? User.fromJSON(object.author) : void 0,
        agree: isSet19(object.agree) ? Agree.fromJSON(object.agree) : void 0,
        tid: isSet19(object.tid) ? globalThis.String(object.tid) : "0",
        customFigure: isSet19(object.customFigure) ? Post_CustomFigure.fromJSON(object.customFigure) : isSet19(object.custom_figure) ? Post_CustomFigure.fromJSON(object.custom_figure) : void 0,
        customState: isSet19(object.customState) ? Post_CustomState.fromJSON(object.customState) : isSet19(object.custom_state) ? Post_CustomState.fromJSON(object.custom_state) : void 0,
        chatContent: isSet19(object.chatContent) ? Post_ChatContent.fromJSON(object.chatContent) : isSet19(object.chat_content) ? Post_ChatContent.fromJSON(object.chat_content) : void 0,
        spriteMemeInfo: isSet19(object.spriteMemeInfo) ? Post_SpriteMemeInfo.fromJSON(object.spriteMemeInfo) : isSet19(object.sprite_meme_info) ? Post_SpriteMemeInfo.fromJSON(object.sprite_meme_info) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.id !== "0") {
        obj.id = message.id;
      }
      if (message.floor !== 0) {
        obj.floor = Math.round(message.floor);
      }
      if (message.time !== 0) {
        obj.time = Math.round(message.time);
      }
      if (message.content?.length) {
        obj.content = message.content.map((e) => PbContent.toJSON(e));
      }
      if (message.subPostNumber !== 0) {
        obj.subPostNumber = Math.round(message.subPostNumber);
      }
      if (message.authorId !== "0") {
        obj.authorId = message.authorId;
      }
      if (message.subPostList !== void 0) {
        obj.subPostList = Post_SubPost.toJSON(message.subPostList);
      }
      if (message.signature !== void 0) {
        obj.signature = Post_SignatureData.toJSON(message.signature);
      }
      if (message.author !== void 0) {
        obj.author = User.toJSON(message.author);
      }
      if (message.agree !== void 0) {
        obj.agree = Agree.toJSON(message.agree);
      }
      if (message.tid !== "0") {
        obj.tid = message.tid;
      }
      if (message.customFigure !== void 0) {
        obj.customFigure = Post_CustomFigure.toJSON(message.customFigure);
      }
      if (message.customState !== void 0) {
        obj.customState = Post_CustomState.toJSON(message.customState);
      }
      if (message.chatContent !== void 0) {
        obj.chatContent = Post_ChatContent.toJSON(message.chatContent);
      }
      if (message.spriteMemeInfo !== void 0) {
        obj.spriteMemeInfo = Post_SpriteMemeInfo.toJSON(message.spriteMemeInfo);
      }
      return obj;
    },
    create(base) {
      return Post.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePost();
      message.id = object.id ?? "0";
      message.floor = object.floor ?? 0;
      message.time = object.time ?? 0;
      message.content = object.content?.map((e) => PbContent.fromPartial(e)) || [];
      message.subPostNumber = object.subPostNumber ?? 0;
      message.authorId = object.authorId ?? "0";
      message.subPostList = object.subPostList !== void 0 && object.subPostList !== null ? Post_SubPost.fromPartial(object.subPostList) : void 0;
      message.signature = object.signature !== void 0 && object.signature !== null ? Post_SignatureData.fromPartial(object.signature) : void 0;
      message.author = object.author !== void 0 && object.author !== null ? User.fromPartial(object.author) : void 0;
      message.agree = object.agree !== void 0 && object.agree !== null ? Agree.fromPartial(object.agree) : void 0;
      message.tid = object.tid ?? "0";
      message.customFigure = object.customFigure !== void 0 && object.customFigure !== null ? Post_CustomFigure.fromPartial(object.customFigure) : void 0;
      message.customState = object.customState !== void 0 && object.customState !== null ? Post_CustomState.fromPartial(object.customState) : void 0;
      message.chatContent = object.chatContent !== void 0 && object.chatContent !== null ? Post_ChatContent.fromPartial(object.chatContent) : void 0;
      message.spriteMemeInfo = object.spriteMemeInfo !== void 0 && object.spriteMemeInfo !== null ? Post_SpriteMemeInfo.fromPartial(object.spriteMemeInfo) : void 0;
      return message;
    }
  };
  function createBasePost_SubPost() {
    return { subPostList: [] };
  }
  var Post_SubPost = {
    encode(message, writer = new BinaryWriter()) {
      for (const v of message.subPostList) {
        SubPostList.encode(v, writer.uint32(18).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePost_SubPost();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.subPostList.push(SubPostList.decode(reader, reader.uint32()));
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        subPostList: globalThis.Array.isArray(object?.subPostList) ? object.subPostList.map((e) => SubPostList.fromJSON(e)) : globalThis.Array.isArray(object?.sub_post_list) ? object.sub_post_list.map((e) => SubPostList.fromJSON(e)) : []
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.subPostList?.length) {
        obj.subPostList = message.subPostList.map((e) => SubPostList.toJSON(e));
      }
      return obj;
    },
    create(base) {
      return Post_SubPost.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePost_SubPost();
      message.subPostList = object.subPostList?.map((e) => SubPostList.fromPartial(e)) || [];
      return message;
    }
  };
  function createBasePost_SignatureData() {
    return { content: [] };
  }
  var Post_SignatureData = {
    encode(message, writer = new BinaryWriter()) {
      for (const v of message.content) {
        Post_SignatureData_SignatureContent.encode(v, writer.uint32(34).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePost_SignatureData();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 4: {
            if (tag !== 34) {
              break;
            }
            message.content.push(Post_SignatureData_SignatureContent.decode(reader, reader.uint32()));
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        content: globalThis.Array.isArray(object?.content) ? object.content.map((e) => Post_SignatureData_SignatureContent.fromJSON(e)) : []
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.content?.length) {
        obj.content = message.content.map((e) => Post_SignatureData_SignatureContent.toJSON(e));
      }
      return obj;
    },
    create(base) {
      return Post_SignatureData.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePost_SignatureData();
      message.content = object.content?.map((e) => Post_SignatureData_SignatureContent.fromPartial(e)) || [];
      return message;
    }
  };
  function createBasePost_SignatureData_SignatureContent() {
    return { type: 0, text: "" };
  }
  var Post_SignatureData_SignatureContent = {
    encode(message, writer = new BinaryWriter()) {
      if (message.type !== 0) {
        writer.uint32(8).int32(message.type);
      }
      if (message.text !== "") {
        writer.uint32(18).string(message.text);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePost_SignatureData_SignatureContent();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.type = reader.int32();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.text = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        type: isSet19(object.type) ? globalThis.Number(object.type) : 0,
        text: isSet19(object.text) ? globalThis.String(object.text) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.type !== 0) {
        obj.type = Math.round(message.type);
      }
      if (message.text !== "") {
        obj.text = message.text;
      }
      return obj;
    },
    create(base) {
      return Post_SignatureData_SignatureContent.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePost_SignatureData_SignatureContent();
      message.type = object.type ?? 0;
      message.text = object.text ?? "";
      return message;
    }
  };
  function createBasePost_CustomFigure() {
    return { backgroundValue: "" };
  }
  var Post_CustomFigure = {
    encode(message, writer = new BinaryWriter()) {
      if (message.backgroundValue !== "") {
        writer.uint32(26).string(message.backgroundValue);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePost_CustomFigure();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.backgroundValue = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        backgroundValue: isSet19(object.backgroundValue) ? globalThis.String(object.backgroundValue) : isSet19(object.background_value) ? globalThis.String(object.background_value) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.backgroundValue !== "") {
        obj.backgroundValue = message.backgroundValue;
      }
      return obj;
    },
    create(base) {
      return Post_CustomFigure.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePost_CustomFigure();
      message.backgroundValue = object.backgroundValue ?? "";
      return message;
    }
  };
  function createBasePost_CustomState() {
    return { content: "" };
  }
  var Post_CustomState = {
    encode(message, writer = new BinaryWriter()) {
      if (message.content !== "") {
        writer.uint32(18).string(message.content);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePost_CustomState();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.content = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return { content: isSet19(object.content) ? globalThis.String(object.content) : "" };
    },
    toJSON(message) {
      const obj = {};
      if (message.content !== "") {
        obj.content = message.content;
      }
      return obj;
    },
    create(base) {
      return Post_CustomState.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePost_CustomState();
      message.content = object.content ?? "";
      return message;
    }
  };
  function createBasePost_ChatContent() {
    return { botUk: "" };
  }
  var Post_ChatContent = {
    encode(message, writer = new BinaryWriter()) {
      if (message.botUk !== "") {
        writer.uint32(10).string(message.botUk);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePost_ChatContent();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.botUk = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        botUk: isSet19(object.botUk) ? globalThis.String(object.botUk) : isSet19(object.bot_uk) ? globalThis.String(object.bot_uk) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.botUk !== "") {
        obj.botUk = message.botUk;
      }
      return obj;
    },
    create(base) {
      return Post_ChatContent.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePost_ChatContent();
      message.botUk = object.botUk ?? "";
      return message;
    }
  };
  function createBasePost_SpriteMemeInfo() {
    return { memeId: "0" };
  }
  var Post_SpriteMemeInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.memeId !== "0") {
        writer.uint32(8).int64(message.memeId);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePost_SpriteMemeInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.memeId = reader.int64().toString();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        memeId: isSet19(object.memeId) ? globalThis.String(object.memeId) : isSet19(object.meme_id) ? globalThis.String(object.meme_id) : "0"
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.memeId !== "0") {
        obj.memeId = message.memeId;
      }
      return obj;
    },
    create(base) {
      return Post_SpriteMemeInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePost_SpriteMemeInfo();
      message.memeId = object.memeId ?? "0";
      return message;
    }
  };
  function isSet19(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/SimpleForum.ts
  function createBaseSimpleForum() {
    return { id: "0", name: "", firstClass: "", secondClass: "", memberNum: 0, postNum: 0 };
  }
  var SimpleForum = {
    encode(message, writer = new BinaryWriter()) {
      if (message.id !== "0") {
        writer.uint32(8).int64(message.id);
      }
      if (message.name !== "") {
        writer.uint32(18).string(message.name);
      }
      if (message.firstClass !== "") {
        writer.uint32(58).string(message.firstClass);
      }
      if (message.secondClass !== "") {
        writer.uint32(66).string(message.secondClass);
      }
      if (message.memberNum !== 0) {
        writer.uint32(96).int32(message.memberNum);
      }
      if (message.postNum !== 0) {
        writer.uint32(104).int32(message.postNum);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseSimpleForum();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.id = reader.int64().toString();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.name = reader.string();
            continue;
          }
          case 7: {
            if (tag !== 58) {
              break;
            }
            message.firstClass = reader.string();
            continue;
          }
          case 8: {
            if (tag !== 66) {
              break;
            }
            message.secondClass = reader.string();
            continue;
          }
          case 12: {
            if (tag !== 96) {
              break;
            }
            message.memberNum = reader.int32();
            continue;
          }
          case 13: {
            if (tag !== 104) {
              break;
            }
            message.postNum = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        id: isSet20(object.id) ? globalThis.String(object.id) : "0",
        name: isSet20(object.name) ? globalThis.String(object.name) : "",
        firstClass: isSet20(object.firstClass) ? globalThis.String(object.firstClass) : isSet20(object.first_class) ? globalThis.String(object.first_class) : "",
        secondClass: isSet20(object.secondClass) ? globalThis.String(object.secondClass) : isSet20(object.second_class) ? globalThis.String(object.second_class) : "",
        memberNum: isSet20(object.memberNum) ? globalThis.Number(object.memberNum) : isSet20(object.member_num) ? globalThis.Number(object.member_num) : 0,
        postNum: isSet20(object.postNum) ? globalThis.Number(object.postNum) : isSet20(object.post_num) ? globalThis.Number(object.post_num) : 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.id !== "0") {
        obj.id = message.id;
      }
      if (message.name !== "") {
        obj.name = message.name;
      }
      if (message.firstClass !== "") {
        obj.firstClass = message.firstClass;
      }
      if (message.secondClass !== "") {
        obj.secondClass = message.secondClass;
      }
      if (message.memberNum !== 0) {
        obj.memberNum = Math.round(message.memberNum);
      }
      if (message.postNum !== 0) {
        obj.postNum = Math.round(message.postNum);
      }
      return obj;
    },
    create(base) {
      return SimpleForum.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseSimpleForum();
      message.id = object.id ?? "0";
      message.name = object.name ?? "";
      message.firstClass = object.firstClass ?? "";
      message.secondClass = object.secondClass ?? "";
      message.memberNum = object.memberNum ?? 0;
      message.postNum = object.postNum ?? 0;
      return message;
    }
  };
  function isSet20(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/PbFloorResIdl.ts
  function createBasePbFloorResIdl() {
    return { error: void 0, data: void 0 };
  }
  var PbFloorResIdl = {
    encode(message, writer = new BinaryWriter()) {
      if (message.error !== void 0) {
        Error4.encode(message.error, writer.uint32(10).fork()).join();
      }
      if (message.data !== void 0) {
        PbFloorResIdl_DataRes.encode(message.data, writer.uint32(18).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePbFloorResIdl();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.error = Error4.decode(reader, reader.uint32());
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.data = PbFloorResIdl_DataRes.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        error: isSet21(object.error) ? Error4.fromJSON(object.error) : void 0,
        data: isSet21(object.data) ? PbFloorResIdl_DataRes.fromJSON(object.data) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.error !== void 0) {
        obj.error = Error4.toJSON(message.error);
      }
      if (message.data !== void 0) {
        obj.data = PbFloorResIdl_DataRes.toJSON(message.data);
      }
      return obj;
    },
    create(base) {
      return PbFloorResIdl.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePbFloorResIdl();
      message.error = object.error !== void 0 && object.error !== null ? Error4.fromPartial(object.error) : void 0;
      message.data = object.data !== void 0 && object.data !== null ? PbFloorResIdl_DataRes.fromPartial(object.data) : void 0;
      return message;
    }
  };
  function createBasePbFloorResIdl_DataRes() {
    return { page: void 0, post: void 0, subpostList: [], thread: void 0, forum: void 0 };
  }
  var PbFloorResIdl_DataRes = {
    encode(message, writer = new BinaryWriter()) {
      if (message.page !== void 0) {
        Page.encode(message.page, writer.uint32(10).fork()).join();
      }
      if (message.post !== void 0) {
        Post.encode(message.post, writer.uint32(26).fork()).join();
      }
      for (const v of message.subpostList) {
        SubPostList.encode(v, writer.uint32(34).fork()).join();
      }
      if (message.thread !== void 0) {
        ThreadInfo.encode(message.thread, writer.uint32(42).fork()).join();
      }
      if (message.forum !== void 0) {
        SimpleForum.encode(message.forum, writer.uint32(50).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePbFloorResIdl_DataRes();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.page = Page.decode(reader, reader.uint32());
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.post = Post.decode(reader, reader.uint32());
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }
            message.subpostList.push(SubPostList.decode(reader, reader.uint32()));
            continue;
          }
          case 5: {
            if (tag !== 42) {
              break;
            }
            message.thread = ThreadInfo.decode(reader, reader.uint32());
            continue;
          }
          case 6: {
            if (tag !== 50) {
              break;
            }
            message.forum = SimpleForum.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        page: isSet21(object.page) ? Page.fromJSON(object.page) : void 0,
        post: isSet21(object.post) ? Post.fromJSON(object.post) : void 0,
        subpostList: globalThis.Array.isArray(object?.subpostList) ? object.subpostList.map((e) => SubPostList.fromJSON(e)) : globalThis.Array.isArray(object?.subpost_list) ? object.subpost_list.map((e) => SubPostList.fromJSON(e)) : [],
        thread: isSet21(object.thread) ? ThreadInfo.fromJSON(object.thread) : void 0,
        forum: isSet21(object.forum) ? SimpleForum.fromJSON(object.forum) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.page !== void 0) {
        obj.page = Page.toJSON(message.page);
      }
      if (message.post !== void 0) {
        obj.post = Post.toJSON(message.post);
      }
      if (message.subpostList?.length) {
        obj.subpostList = message.subpostList.map((e) => SubPostList.toJSON(e));
      }
      if (message.thread !== void 0) {
        obj.thread = ThreadInfo.toJSON(message.thread);
      }
      if (message.forum !== void 0) {
        obj.forum = SimpleForum.toJSON(message.forum);
      }
      return obj;
    },
    create(base) {
      return PbFloorResIdl_DataRes.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePbFloorResIdl_DataRes();
      message.page = object.page !== void 0 && object.page !== null ? Page.fromPartial(object.page) : void 0;
      message.post = object.post !== void 0 && object.post !== null ? Post.fromPartial(object.post) : void 0;
      message.subpostList = object.subpostList?.map((e) => SubPostList.fromPartial(e)) || [];
      message.thread = object.thread !== void 0 && object.thread !== null ? ThreadInfo.fromPartial(object.thread) : void 0;
      message.forum = object.forum !== void 0 && object.forum !== null ? SimpleForum.fromPartial(object.forum) : void 0;
      return message;
    }
  };
  function isSet21(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/PbPageReqIdl.ts
  function createBasePbPageReqIdl() {
    return { data: void 0 };
  }
  var PbPageReqIdl = {
    encode(message, writer = new BinaryWriter()) {
      if (message.data !== void 0) {
        PbPageReqIdl_DataReq.encode(message.data, writer.uint32(10).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePbPageReqIdl();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.data = PbPageReqIdl_DataReq.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return { data: isSet22(object.data) ? PbPageReqIdl_DataReq.fromJSON(object.data) : void 0 };
    },
    toJSON(message) {
      const obj = {};
      if (message.data !== void 0) {
        obj.data = PbPageReqIdl_DataReq.toJSON(message.data);
      }
      return obj;
    },
    create(base) {
      return PbPageReqIdl.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePbPageReqIdl();
      message.data = object.data !== void 0 && object.data !== null ? PbPageReqIdl_DataReq.fromPartial(object.data) : void 0;
      return message;
    }
  };
  function createBasePbPageReqIdl_DataReq() {
    return {
      common: void 0,
      kz: "0",
      lz: 0,
      r: 0,
      pid: "0",
      withFloor: 0,
      floorRn: 0,
      rn: 0,
      pn: 0,
      floorSortType: 0
    };
  }
  var PbPageReqIdl_DataReq = {
    encode(message, writer = new BinaryWriter()) {
      if (message.common !== void 0) {
        CommonReq.encode(message.common, writer.uint32(202).fork()).join();
      }
      if (message.kz !== "0") {
        writer.uint32(32).int64(message.kz);
      }
      if (message.lz !== 0) {
        writer.uint32(40).int32(message.lz);
      }
      if (message.r !== 0) {
        writer.uint32(48).int32(message.r);
      }
      if (message.pid !== "0") {
        writer.uint32(56).int64(message.pid);
      }
      if (message.withFloor !== 0) {
        writer.uint32(64).int32(message.withFloor);
      }
      if (message.floorRn !== 0) {
        writer.uint32(72).int32(message.floorRn);
      }
      if (message.rn !== 0) {
        writer.uint32(104).int32(message.rn);
      }
      if (message.pn !== 0) {
        writer.uint32(144).int32(message.pn);
      }
      if (message.floorSortType !== 0) {
        writer.uint32(592).int32(message.floorSortType);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePbPageReqIdl_DataReq();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 25: {
            if (tag !== 202) {
              break;
            }
            message.common = CommonReq.decode(reader, reader.uint32());
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }
            message.kz = reader.int64().toString();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }
            message.lz = reader.int32();
            continue;
          }
          case 6: {
            if (tag !== 48) {
              break;
            }
            message.r = reader.int32();
            continue;
          }
          case 7: {
            if (tag !== 56) {
              break;
            }
            message.pid = reader.int64().toString();
            continue;
          }
          case 8: {
            if (tag !== 64) {
              break;
            }
            message.withFloor = reader.int32();
            continue;
          }
          case 9: {
            if (tag !== 72) {
              break;
            }
            message.floorRn = reader.int32();
            continue;
          }
          case 13: {
            if (tag !== 104) {
              break;
            }
            message.rn = reader.int32();
            continue;
          }
          case 18: {
            if (tag !== 144) {
              break;
            }
            message.pn = reader.int32();
            continue;
          }
          case 74: {
            if (tag !== 592) {
              break;
            }
            message.floorSortType = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        common: isSet22(object.common) ? CommonReq.fromJSON(object.common) : void 0,
        kz: isSet22(object.kz) ? globalThis.String(object.kz) : "0",
        lz: isSet22(object.lz) ? globalThis.Number(object.lz) : 0,
        r: isSet22(object.r) ? globalThis.Number(object.r) : 0,
        pid: isSet22(object.pid) ? globalThis.String(object.pid) : "0",
        withFloor: isSet22(object.withFloor) ? globalThis.Number(object.withFloor) : isSet22(object.with_floor) ? globalThis.Number(object.with_floor) : 0,
        floorRn: isSet22(object.floorRn) ? globalThis.Number(object.floorRn) : isSet22(object.floor_rn) ? globalThis.Number(object.floor_rn) : 0,
        rn: isSet22(object.rn) ? globalThis.Number(object.rn) : 0,
        pn: isSet22(object.pn) ? globalThis.Number(object.pn) : 0,
        floorSortType: isSet22(object.floorSortType) ? globalThis.Number(object.floorSortType) : isSet22(object.floor_sort_type) ? globalThis.Number(object.floor_sort_type) : 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.common !== void 0) {
        obj.common = CommonReq.toJSON(message.common);
      }
      if (message.kz !== "0") {
        obj.kz = message.kz;
      }
      if (message.lz !== 0) {
        obj.lz = Math.round(message.lz);
      }
      if (message.r !== 0) {
        obj.r = Math.round(message.r);
      }
      if (message.pid !== "0") {
        obj.pid = message.pid;
      }
      if (message.withFloor !== 0) {
        obj.withFloor = Math.round(message.withFloor);
      }
      if (message.floorRn !== 0) {
        obj.floorRn = Math.round(message.floorRn);
      }
      if (message.rn !== 0) {
        obj.rn = Math.round(message.rn);
      }
      if (message.pn !== 0) {
        obj.pn = Math.round(message.pn);
      }
      if (message.floorSortType !== 0) {
        obj.floorSortType = Math.round(message.floorSortType);
      }
      return obj;
    },
    create(base) {
      return PbPageReqIdl_DataReq.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePbPageReqIdl_DataReq();
      message.common = object.common !== void 0 && object.common !== null ? CommonReq.fromPartial(object.common) : void 0;
      message.kz = object.kz ?? "0";
      message.lz = object.lz ?? 0;
      message.r = object.r ?? 0;
      message.pid = object.pid ?? "0";
      message.withFloor = object.withFloor ?? 0;
      message.floorRn = object.floorRn ?? 0;
      message.rn = object.rn ?? 0;
      message.pn = object.pn ?? 0;
      message.floorSortType = object.floorSortType ?? 0;
      return message;
    }
  };
  function isSet22(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/PbPageResIdl.ts
  function createBasePbPageResIdl() {
    return { error: void 0, data: void 0 };
  }
  var PbPageResIdl = {
    encode(message, writer = new BinaryWriter()) {
      if (message.error !== void 0) {
        Error4.encode(message.error, writer.uint32(10).fork()).join();
      }
      if (message.data !== void 0) {
        PbPageResIdl_DataRes.encode(message.data, writer.uint32(18).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePbPageResIdl();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.error = Error4.decode(reader, reader.uint32());
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.data = PbPageResIdl_DataRes.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        error: isSet23(object.error) ? Error4.fromJSON(object.error) : void 0,
        data: isSet23(object.data) ? PbPageResIdl_DataRes.fromJSON(object.data) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.error !== void 0) {
        obj.error = Error4.toJSON(message.error);
      }
      if (message.data !== void 0) {
        obj.data = PbPageResIdl_DataRes.toJSON(message.data);
      }
      return obj;
    },
    create(base) {
      return PbPageResIdl.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePbPageResIdl();
      message.error = object.error !== void 0 && object.error !== null ? Error4.fromPartial(object.error) : void 0;
      message.data = object.data !== void 0 && object.data !== null ? PbPageResIdl_DataRes.fromPartial(object.data) : void 0;
      return message;
    }
  };
  function createBasePbPageResIdl_DataRes() {
    return { forum: void 0, page: void 0, postList: [], thread: void 0, userList: [], threadFreqNum: "0" };
  }
  var PbPageResIdl_DataRes = {
    encode(message, writer = new BinaryWriter()) {
      if (message.forum !== void 0) {
        SimpleForum.encode(message.forum, writer.uint32(18).fork()).join();
      }
      if (message.page !== void 0) {
        Page.encode(message.page, writer.uint32(26).fork()).join();
      }
      for (const v of message.postList) {
        Post.encode(v, writer.uint32(50).fork()).join();
      }
      if (message.thread !== void 0) {
        ThreadInfo.encode(message.thread, writer.uint32(66).fork()).join();
      }
      for (const v of message.userList) {
        User.encode(v, writer.uint32(106).fork()).join();
      }
      if (message.threadFreqNum !== "0") {
        writer.uint32(296).int64(message.threadFreqNum);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePbPageResIdl_DataRes();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.forum = SimpleForum.decode(reader, reader.uint32());
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.page = Page.decode(reader, reader.uint32());
            continue;
          }
          case 6: {
            if (tag !== 50) {
              break;
            }
            message.postList.push(Post.decode(reader, reader.uint32()));
            continue;
          }
          case 8: {
            if (tag !== 66) {
              break;
            }
            message.thread = ThreadInfo.decode(reader, reader.uint32());
            continue;
          }
          case 13: {
            if (tag !== 106) {
              break;
            }
            message.userList.push(User.decode(reader, reader.uint32()));
            continue;
          }
          case 37: {
            if (tag !== 296) {
              break;
            }
            message.threadFreqNum = reader.int64().toString();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        forum: isSet23(object.forum) ? SimpleForum.fromJSON(object.forum) : void 0,
        page: isSet23(object.page) ? Page.fromJSON(object.page) : void 0,
        postList: globalThis.Array.isArray(object?.postList) ? object.postList.map((e) => Post.fromJSON(e)) : globalThis.Array.isArray(object?.post_list) ? object.post_list.map((e) => Post.fromJSON(e)) : [],
        thread: isSet23(object.thread) ? ThreadInfo.fromJSON(object.thread) : void 0,
        userList: globalThis.Array.isArray(object?.userList) ? object.userList.map((e) => User.fromJSON(e)) : globalThis.Array.isArray(object?.user_list) ? object.user_list.map((e) => User.fromJSON(e)) : [],
        threadFreqNum: isSet23(object.threadFreqNum) ? globalThis.String(object.threadFreqNum) : isSet23(object.thread_freq_num) ? globalThis.String(object.thread_freq_num) : "0"
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.forum !== void 0) {
        obj.forum = SimpleForum.toJSON(message.forum);
      }
      if (message.page !== void 0) {
        obj.page = Page.toJSON(message.page);
      }
      if (message.postList?.length) {
        obj.postList = message.postList.map((e) => Post.toJSON(e));
      }
      if (message.thread !== void 0) {
        obj.thread = ThreadInfo.toJSON(message.thread);
      }
      if (message.userList?.length) {
        obj.userList = message.userList.map((e) => User.toJSON(e));
      }
      if (message.threadFreqNum !== "0") {
        obj.threadFreqNum = message.threadFreqNum;
      }
      return obj;
    },
    create(base) {
      return PbPageResIdl_DataRes.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePbPageResIdl_DataRes();
      message.forum = object.forum !== void 0 && object.forum !== null ? SimpleForum.fromPartial(object.forum) : void 0;
      message.page = object.page !== void 0 && object.page !== null ? Page.fromPartial(object.page) : void 0;
      message.postList = object.postList?.map((e) => Post.fromPartial(e)) || [];
      message.thread = object.thread !== void 0 && object.thread !== null ? ThreadInfo.fromPartial(object.thread) : void 0;
      message.userList = object.userList?.map((e) => User.fromPartial(e)) || [];
      message.threadFreqNum = object.threadFreqNum ?? "0";
      return message;
    }
  };
  function isSet23(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/UserPostReqIdl.ts
  function createBaseUserPostReqIdl() {
    return { data: void 0 };
  }
  var UserPostReqIdl = {
    encode(message, writer = new BinaryWriter()) {
      if (message.data !== void 0) {
        UserPostReqIdl_DataReq.encode(message.data, writer.uint32(10).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseUserPostReqIdl();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.data = UserPostReqIdl_DataReq.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return { data: isSet24(object.data) ? UserPostReqIdl_DataReq.fromJSON(object.data) : void 0 };
    },
    toJSON(message) {
      const obj = {};
      if (message.data !== void 0) {
        obj.data = UserPostReqIdl_DataReq.toJSON(message.data);
      }
      return obj;
    },
    create(base) {
      return UserPostReqIdl.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseUserPostReqIdl();
      message.data = object.data !== void 0 && object.data !== null ? UserPostReqIdl_DataReq.fromPartial(object.data) : void 0;
      return message;
    }
  };
  function createBaseUserPostReqIdl_DataReq() {
    return { userId: "0", rn: 0, isThread: 0, needContent: 0, pn: 0, isViewCard: 0, common: void 0 };
  }
  var UserPostReqIdl_DataReq = {
    encode(message, writer = new BinaryWriter()) {
      if (message.userId !== "0") {
        writer.uint32(8).int64(message.userId);
      }
      if (message.rn !== 0) {
        writer.uint32(16).uint32(message.rn);
      }
      if (message.isThread !== 0) {
        writer.uint32(32).uint32(message.isThread);
      }
      if (message.needContent !== 0) {
        writer.uint32(40).uint32(message.needContent);
      }
      if (message.pn !== 0) {
        writer.uint32(208).uint32(message.pn);
      }
      if (message.isViewCard !== 0) {
        writer.uint32(264).int32(message.isViewCard);
      }
      if (message.common !== void 0) {
        CommonReq.encode(message.common, writer.uint32(218).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseUserPostReqIdl_DataReq();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.userId = reader.int64().toString();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.rn = reader.uint32();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }
            message.isThread = reader.uint32();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }
            message.needContent = reader.uint32();
            continue;
          }
          case 26: {
            if (tag !== 208) {
              break;
            }
            message.pn = reader.uint32();
            continue;
          }
          case 33: {
            if (tag !== 264) {
              break;
            }
            message.isViewCard = reader.int32();
            continue;
          }
          case 27: {
            if (tag !== 218) {
              break;
            }
            message.common = CommonReq.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        userId: isSet24(object.userId) ? globalThis.String(object.userId) : isSet24(object.user_id) ? globalThis.String(object.user_id) : "0",
        rn: isSet24(object.rn) ? globalThis.Number(object.rn) : 0,
        isThread: isSet24(object.isThread) ? globalThis.Number(object.isThread) : isSet24(object.is_thread) ? globalThis.Number(object.is_thread) : 0,
        needContent: isSet24(object.needContent) ? globalThis.Number(object.needContent) : isSet24(object.need_content) ? globalThis.Number(object.need_content) : 0,
        pn: isSet24(object.pn) ? globalThis.Number(object.pn) : 0,
        isViewCard: isSet24(object.isViewCard) ? globalThis.Number(object.isViewCard) : isSet24(object.is_view_card) ? globalThis.Number(object.is_view_card) : 0,
        common: isSet24(object.common) ? CommonReq.fromJSON(object.common) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.userId !== "0") {
        obj.userId = message.userId;
      }
      if (message.rn !== 0) {
        obj.rn = Math.round(message.rn);
      }
      if (message.isThread !== 0) {
        obj.isThread = Math.round(message.isThread);
      }
      if (message.needContent !== 0) {
        obj.needContent = Math.round(message.needContent);
      }
      if (message.pn !== 0) {
        obj.pn = Math.round(message.pn);
      }
      if (message.isViewCard !== 0) {
        obj.isViewCard = Math.round(message.isViewCard);
      }
      if (message.common !== void 0) {
        obj.common = CommonReq.toJSON(message.common);
      }
      return obj;
    },
    create(base) {
      return UserPostReqIdl_DataReq.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseUserPostReqIdl_DataReq();
      message.userId = object.userId ?? "0";
      message.rn = object.rn ?? 0;
      message.isThread = object.isThread ?? 0;
      message.needContent = object.needContent ?? 0;
      message.pn = object.pn ?? 0;
      message.isViewCard = object.isViewCard ?? 0;
      message.common = object.common !== void 0 && object.common !== null ? CommonReq.fromPartial(object.common) : void 0;
      return message;
    }
  };
  function isSet24(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/PostInfoList.ts
  function createBasePostInfoList() {
    return {
      forumId: "0",
      threadId: "0",
      postId: "0",
      createTime: 0,
      forumName: "",
      title: "",
      content: [],
      userName: "",
      media: [],
      replyNum: 0,
      userId: "0",
      userPortrait: "",
      voiceInfo: [],
      threadType: "0",
      pollInfo: void 0,
      videoInfo: void 0,
      freqNum: 0,
      nameShow: "",
      shareNum: 0,
      agree: void 0,
      isShareThread: 0,
      firstPostContent: []
    };
  }
  var PostInfoList = {
    encode(message, writer = new BinaryWriter()) {
      if (message.forumId !== "0") {
        writer.uint32(8).uint64(message.forumId);
      }
      if (message.threadId !== "0") {
        writer.uint32(16).uint64(message.threadId);
      }
      if (message.postId !== "0") {
        writer.uint32(24).uint64(message.postId);
      }
      if (message.createTime !== 0) {
        writer.uint32(40).uint32(message.createTime);
      }
      if (message.forumName !== "") {
        writer.uint32(50).string(message.forumName);
      }
      if (message.title !== "") {
        writer.uint32(58).string(message.title);
      }
      for (const v of message.content) {
        PostInfoList_PostInfoContent.encode(v, writer.uint32(66).fork()).join();
      }
      if (message.userName !== "") {
        writer.uint32(82).string(message.userName);
      }
      for (const v of message.media) {
        Media.encode(v, writer.uint32(130).fork()).join();
      }
      if (message.replyNum !== 0) {
        writer.uint32(136).uint32(message.replyNum);
      }
      if (message.userId !== "0") {
        writer.uint32(144).int64(message.userId);
      }
      if (message.userPortrait !== "") {
        writer.uint32(154).string(message.userPortrait);
      }
      for (const v of message.voiceInfo) {
        Voice.encode(v, writer.uint32(186).fork()).join();
      }
      if (message.threadType !== "0") {
        writer.uint32(208).uint64(message.threadType);
      }
      if (message.pollInfo !== void 0) {
        PollInfo.encode(message.pollInfo, writer.uint32(226).fork()).join();
      }
      if (message.videoInfo !== void 0) {
        VideoInfo.encode(message.videoInfo, writer.uint32(234).fork()).join();
      }
      if (message.freqNum !== 0) {
        writer.uint32(264).int32(message.freqNum);
      }
      if (message.nameShow !== "") {
        writer.uint32(282).string(message.nameShow);
      }
      if (message.shareNum !== 0) {
        writer.uint32(312).int32(message.shareNum);
      }
      if (message.agree !== void 0) {
        Agree.encode(message.agree, writer.uint32(322).fork()).join();
      }
      if (message.isShareThread !== 0) {
        writer.uint32(352).int32(message.isShareThread);
      }
      for (const v of message.firstPostContent) {
        PbContent.encode(v, writer.uint32(394).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePostInfoList();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.forumId = reader.uint64().toString();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.threadId = reader.uint64().toString();
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }
            message.postId = reader.uint64().toString();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }
            message.createTime = reader.uint32();
            continue;
          }
          case 6: {
            if (tag !== 50) {
              break;
            }
            message.forumName = reader.string();
            continue;
          }
          case 7: {
            if (tag !== 58) {
              break;
            }
            message.title = reader.string();
            continue;
          }
          case 8: {
            if (tag !== 66) {
              break;
            }
            message.content.push(PostInfoList_PostInfoContent.decode(reader, reader.uint32()));
            continue;
          }
          case 10: {
            if (tag !== 82) {
              break;
            }
            message.userName = reader.string();
            continue;
          }
          case 16: {
            if (tag !== 130) {
              break;
            }
            message.media.push(Media.decode(reader, reader.uint32()));
            continue;
          }
          case 17: {
            if (tag !== 136) {
              break;
            }
            message.replyNum = reader.uint32();
            continue;
          }
          case 18: {
            if (tag !== 144) {
              break;
            }
            message.userId = reader.int64().toString();
            continue;
          }
          case 19: {
            if (tag !== 154) {
              break;
            }
            message.userPortrait = reader.string();
            continue;
          }
          case 23: {
            if (tag !== 186) {
              break;
            }
            message.voiceInfo.push(Voice.decode(reader, reader.uint32()));
            continue;
          }
          case 26: {
            if (tag !== 208) {
              break;
            }
            message.threadType = reader.uint64().toString();
            continue;
          }
          case 28: {
            if (tag !== 226) {
              break;
            }
            message.pollInfo = PollInfo.decode(reader, reader.uint32());
            continue;
          }
          case 29: {
            if (tag !== 234) {
              break;
            }
            message.videoInfo = VideoInfo.decode(reader, reader.uint32());
            continue;
          }
          case 33: {
            if (tag !== 264) {
              break;
            }
            message.freqNum = reader.int32();
            continue;
          }
          case 35: {
            if (tag !== 282) {
              break;
            }
            message.nameShow = reader.string();
            continue;
          }
          case 39: {
            if (tag !== 312) {
              break;
            }
            message.shareNum = reader.int32();
            continue;
          }
          case 40: {
            if (tag !== 322) {
              break;
            }
            message.agree = Agree.decode(reader, reader.uint32());
            continue;
          }
          case 44: {
            if (tag !== 352) {
              break;
            }
            message.isShareThread = reader.int32();
            continue;
          }
          case 49: {
            if (tag !== 394) {
              break;
            }
            message.firstPostContent.push(PbContent.decode(reader, reader.uint32()));
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        forumId: isSet25(object.forumId) ? globalThis.String(object.forumId) : isSet25(object.forum_id) ? globalThis.String(object.forum_id) : "0",
        threadId: isSet25(object.threadId) ? globalThis.String(object.threadId) : isSet25(object.thread_id) ? globalThis.String(object.thread_id) : "0",
        postId: isSet25(object.postId) ? globalThis.String(object.postId) : isSet25(object.post_id) ? globalThis.String(object.post_id) : "0",
        createTime: isSet25(object.createTime) ? globalThis.Number(object.createTime) : isSet25(object.create_time) ? globalThis.Number(object.create_time) : 0,
        forumName: isSet25(object.forumName) ? globalThis.String(object.forumName) : isSet25(object.forum_name) ? globalThis.String(object.forum_name) : "",
        title: isSet25(object.title) ? globalThis.String(object.title) : "",
        content: globalThis.Array.isArray(object?.content) ? object.content.map((e) => PostInfoList_PostInfoContent.fromJSON(e)) : [],
        userName: isSet25(object.userName) ? globalThis.String(object.userName) : isSet25(object.user_name) ? globalThis.String(object.user_name) : "",
        media: globalThis.Array.isArray(object?.media) ? object.media.map((e) => Media.fromJSON(e)) : [],
        replyNum: isSet25(object.replyNum) ? globalThis.Number(object.replyNum) : isSet25(object.reply_num) ? globalThis.Number(object.reply_num) : 0,
        userId: isSet25(object.userId) ? globalThis.String(object.userId) : isSet25(object.user_id) ? globalThis.String(object.user_id) : "0",
        userPortrait: isSet25(object.userPortrait) ? globalThis.String(object.userPortrait) : isSet25(object.user_portrait) ? globalThis.String(object.user_portrait) : "",
        voiceInfo: globalThis.Array.isArray(object?.voiceInfo) ? object.voiceInfo.map((e) => Voice.fromJSON(e)) : globalThis.Array.isArray(object?.voice_info) ? object.voice_info.map((e) => Voice.fromJSON(e)) : [],
        threadType: isSet25(object.threadType) ? globalThis.String(object.threadType) : isSet25(object.thread_type) ? globalThis.String(object.thread_type) : "0",
        pollInfo: isSet25(object.pollInfo) ? PollInfo.fromJSON(object.pollInfo) : isSet25(object.poll_info) ? PollInfo.fromJSON(object.poll_info) : void 0,
        videoInfo: isSet25(object.videoInfo) ? VideoInfo.fromJSON(object.videoInfo) : isSet25(object.video_info) ? VideoInfo.fromJSON(object.video_info) : void 0,
        freqNum: isSet25(object.freqNum) ? globalThis.Number(object.freqNum) : isSet25(object.freq_num) ? globalThis.Number(object.freq_num) : 0,
        nameShow: isSet25(object.nameShow) ? globalThis.String(object.nameShow) : isSet25(object.name_show) ? globalThis.String(object.name_show) : "",
        shareNum: isSet25(object.shareNum) ? globalThis.Number(object.shareNum) : isSet25(object.share_num) ? globalThis.Number(object.share_num) : 0,
        agree: isSet25(object.agree) ? Agree.fromJSON(object.agree) : void 0,
        isShareThread: isSet25(object.isShareThread) ? globalThis.Number(object.isShareThread) : isSet25(object.is_share_thread) ? globalThis.Number(object.is_share_thread) : 0,
        firstPostContent: globalThis.Array.isArray(object?.firstPostContent) ? object.firstPostContent.map((e) => PbContent.fromJSON(e)) : globalThis.Array.isArray(object?.first_post_content) ? object.first_post_content.map((e) => PbContent.fromJSON(e)) : []
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.forumId !== "0") {
        obj.forumId = message.forumId;
      }
      if (message.threadId !== "0") {
        obj.threadId = message.threadId;
      }
      if (message.postId !== "0") {
        obj.postId = message.postId;
      }
      if (message.createTime !== 0) {
        obj.createTime = Math.round(message.createTime);
      }
      if (message.forumName !== "") {
        obj.forumName = message.forumName;
      }
      if (message.title !== "") {
        obj.title = message.title;
      }
      if (message.content?.length) {
        obj.content = message.content.map((e) => PostInfoList_PostInfoContent.toJSON(e));
      }
      if (message.userName !== "") {
        obj.userName = message.userName;
      }
      if (message.media?.length) {
        obj.media = message.media.map((e) => Media.toJSON(e));
      }
      if (message.replyNum !== 0) {
        obj.replyNum = Math.round(message.replyNum);
      }
      if (message.userId !== "0") {
        obj.userId = message.userId;
      }
      if (message.userPortrait !== "") {
        obj.userPortrait = message.userPortrait;
      }
      if (message.voiceInfo?.length) {
        obj.voiceInfo = message.voiceInfo.map((e) => Voice.toJSON(e));
      }
      if (message.threadType !== "0") {
        obj.threadType = message.threadType;
      }
      if (message.pollInfo !== void 0) {
        obj.pollInfo = PollInfo.toJSON(message.pollInfo);
      }
      if (message.videoInfo !== void 0) {
        obj.videoInfo = VideoInfo.toJSON(message.videoInfo);
      }
      if (message.freqNum !== 0) {
        obj.freqNum = Math.round(message.freqNum);
      }
      if (message.nameShow !== "") {
        obj.nameShow = message.nameShow;
      }
      if (message.shareNum !== 0) {
        obj.shareNum = Math.round(message.shareNum);
      }
      if (message.agree !== void 0) {
        obj.agree = Agree.toJSON(message.agree);
      }
      if (message.isShareThread !== 0) {
        obj.isShareThread = Math.round(message.isShareThread);
      }
      if (message.firstPostContent?.length) {
        obj.firstPostContent = message.firstPostContent.map((e) => PbContent.toJSON(e));
      }
      return obj;
    },
    create(base) {
      return PostInfoList.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePostInfoList();
      message.forumId = object.forumId ?? "0";
      message.threadId = object.threadId ?? "0";
      message.postId = object.postId ?? "0";
      message.createTime = object.createTime ?? 0;
      message.forumName = object.forumName ?? "";
      message.title = object.title ?? "";
      message.content = object.content?.map((e) => PostInfoList_PostInfoContent.fromPartial(e)) || [];
      message.userName = object.userName ?? "";
      message.media = object.media?.map((e) => Media.fromPartial(e)) || [];
      message.replyNum = object.replyNum ?? 0;
      message.userId = object.userId ?? "0";
      message.userPortrait = object.userPortrait ?? "";
      message.voiceInfo = object.voiceInfo?.map((e) => Voice.fromPartial(e)) || [];
      message.threadType = object.threadType ?? "0";
      message.pollInfo = object.pollInfo !== void 0 && object.pollInfo !== null ? PollInfo.fromPartial(object.pollInfo) : void 0;
      message.videoInfo = object.videoInfo !== void 0 && object.videoInfo !== null ? VideoInfo.fromPartial(object.videoInfo) : void 0;
      message.freqNum = object.freqNum ?? 0;
      message.nameShow = object.nameShow ?? "";
      message.shareNum = object.shareNum ?? 0;
      message.agree = object.agree !== void 0 && object.agree !== null ? Agree.fromPartial(object.agree) : void 0;
      message.isShareThread = object.isShareThread ?? 0;
      message.firstPostContent = object.firstPostContent?.map((e) => PbContent.fromPartial(e)) || [];
      return message;
    }
  };
  function createBasePostInfoList_PostInfoContent() {
    return { postContent: [], createTime: "0", postType: "0", postId: "0" };
  }
  var PostInfoList_PostInfoContent = {
    encode(message, writer = new BinaryWriter()) {
      for (const v of message.postContent) {
        PostInfoList_PostInfoContent_Abstract.encode(v, writer.uint32(10).fork()).join();
      }
      if (message.createTime !== "0") {
        writer.uint32(16).uint64(message.createTime);
      }
      if (message.postType !== "0") {
        writer.uint32(24).uint64(message.postType);
      }
      if (message.postId !== "0") {
        writer.uint32(32).uint64(message.postId);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePostInfoList_PostInfoContent();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.postContent.push(PostInfoList_PostInfoContent_Abstract.decode(reader, reader.uint32()));
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.createTime = reader.uint64().toString();
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }
            message.postType = reader.uint64().toString();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }
            message.postId = reader.uint64().toString();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        postContent: globalThis.Array.isArray(object?.postContent) ? object.postContent.map((e) => PostInfoList_PostInfoContent_Abstract.fromJSON(e)) : globalThis.Array.isArray(object?.post_content) ? object.post_content.map((e) => PostInfoList_PostInfoContent_Abstract.fromJSON(e)) : [],
        createTime: isSet25(object.createTime) ? globalThis.String(object.createTime) : isSet25(object.create_time) ? globalThis.String(object.create_time) : "0",
        postType: isSet25(object.postType) ? globalThis.String(object.postType) : isSet25(object.post_type) ? globalThis.String(object.post_type) : "0",
        postId: isSet25(object.postId) ? globalThis.String(object.postId) : isSet25(object.post_id) ? globalThis.String(object.post_id) : "0"
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.postContent?.length) {
        obj.postContent = message.postContent.map((e) => PostInfoList_PostInfoContent_Abstract.toJSON(e));
      }
      if (message.createTime !== "0") {
        obj.createTime = message.createTime;
      }
      if (message.postType !== "0") {
        obj.postType = message.postType;
      }
      if (message.postId !== "0") {
        obj.postId = message.postId;
      }
      return obj;
    },
    create(base) {
      return PostInfoList_PostInfoContent.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePostInfoList_PostInfoContent();
      message.postContent = object.postContent?.map((e) => PostInfoList_PostInfoContent_Abstract.fromPartial(e)) || [];
      message.createTime = object.createTime ?? "0";
      message.postType = object.postType ?? "0";
      message.postId = object.postId ?? "0";
      return message;
    }
  };
  function createBasePostInfoList_PostInfoContent_Abstract() {
    return { type: 0, text: "", link: "", duringTime: "", voiceMd5: "" };
  }
  var PostInfoList_PostInfoContent_Abstract = {
    encode(message, writer = new BinaryWriter()) {
      if (message.type !== 0) {
        writer.uint32(8).int32(message.type);
      }
      if (message.text !== "") {
        writer.uint32(18).string(message.text);
      }
      if (message.link !== "") {
        writer.uint32(26).string(message.link);
      }
      if (message.duringTime !== "") {
        writer.uint32(50).string(message.duringTime);
      }
      if (message.voiceMd5 !== "") {
        writer.uint32(58).string(message.voiceMd5);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBasePostInfoList_PostInfoContent_Abstract();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.type = reader.int32();
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.text = reader.string();
            continue;
          }
          case 3: {
            if (tag !== 26) {
              break;
            }
            message.link = reader.string();
            continue;
          }
          case 6: {
            if (tag !== 50) {
              break;
            }
            message.duringTime = reader.string();
            continue;
          }
          case 7: {
            if (tag !== 58) {
              break;
            }
            message.voiceMd5 = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        type: isSet25(object.type) ? globalThis.Number(object.type) : 0,
        text: isSet25(object.text) ? globalThis.String(object.text) : "",
        link: isSet25(object.link) ? globalThis.String(object.link) : "",
        duringTime: isSet25(object.duringTime) ? globalThis.String(object.duringTime) : isSet25(object.during_time) ? globalThis.String(object.during_time) : "",
        voiceMd5: isSet25(object.voiceMd5) ? globalThis.String(object.voiceMd5) : isSet25(object.voice_md5) ? globalThis.String(object.voice_md5) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.type !== 0) {
        obj.type = Math.round(message.type);
      }
      if (message.text !== "") {
        obj.text = message.text;
      }
      if (message.link !== "") {
        obj.link = message.link;
      }
      if (message.duringTime !== "") {
        obj.duringTime = message.duringTime;
      }
      if (message.voiceMd5 !== "") {
        obj.voiceMd5 = message.voiceMd5;
      }
      return obj;
    },
    create(base) {
      return PostInfoList_PostInfoContent_Abstract.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBasePostInfoList_PostInfoContent_Abstract();
      message.type = object.type ?? 0;
      message.text = object.text ?? "";
      message.link = object.link ?? "";
      message.duringTime = object.duringTime ?? "";
      message.voiceMd5 = object.voiceMd5 ?? "";
      return message;
    }
  };
  function isSet25(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/UserPostResIdl.ts
  function createBaseUserPostResIdl() {
    return { error: void 0, data: void 0 };
  }
  var UserPostResIdl = {
    encode(message, writer = new BinaryWriter()) {
      if (message.error !== void 0) {
        Error4.encode(message.error, writer.uint32(10).fork()).join();
      }
      if (message.data !== void 0) {
        UserPostResIdl_DataRes.encode(message.data, writer.uint32(18).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseUserPostResIdl();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.error = Error4.decode(reader, reader.uint32());
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.data = UserPostResIdl_DataRes.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        error: isSet26(object.error) ? Error4.fromJSON(object.error) : void 0,
        data: isSet26(object.data) ? UserPostResIdl_DataRes.fromJSON(object.data) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.error !== void 0) {
        obj.error = Error4.toJSON(message.error);
      }
      if (message.data !== void 0) {
        obj.data = UserPostResIdl_DataRes.toJSON(message.data);
      }
      return obj;
    },
    create(base) {
      return UserPostResIdl.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseUserPostResIdl();
      message.error = object.error !== void 0 && object.error !== null ? Error4.fromPartial(object.error) : void 0;
      message.data = object.data !== void 0 && object.data !== null ? UserPostResIdl_DataRes.fromPartial(object.data) : void 0;
      return message;
    }
  };
  function createBaseUserPostResIdl_DataRes() {
    return {
      postList: [],
      hidePost: 0,
      time: "0",
      ctime: "0",
      logid: "0",
      maskType: 0,
      viewCardNum: 0,
      reddotDeletedThread: 0
    };
  }
  var UserPostResIdl_DataRes = {
    encode(message, writer = new BinaryWriter()) {
      for (const v of message.postList) {
        PostInfoList.encode(v, writer.uint32(10).fork()).join();
      }
      if (message.hidePost !== 0) {
        writer.uint32(16).uint32(message.hidePost);
      }
      if (message.time !== "0") {
        writer.uint32(24).uint64(message.time);
      }
      if (message.ctime !== "0") {
        writer.uint32(32).uint64(message.ctime);
      }
      if (message.logid !== "0") {
        writer.uint32(40).uint64(message.logid);
      }
      if (message.maskType !== 0) {
        writer.uint32(48).int32(message.maskType);
      }
      if (message.viewCardNum !== 0) {
        writer.uint32(56).int32(message.viewCardNum);
      }
      if (message.reddotDeletedThread !== 0) {
        writer.uint32(64).int32(message.reddotDeletedThread);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseUserPostResIdl_DataRes();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.postList.push(PostInfoList.decode(reader, reader.uint32()));
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.hidePost = reader.uint32();
            continue;
          }
          case 3: {
            if (tag !== 24) {
              break;
            }
            message.time = reader.uint64().toString();
            continue;
          }
          case 4: {
            if (tag !== 32) {
              break;
            }
            message.ctime = reader.uint64().toString();
            continue;
          }
          case 5: {
            if (tag !== 40) {
              break;
            }
            message.logid = reader.uint64().toString();
            continue;
          }
          case 6: {
            if (tag !== 48) {
              break;
            }
            message.maskType = reader.int32();
            continue;
          }
          case 7: {
            if (tag !== 56) {
              break;
            }
            message.viewCardNum = reader.int32();
            continue;
          }
          case 8: {
            if (tag !== 64) {
              break;
            }
            message.reddotDeletedThread = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        postList: globalThis.Array.isArray(object?.postList) ? object.postList.map((e) => PostInfoList.fromJSON(e)) : globalThis.Array.isArray(object?.post_list) ? object.post_list.map((e) => PostInfoList.fromJSON(e)) : [],
        hidePost: isSet26(object.hidePost) ? globalThis.Number(object.hidePost) : isSet26(object.hide_post) ? globalThis.Number(object.hide_post) : 0,
        time: isSet26(object.time) ? globalThis.String(object.time) : "0",
        ctime: isSet26(object.ctime) ? globalThis.String(object.ctime) : "0",
        logid: isSet26(object.logid) ? globalThis.String(object.logid) : "0",
        maskType: isSet26(object.maskType) ? globalThis.Number(object.maskType) : isSet26(object.mask_type) ? globalThis.Number(object.mask_type) : 0,
        viewCardNum: isSet26(object.viewCardNum) ? globalThis.Number(object.viewCardNum) : isSet26(object.view_card_num) ? globalThis.Number(object.view_card_num) : 0,
        reddotDeletedThread: isSet26(object.reddotDeletedThread) ? globalThis.Number(object.reddotDeletedThread) : isSet26(object.reddot_deleted_thread) ? globalThis.Number(object.reddot_deleted_thread) : 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.postList?.length) {
        obj.postList = message.postList.map((e) => PostInfoList.toJSON(e));
      }
      if (message.hidePost !== 0) {
        obj.hidePost = Math.round(message.hidePost);
      }
      if (message.time !== "0") {
        obj.time = message.time;
      }
      if (message.ctime !== "0") {
        obj.ctime = message.ctime;
      }
      if (message.logid !== "0") {
        obj.logid = message.logid;
      }
      if (message.maskType !== 0) {
        obj.maskType = Math.round(message.maskType);
      }
      if (message.viewCardNum !== 0) {
        obj.viewCardNum = Math.round(message.viewCardNum);
      }
      if (message.reddotDeletedThread !== 0) {
        obj.reddotDeletedThread = Math.round(message.reddotDeletedThread);
      }
      return obj;
    },
    create(base) {
      return UserPostResIdl_DataRes.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseUserPostResIdl_DataRes();
      message.postList = object.postList?.map((e) => PostInfoList.fromPartial(e)) || [];
      message.hidePost = object.hidePost ?? 0;
      message.time = object.time ?? "0";
      message.ctime = object.ctime ?? "0";
      message.logid = object.logid ?? "0";
      message.maskType = object.maskType ?? 0;
      message.viewCardNum = object.viewCardNum ?? 0;
      message.reddotDeletedThread = object.reddotDeletedThread ?? 0;
      return message;
    }
  };
  function isSet26(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/helpers/cache.ts
  var forumNameCache = null;
  function createForumNameCache() {
    if (!forumNameCache) {
      forumNameCache = Cache_exports.make({
        capacity: 500,
        timeToLive: Duration_exports.infinity,
        lookup: (id) => getForumName(Number(id))
      });
    }
    return forumNameCache;
  }
  function processUserPosts(posts, needForumName = false) {
    if (!posts?.length) {
      return Effect_exports.succeed([]);
    }
    return Effect_exports.gen(function* () {
      let forumCache;
      if (needForumName) {
        forumCache = yield* createForumNameCache();
        const forumIDList = [...new Set(posts.map((post) => post.forumId))];
        yield* Effect_exports.all(
          forumIDList.map((id) => forumCache.get(id)),
          { concurrency: 5 }
        );
      }
      const result = [];
      for (const post of posts) {
        const forumName = needForumName && forumCache ? yield* forumCache.get(post.forumId) : post.forumName;
        for (const entry of post.content) {
          const affiliated = entry.postType === "1";
          const isReply = affiliated && entry.postContent.length >= 3 && entry.postContent[1]?.type === 4;
          result.push({
            forumId: Number(post.forumId),
            forumName,
            title: post.title[0] === "回" && post.title[2] === "：" ? post.title.slice(3) : post.title,
            threadId: post.threadId,
            postId: post.postId,
            cid: entry.postId,
            createTime: Number(entry.createTime),
            affiliated,
            content: isReply ? (entry.postContent[2]?.text ?? "").slice(2) : entry.postContent.length === 1 ? entry.postContent[0]?.text ?? "" : entry.postContent.map((item) => item.text).join(""),
            replyTo: isReply ? entry.postContent[1]?.text : void 0
          });
        }
      }
      return result;
    });
  }

  // <eztb>/packages/sdk/src/api/post.ts
  var MAX_PAGE = 600;
  function packPostsProto(params) {
    const rn = Math.min(Math.max(params.rn || 30, 1), 30);
    const data = {
      kz: params.tid.toString(),
      pn: params.page || 1,
      // 单页最大 30
      rn,
      // 1 时间倒序，2 热门排序，3 及以上时间正序
      r: params.sort || 3,
      lz: params.onlyThreadAuthor ? 1 : 0,
      common: {
        ClientType: CLIENT_TYPE,
        ClientVersion: CLIENT_VERSION
      }
    };
    if (params.withComment) {
      data.common.BDUSS = getClient().bduss;
      data.withFloor = 1;
      data.floorSortType = params.commentsSortByTime ? 0 : 1;
      data.floorRn = params.commentRn || 4;
    }
    const req = PbPageReqIdl.fromPartial({ data });
    return PbPageReqIdl.encode(req).finish();
  }
  function parsePostsBody(buffer) {
    const res = PbPageResIdl.decode(buffer);
    if (res.error?.errorno) {
      throw new TiebaServerError(res.error.errorno, res.error.errmsg ?? "");
    }
    return res.data;
  }
  function getSinglePage(params) {
    const effect = pipe(
      Effect_exports.succeed(packPostsProto(params)),
      Effect_exports.andThen(
        (buf) => getClient().postProtobuf("/c/f/pb/page?cmd=303002", buf)
      ),
      Effect_exports.map(parsePostsBody)
    );
    if (params.withComment) {
      return effect.pipe(
        Effect_exports.retry({
          schedule: Schedule_exports.exponential(1e3),
          times: 3
        })
      );
    }
    return effect;
  }
  function fetchPages(pages, makeParams) {
    const effects = pages.map((pg) => getSinglePage(makeParams(pg)));
    return Effect_exports.all(effects, { concurrency: 5, mode: "either" }).pipe(
      Effect_exports.map((results) => {
        const postsArr = [];
        const usersArr = [];
        for (const r of results) {
          if (Either_exports.isRight(r)) {
            if (r.right?.postList) postsArr.push(r.right.postList);
            if (r.right?.userList) usersArr.push(r.right.userList);
          }
        }
        return { posts: postsArr.flat(1), users: usersArr.flat(1) };
      })
    );
  }
  function getPosts(tid, page, options) {
    const makeParams = (pg) => ({
      tid,
      page: pg,
      ...options
    });
    if (typeof page === "number") {
      return getSinglePage(makeParams(page));
    }
    return Effect_exports.gen(function* () {
      const from = page === "ALL" ? 1 : Math.max(1, page[0]);
      const requestedLastPage = page === "ALL" ? MAX_PAGE : Math.max(from, page[1]);
      const firstResult = yield* getSinglePage(makeParams(from));
      const totalPage = Math.max(
        1,
        Math.min(firstResult?.page?.totalPage || 1, MAX_PAGE)
      );
      const lastPage = page === "ALL" ? totalPage : Math.min(requestedLastPage, totalPage);
      if (page !== "ALL" && from > totalPage) {
        if (firstResult?.postList) firstResult.postList = [];
        if (firstResult?.userList) firstResult.userList = [];
        return firstResult;
      }
      if (from >= lastPage) return firstResult;
      const remaining = Array.from(
        { length: lastPage - from },
        (_, i) => from + 1 + i
      );
      const { posts, users } = yield* fetchPages(remaining, makeParams);
      if (firstResult?.postList) {
        firstResult.postList.push(...posts);
      }
      if (firstResult?.userList) {
        firstResult.userList.push(...users);
      }
      return firstResult;
    });
  }
  var getUserPostSingle = createProtoApi({
    endpoint: "/c/u/feed/userpost?cmd=303002",
    reqCodec: UserPostReqIdl,
    resCodec: UserPostResIdl,
    buildRequest: (params) => ({
      data: {
        needContent: 1,
        userId: params.uid.toString(),
        pn: params.pn,
        common: { ClientVersion: CLIENT_VERSION_OLD }
      }
    }),
    extractResult: (res) => res.data?.postList ?? []
  });
  var getComments = createProtoApi({
    endpoint: "/c/f/pb/floor?cmd=303002",
    reqCodec: PbFloorReqIdl,
    resCodec: PbFloorResIdl,
    buildRequest: (params) => ({
      data: {
        kz: params.tid.toString(),
        pid: params.pid.toString(),
        pn: params.pn || 1,
        common: {
          ClientType: CLIENT_TYPE,
          ClientVersion: CLIENT_VERSION
        }
      }
    }),
    extractResult: (res) => res.data
  });
  var delPost = createFormApi({
    endpoint: "/c/c/bawu/delpost",
    buildParams: (params) => ({
      fid: params.fid.toString(),
      z: params.tid.toString(),
      pid: params.pid.toString()
    })
  });
  var delThread = createFormApi({
    endpoint: "/c/c/bawu/delthread",
    buildParams: (params) => ({
      fid: params.fid.toString(),
      z: params.tid.toString()
    })
  });

  // <eztb>/packages/sdk/src/generated/GetUserByUidReqIdl.ts
  function createBaseGetUserByUidReqIdl() {
    return { data: void 0 };
  }
  var GetUserByUidReqIdl = {
    encode(message, writer = new BinaryWriter()) {
      if (message.data !== void 0) {
        GetUserByUidReqIdl_DataReq.encode(message.data, writer.uint32(10).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseGetUserByUidReqIdl();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.data = GetUserByUidReqIdl_DataReq.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return { data: isSet27(object.data) ? GetUserByUidReqIdl_DataReq.fromJSON(object.data) : void 0 };
    },
    toJSON(message) {
      const obj = {};
      if (message.data !== void 0) {
        obj.data = GetUserByUidReqIdl_DataReq.toJSON(message.data);
      }
      return obj;
    },
    create(base) {
      return GetUserByUidReqIdl.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseGetUserByUidReqIdl();
      message.data = object.data !== void 0 && object.data !== null ? GetUserByUidReqIdl_DataReq.fromPartial(object.data) : void 0;
      return message;
    }
  };
  function createBaseGetUserByUidReqIdl_DataReq() {
    return { common: void 0, tiebaUid: "" };
  }
  var GetUserByUidReqIdl_DataReq = {
    encode(message, writer = new BinaryWriter()) {
      if (message.common !== void 0) {
        CommonReq.encode(message.common, writer.uint32(10).fork()).join();
      }
      if (message.tiebaUid !== "") {
        writer.uint32(18).string(message.tiebaUid);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseGetUserByUidReqIdl_DataReq();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.common = CommonReq.decode(reader, reader.uint32());
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.tiebaUid = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        common: isSet27(object.common) ? CommonReq.fromJSON(object.common) : void 0,
        tiebaUid: isSet27(object.tiebaUid) ? globalThis.String(object.tiebaUid) : isSet27(object.tieba_uid) ? globalThis.String(object.tieba_uid) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.common !== void 0) {
        obj.common = CommonReq.toJSON(message.common);
      }
      if (message.tiebaUid !== "") {
        obj.tiebaUid = message.tiebaUid;
      }
      return obj;
    },
    create(base) {
      return GetUserByUidReqIdl_DataReq.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseGetUserByUidReqIdl_DataReq();
      message.common = object.common !== void 0 && object.common !== null ? CommonReq.fromPartial(object.common) : void 0;
      message.tiebaUid = object.tiebaUid ?? "";
      return message;
    }
  };
  function isSet27(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/GetUserByUidResIdl.ts
  function createBaseGetUserByUidResIdl() {
    return { error: void 0, data: void 0 };
  }
  var GetUserByUidResIdl = {
    encode(message, writer = new BinaryWriter()) {
      if (message.error !== void 0) {
        Error4.encode(message.error, writer.uint32(10).fork()).join();
      }
      if (message.data !== void 0) {
        GetUserByUidResIdl_DataRes.encode(message.data, writer.uint32(18).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseGetUserByUidResIdl();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.error = Error4.decode(reader, reader.uint32());
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.data = GetUserByUidResIdl_DataRes.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        error: isSet28(object.error) ? Error4.fromJSON(object.error) : void 0,
        data: isSet28(object.data) ? GetUserByUidResIdl_DataRes.fromJSON(object.data) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.error !== void 0) {
        obj.error = Error4.toJSON(message.error);
      }
      if (message.data !== void 0) {
        obj.data = GetUserByUidResIdl_DataRes.toJSON(message.data);
      }
      return obj;
    },
    create(base) {
      return GetUserByUidResIdl.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseGetUserByUidResIdl();
      message.error = object.error !== void 0 && object.error !== null ? Error4.fromPartial(object.error) : void 0;
      message.data = object.data !== void 0 && object.data !== null ? GetUserByUidResIdl_DataRes.fromPartial(object.data) : void 0;
      return message;
    }
  };
  function createBaseGetUserByUidResIdl_DataRes() {
    return { user: void 0 };
  }
  var GetUserByUidResIdl_DataRes = {
    encode(message, writer = new BinaryWriter()) {
      if (message.user !== void 0) {
        User.encode(message.user, writer.uint32(10).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseGetUserByUidResIdl_DataRes();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.user = User.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return { user: isSet28(object.user) ? User.fromJSON(object.user) : void 0 };
    },
    toJSON(message) {
      const obj = {};
      if (message.user !== void 0) {
        obj.user = User.toJSON(message.user);
      }
      return obj;
    },
    create(base) {
      return GetUserByUidResIdl_DataRes.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseGetUserByUidResIdl_DataRes();
      message.user = object.user !== void 0 && object.user !== null ? User.fromPartial(object.user) : void 0;
      return message;
    }
  };
  function isSet28(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/ProfileReqIdl.ts
  function createBaseProfileReqIdl() {
    return { data: void 0 };
  }
  var ProfileReqIdl = {
    encode(message, writer = new BinaryWriter()) {
      if (message.data !== void 0) {
        ProfileReqIdl_DataReq.encode(message.data, writer.uint32(10).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseProfileReqIdl();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.data = ProfileReqIdl_DataReq.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return { data: isSet29(object.data) ? ProfileReqIdl_DataReq.fromJSON(object.data) : void 0 };
    },
    toJSON(message) {
      const obj = {};
      if (message.data !== void 0) {
        obj.data = ProfileReqIdl_DataReq.toJSON(message.data);
      }
      return obj;
    },
    create(base) {
      return ProfileReqIdl.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseProfileReqIdl();
      message.data = object.data !== void 0 && object.data !== null ? ProfileReqIdl_DataReq.fromPartial(object.data) : void 0;
      return message;
    }
  };
  function createBaseProfileReqIdl_DataReq() {
    return { uid: "0", needPostCount: 0, pn: 0, common: void 0, page: 0, friendUidPortrait: "" };
  }
  var ProfileReqIdl_DataReq = {
    encode(message, writer = new BinaryWriter()) {
      if (message.uid !== "0") {
        writer.uint32(8).int64(message.uid);
      }
      if (message.needPostCount !== 0) {
        writer.uint32(16).uint32(message.needPostCount);
      }
      if (message.pn !== 0) {
        writer.uint32(48).uint32(message.pn);
      }
      if (message.common !== void 0) {
        CommonReq.encode(message.common, writer.uint32(74).fork()).join();
      }
      if (message.page !== 0) {
        writer.uint32(120).int32(message.page);
      }
      if (message.friendUidPortrait !== "") {
        writer.uint32(130).string(message.friendUidPortrait);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseProfileReqIdl_DataReq();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.uid = reader.int64().toString();
            continue;
          }
          case 2: {
            if (tag !== 16) {
              break;
            }
            message.needPostCount = reader.uint32();
            continue;
          }
          case 6: {
            if (tag !== 48) {
              break;
            }
            message.pn = reader.uint32();
            continue;
          }
          case 9: {
            if (tag !== 74) {
              break;
            }
            message.common = CommonReq.decode(reader, reader.uint32());
            continue;
          }
          case 15: {
            if (tag !== 120) {
              break;
            }
            message.page = reader.int32();
            continue;
          }
          case 16: {
            if (tag !== 130) {
              break;
            }
            message.friendUidPortrait = reader.string();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        uid: isSet29(object.uid) ? globalThis.String(object.uid) : "0",
        needPostCount: isSet29(object.needPostCount) ? globalThis.Number(object.needPostCount) : isSet29(object.need_post_count) ? globalThis.Number(object.need_post_count) : 0,
        pn: isSet29(object.pn) ? globalThis.Number(object.pn) : 0,
        common: isSet29(object.common) ? CommonReq.fromJSON(object.common) : void 0,
        page: isSet29(object.page) ? globalThis.Number(object.page) : 0,
        friendUidPortrait: isSet29(object.friendUidPortrait) ? globalThis.String(object.friendUidPortrait) : isSet29(object.friend_uid_portrait) ? globalThis.String(object.friend_uid_portrait) : ""
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.uid !== "0") {
        obj.uid = message.uid;
      }
      if (message.needPostCount !== 0) {
        obj.needPostCount = Math.round(message.needPostCount);
      }
      if (message.pn !== 0) {
        obj.pn = Math.round(message.pn);
      }
      if (message.common !== void 0) {
        obj.common = CommonReq.toJSON(message.common);
      }
      if (message.page !== 0) {
        obj.page = Math.round(message.page);
      }
      if (message.friendUidPortrait !== "") {
        obj.friendUidPortrait = message.friendUidPortrait;
      }
      return obj;
    },
    create(base) {
      return ProfileReqIdl_DataReq.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseProfileReqIdl_DataReq();
      message.uid = object.uid ?? "0";
      message.needPostCount = object.needPostCount ?? 0;
      message.pn = object.pn ?? 0;
      message.common = object.common !== void 0 && object.common !== null ? CommonReq.fromPartial(object.common) : void 0;
      message.page = object.page ?? 0;
      message.friendUidPortrait = object.friendUidPortrait ?? "";
      return message;
    }
  };
  function isSet29(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/generated/ProfileResIdl.ts
  function createBaseProfileResIdl() {
    return { error: void 0, data: void 0 };
  }
  var ProfileResIdl = {
    encode(message, writer = new BinaryWriter()) {
      if (message.error !== void 0) {
        Error4.encode(message.error, writer.uint32(10).fork()).join();
      }
      if (message.data !== void 0) {
        ProfileResIdl_DataRes.encode(message.data, writer.uint32(18).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseProfileResIdl();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.error = Error4.decode(reader, reader.uint32());
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.data = ProfileResIdl_DataRes.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        error: isSet30(object.error) ? Error4.fromJSON(object.error) : void 0,
        data: isSet30(object.data) ? ProfileResIdl_DataRes.fromJSON(object.data) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.error !== void 0) {
        obj.error = Error4.toJSON(message.error);
      }
      if (message.data !== void 0) {
        obj.data = ProfileResIdl_DataRes.toJSON(message.data);
      }
      return obj;
    },
    create(base) {
      return ProfileResIdl.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseProfileResIdl();
      message.error = object.error !== void 0 && object.error !== null ? Error4.fromPartial(object.error) : void 0;
      message.data = object.data !== void 0 && object.data !== null ? ProfileResIdl_DataRes.fromPartial(object.data) : void 0;
      return message;
    }
  };
  function createBaseProfileResIdl_DataRes() {
    return { user: void 0, antiStat: void 0, postList: [], userAgreeInfo: void 0 };
  }
  var ProfileResIdl_DataRes = {
    encode(message, writer = new BinaryWriter()) {
      if (message.user !== void 0) {
        User.encode(message.user, writer.uint32(10).fork()).join();
      }
      if (message.antiStat !== void 0) {
        ProfileResIdl_DataRes_Anti.encode(message.antiStat, writer.uint32(18).fork()).join();
      }
      for (const v of message.postList) {
        PostInfoList.encode(v, writer.uint32(34).fork()).join();
      }
      if (message.userAgreeInfo !== void 0) {
        ProfileResIdl_DataRes_UserAgreeInfo.encode(message.userAgreeInfo, writer.uint32(114).fork()).join();
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseProfileResIdl_DataRes();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 10) {
              break;
            }
            message.user = User.decode(reader, reader.uint32());
            continue;
          }
          case 2: {
            if (tag !== 18) {
              break;
            }
            message.antiStat = ProfileResIdl_DataRes_Anti.decode(reader, reader.uint32());
            continue;
          }
          case 4: {
            if (tag !== 34) {
              break;
            }
            message.postList.push(PostInfoList.decode(reader, reader.uint32()));
            continue;
          }
          case 14: {
            if (tag !== 114) {
              break;
            }
            message.userAgreeInfo = ProfileResIdl_DataRes_UserAgreeInfo.decode(reader, reader.uint32());
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        user: isSet30(object.user) ? User.fromJSON(object.user) : void 0,
        antiStat: isSet30(object.antiStat) ? ProfileResIdl_DataRes_Anti.fromJSON(object.antiStat) : isSet30(object.anti_stat) ? ProfileResIdl_DataRes_Anti.fromJSON(object.anti_stat) : void 0,
        postList: globalThis.Array.isArray(object?.postList) ? object.postList.map((e) => PostInfoList.fromJSON(e)) : globalThis.Array.isArray(object?.post_list) ? object.post_list.map((e) => PostInfoList.fromJSON(e)) : [],
        userAgreeInfo: isSet30(object.userAgreeInfo) ? ProfileResIdl_DataRes_UserAgreeInfo.fromJSON(object.userAgreeInfo) : isSet30(object.user_agree_info) ? ProfileResIdl_DataRes_UserAgreeInfo.fromJSON(object.user_agree_info) : void 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.user !== void 0) {
        obj.user = User.toJSON(message.user);
      }
      if (message.antiStat !== void 0) {
        obj.antiStat = ProfileResIdl_DataRes_Anti.toJSON(message.antiStat);
      }
      if (message.postList?.length) {
        obj.postList = message.postList.map((e) => PostInfoList.toJSON(e));
      }
      if (message.userAgreeInfo !== void 0) {
        obj.userAgreeInfo = ProfileResIdl_DataRes_UserAgreeInfo.toJSON(message.userAgreeInfo);
      }
      return obj;
    },
    create(base) {
      return ProfileResIdl_DataRes.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseProfileResIdl_DataRes();
      message.user = object.user !== void 0 && object.user !== null ? User.fromPartial(object.user) : void 0;
      message.antiStat = object.antiStat !== void 0 && object.antiStat !== null ? ProfileResIdl_DataRes_Anti.fromPartial(object.antiStat) : void 0;
      message.postList = object.postList?.map((e) => PostInfoList.fromPartial(e)) || [];
      message.userAgreeInfo = object.userAgreeInfo !== void 0 && object.userAgreeInfo !== null ? ProfileResIdl_DataRes_UserAgreeInfo.fromPartial(object.userAgreeInfo) : void 0;
      return message;
    }
  };
  function createBaseProfileResIdl_DataRes_Anti() {
    return { blockStat: 0, hideStat: 0, daysTofree: 0 };
  }
  var ProfileResIdl_DataRes_Anti = {
    encode(message, writer = new BinaryWriter()) {
      if (message.blockStat !== 0) {
        writer.uint32(48).int32(message.blockStat);
      }
      if (message.hideStat !== 0) {
        writer.uint32(56).int32(message.hideStat);
      }
      if (message.daysTofree !== 0) {
        writer.uint32(72).int32(message.daysTofree);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseProfileResIdl_DataRes_Anti();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 6: {
            if (tag !== 48) {
              break;
            }
            message.blockStat = reader.int32();
            continue;
          }
          case 7: {
            if (tag !== 56) {
              break;
            }
            message.hideStat = reader.int32();
            continue;
          }
          case 9: {
            if (tag !== 72) {
              break;
            }
            message.daysTofree = reader.int32();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        blockStat: isSet30(object.blockStat) ? globalThis.Number(object.blockStat) : isSet30(object.block_stat) ? globalThis.Number(object.block_stat) : 0,
        hideStat: isSet30(object.hideStat) ? globalThis.Number(object.hideStat) : isSet30(object.hide_stat) ? globalThis.Number(object.hide_stat) : 0,
        daysTofree: isSet30(object.daysTofree) ? globalThis.Number(object.daysTofree) : isSet30(object.days_tofree) ? globalThis.Number(object.days_tofree) : 0
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.blockStat !== 0) {
        obj.blockStat = Math.round(message.blockStat);
      }
      if (message.hideStat !== 0) {
        obj.hideStat = Math.round(message.hideStat);
      }
      if (message.daysTofree !== 0) {
        obj.daysTofree = Math.round(message.daysTofree);
      }
      return obj;
    },
    create(base) {
      return ProfileResIdl_DataRes_Anti.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseProfileResIdl_DataRes_Anti();
      message.blockStat = object.blockStat ?? 0;
      message.hideStat = object.hideStat ?? 0;
      message.daysTofree = object.daysTofree ?? 0;
      return message;
    }
  };
  function createBaseProfileResIdl_DataRes_UserAgreeInfo() {
    return { totalAgreeNum: "0" };
  }
  var ProfileResIdl_DataRes_UserAgreeInfo = {
    encode(message, writer = new BinaryWriter()) {
      if (message.totalAgreeNum !== "0") {
        writer.uint32(8).int64(message.totalAgreeNum);
      }
      return writer;
    },
    decode(input, length2) {
      const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
      const end3 = length2 === void 0 ? reader.len : reader.pos + length2;
      const message = createBaseProfileResIdl_DataRes_UserAgreeInfo();
      while (reader.pos < end3) {
        const tag = reader.uint32();
        switch (tag >>> 3) {
          case 1: {
            if (tag !== 8) {
              break;
            }
            message.totalAgreeNum = reader.int64().toString();
            continue;
          }
        }
        if ((tag & 7) === 4 || tag === 0) {
          break;
        }
        reader.skip(tag & 7);
      }
      return message;
    },
    fromJSON(object) {
      return {
        totalAgreeNum: isSet30(object.totalAgreeNum) ? globalThis.String(object.totalAgreeNum) : isSet30(object.total_agree_num) ? globalThis.String(object.total_agree_num) : "0"
      };
    },
    toJSON(message) {
      const obj = {};
      if (message.totalAgreeNum !== "0") {
        obj.totalAgreeNum = message.totalAgreeNum;
      }
      return obj;
    },
    create(base) {
      return ProfileResIdl_DataRes_UserAgreeInfo.fromPartial(base ?? {});
    },
    fromPartial(object) {
      const message = createBaseProfileResIdl_DataRes_UserAgreeInfo();
      message.totalAgreeNum = object.totalAgreeNum ?? "0";
      return message;
    }
  };
  function isSet30(value) {
    return value !== null && value !== void 0;
  }

  // <eztb>/packages/sdk/src/api/user.ts
  function getUserInfo(username) {
    return pipe(
      getData(
        `/i/sys/user_json?un=${encodeURIComponent(username)}&ie=utf-8`
      ),
      Effect_exports.andThen((res) => res.creator)
    );
  }
  var getUserByUid = createProtoApi({
    endpoint: "/c/u/user/getUserByTiebaUid?cmd=309702",
    reqCodec: GetUserByUidReqIdl,
    resCodec: GetUserByUidResIdl,
    buildRequest: (uid) => ({
      data: {
        tiebaUid: uid.toString(),
        common: {
          ClientType: CLIENT_TYPE,
          ClientVersion: CLIENT_VERSION
        }
      }
    }),
    extractResult: (res) => res.data?.user
  });
  var getProfile = createProtoApi({
    endpoint: "/c/u/user/profile?cmd=303012",
    reqCodec: ProfileReqIdl,
    resCodec: ProfileResIdl,
    buildRequest: (id) => {
      const data = {
        needPostCount: 1,
        pn: 1,
        common: {
          ClientType: CLIENT_TYPE,
          ClientVersion: CLIENT_VERSION
        }
      };
      if (typeof id === "string") {
        data.friendUidPortrait = id;
      } else {
        data.uid = id.toString();
      }
      return { data };
    },
    extractResult: (res) => res.data
  });
  function getPanel(un) {
    return pipe(
      getData(
        `https://tiebac.baidu.com/home/get/panel?un=${encodeURIComponent(un)}`
      ),
      Effect_exports.map((res) => res.data)
    );
  }
  function getFans(id, page = 1) {
    const client = getClient();
    const fetchPage = (pg) => postFormData(
      "/c/u/fans/page",
      client.packRequest({ uid: id.toString(), page: pg.toString() })
    );
    if (typeof page === "number") {
      return fetchPage(page);
    }
    return Effect_exports.gen(function* () {
      const from = page === "ALL" ? 1 : Math.max(1, page[0]);
      const requestedLastPage = page === "ALL" ? Number.POSITIVE_INFINITY : Math.max(from, page[1]);
      const firstRes = yield* fetchPage(from);
      const totalPage = Math.max(1, Number(firstRes.page?.total_page ?? 1) || 1);
      const lastPage = page === "ALL" ? totalPage : Math.min(requestedLastPage, totalPage);
      if (page !== "ALL" && from > totalPage) {
        firstRes.user_list = [];
        return firstRes;
      }
      if (from >= lastPage) return firstRes;
      const remaining = Array.from(
        { length: lastPage - from },
        (_, i) => from + 1 + i
      );
      const results = yield* Effect_exports.all(
        remaining.map((pg) => fetchPage(pg)),
        { concurrency: 5, mode: "either" }
      );
      const extraUsers = results.filter(Either_exports.isRight).flatMap((r) => {
        const users = r.right.user_list ?? [];
        for (const u of users) {
          if (typeof u.bazhu_grade === "string" || Array.isArray(u.bazhu_grade)) {
            u.bazhu_grade = void 0;
          }
        }
        return users;
      });
      firstRes.user_list = [...firstRes.user_list, ...extraUsers];
      return firstRes;
    });
  }
  function getFollow(id, page = 1) {
    const client = getClient();
    const fetchPage = (pg) => postFormData(
      "/c/u/follow/followList",
      client.packRequest({ uid: id.toString(), page: pg.toString() })
    );
    if (typeof page === "number") {
      return fetchPage(page);
    }
    return Effect_exports.gen(function* () {
      const from = page === "ALL" ? 1 : Math.max(1, page[0]);
      const requestedLastPage = page === "ALL" ? Number.POSITIVE_INFINITY : Math.max(from, page[1]);
      const firstRes = yield* fetchPage(from);
      const totalPage = Math.max(
        1,
        Math.ceil((firstRes.total_follow_num || 0) / 20)
      );
      const lastPage = page === "ALL" ? totalPage : Math.min(requestedLastPage, totalPage);
      if (page !== "ALL" && from > totalPage) {
        firstRes.follow_list = [];
        firstRes.has_more = 0;
        return firstRes;
      }
      if (from >= lastPage) return firstRes;
      const remaining = Array.from(
        { length: lastPage - from },
        (_, i) => from + 1 + i
      );
      const results = yield* Effect_exports.all(
        remaining.map((pg) => fetchPage(pg)),
        { concurrency: 5, mode: "either" }
      );
      const extraFollows = results.filter(Either_exports.isRight).flatMap((r) => r.right.follow_list ?? []);
      firstRes.follow_list = [...firstRes.follow_list, ...extraFollows];
      return firstRes;
    });
  }
  function getLikeForum(id, page = 1) {
    const client = getClient();
    return Effect_exports.gen(function* () {
      const params = {
        friend_uid: id.toString(),
        page_no: (typeof page === "number" ? page : 1).toString(),
        page_size: "400"
      };
      const res = yield* postFormData("/c/f/forum/like", client.packRequest(params));
      if (res?.forum_list?.gconforum) {
        return res.forum_list["non-gconforum"]?.concat(res.forum_list.gconforum);
      }
      return res?.forum_list ? res.forum_list["non-gconforum"] : [];
    });
  }
  function getHiddenLikeForum(id) {
    return Effect_exports.gen(function* () {
      const profile = yield* getProfile(id);
      const name = profile?.user?.name ?? "";
      const panel = yield* getPanel(name);
      const profileForums = (profile?.user?.likeForum ?? []).map(
        (f) => f.forumName
      );
      const gradeForums = Object.values(panel.honor?.grade ?? {}).flatMap(
        (v) => v.forum_list
      );
      return {
        grade: panel.honor?.grade ?? {},
        plain: profileForums.filter((name2) => !gradeForums.includes(name2))
      };
    });
  }
  var followUser = createFormApi({
    endpoint: "/c/c/user/follow",
    buildParams: (params) => ({
      portrait: params.portrait
    })
  });
  var unfollowUser = createFormApi({
    endpoint: "/c/c/user/unfollow",
    buildParams: (params) => ({
      portrait: params.portrait
    })
  });

  // src/shims/md5.ts
  var SHIFT = new Uint8Array([
    7,
    12,
    17,
    22,
    7,
    12,
    17,
    22,
    7,
    12,
    17,
    22,
    7,
    12,
    17,
    22,
    5,
    9,
    14,
    20,
    5,
    9,
    14,
    20,
    5,
    9,
    14,
    20,
    5,
    9,
    14,
    20,
    4,
    11,
    16,
    23,
    4,
    11,
    16,
    23,
    4,
    11,
    16,
    23,
    4,
    11,
    16,
    23,
    6,
    10,
    15,
    21,
    6,
    10,
    15,
    21,
    6,
    10,
    15,
    21,
    6,
    10,
    15,
    21
  ]);
  var TABLE = (() => {
    const table = new Uint32Array(64);
    for (let i = 0; i < 64; i++) {
      table[i] = Math.floor(Math.abs(Math.sin(i + 1)) * 4294967296);
    }
    return table;
  })();
  function md5Bytes(message) {
    const withPaddingStart = message.length + 1;
    const totalLength = withPaddingStart + 8 + 63 >> 6 << 6;
    const buffer = new Uint8Array(totalLength);
    buffer.set(message);
    buffer[message.length] = 128;
    const bitLength = message.length * 8;
    const view = new DataView(buffer.buffer);
    view.setUint32(totalLength - 8, bitLength >>> 0, true);
    view.setUint32(totalLength - 4, Math.floor(bitLength / 4294967296), true);
    let a0 = 1732584193;
    let b0 = 4023233417;
    let c0 = 2562383102;
    let d0 = 271733878;
    const chunk2 = new Uint32Array(16);
    for (let offset = 0; offset < totalLength; offset += 64) {
      for (let i = 0; i < 16; i++) {
        chunk2[i] = view.getUint32(offset + i * 4, true);
      }
      let a = a0;
      let b = b0;
      let c = c0;
      let d = d0;
      for (let i = 0; i < 64; i++) {
        let f;
        let g;
        if (i < 16) {
          f = b & c | ~b & d;
          g = i;
        } else if (i < 32) {
          f = d & b | ~d & c;
          g = (5 * i + 1) % 16;
        } else if (i < 48) {
          f = b ^ c ^ d;
          g = (3 * i + 5) % 16;
        } else {
          f = c ^ (b | ~d);
          g = 7 * i % 16;
        }
        const sum2 = f + a + TABLE[i] + chunk2[g] | 0;
        const rotate = SHIFT[i];
        a = d;
        d = c;
        c = b;
        b = b + (sum2 << rotate | sum2 >>> 32 - rotate) | 0;
      }
      a0 = a0 + a | 0;
      b0 = b0 + b | 0;
      c0 = c0 + c | 0;
      d0 = d0 + d | 0;
    }
    const digest = new Uint8Array(16);
    const digestView = new DataView(digest.buffer);
    digestView.setUint32(0, a0 >>> 0, true);
    digestView.setUint32(4, b0 >>> 0, true);
    digestView.setUint32(8, c0 >>> 0, true);
    digestView.setUint32(12, d0 >>> 0, true);
    return digest;
  }
  var HEX = "0123456789abcdef";
  function md5Hex(input) {
    const digest = md5Bytes(new TextEncoder().encode(input));
    let out = "";
    for (const byte of digest) {
      out += HEX[byte >> 4] + HEX[byte & 15];
    }
    return out;
  }
  function createHash(algorithm) {
    if (algorithm.toLowerCase() !== "md5") {
      throw new Error(`浏览器版 tieba.js 只支持 md5，收到：${algorithm}`);
    }
    let buffer = "";
    const hash2 = {
      update(data) {
        buffer += data;
        return hash2;
      },
      digest(encoding = "hex") {
        if (encoding !== "hex") {
          throw new Error(`浏览器版 tieba.js 只支持 hex 摘要，收到：${encoding}`);
        }
        return md5Hex(buffer);
      }
    };
    return hash2;
  }

  // <eztb>/packages/sdk/src/core/auth.ts
  function packRequest(data, bduss) {
    const params = new URLSearchParams(data);
    if (!params.has("BDUSS")) {
      params.append("BDUSS", bduss);
    }
    if (!params.has("_client_version")) {
      params.append("_client_version", "12.57.4.2");
    }
    if (!params.has("pn")) {
      params.append("pn", params.get("page") || "1");
    }
    params.delete("page");
    params.sort();
    const string2 = Array.from(params.entries()).map((entry) => entry.join("=")).join("");
    const sign = createHash("md5").update(`${string2}tiebaclient!!!`).digest("hex").toUpperCase();
    params.append("sign", sign);
    return Array.from(params.entries()).map((entry) => entry.join("=")).join("&");
  }

  // <eztb>/packages/sdk/src/client.ts
  var defaultOptions = {
    needPlainText: true,
    needTimestamp: false,
    timeFormat: new Intl.DateTimeFormat("zh-CN", {
      timeStyle: "short",
      dateStyle: "short"
    })
  };
  var TiebaClient = class {
    constructor(config) {
      __publicField(this, "bduss");
      __publicField(this, "options");
      __publicField(this, "_tbs");
      this.bduss = config.bduss;
      this.options = { ...defaultOptions, ...config.options };
    }
    /**
     * 获取 TBS 令牌（懒加载并缓存）。
     * 所有写操作都需要此令牌。
     */
    getTbs() {
      if (this._tbs) {
        return Effect_exports.succeed(this._tbs);
      }
      const self = this;
      return pipe(
        postFormData(
          "/c/s/login",
          self.packRequest({ bdusstoken: self.bduss })
        ),
        Effect_exports.map((res) => {
          if (Number(res.error_code) !== 0) {
            throw new TiebaServerError(
              Number(res.error_code),
              res.error_msg ?? ""
            );
          }
          const tbs = res.anti?.tbs ?? "";
          self._tbs = tbs;
          return tbs;
        })
      );
    }
    // --- 内部 HTTP 方法（供 API 模块使用） ---
    /** @internal */
    postProtobuf(url, buffer) {
      return postProtobuf(url, buffer);
    }
    /** @internal */
    postFormData(url, data) {
      return postFormData(url, data);
    }
    /** @internal */
    getData(url) {
      return getData(url);
    }
    /** @internal */
    packRequest(data) {
      return packRequest(data, this.bduss);
    }
  };

  // <eztb>/packages/sdk/src/helpers/user-id-resolver.ts
  var CACHE_TTL2 = Duration_exports.hours(24);

  // src/core/sdk.ts
  var initializedBduss = null;
  var BdussMissingError = class extends Error {
    constructor() {
      super("尚未设置 BDUSS，请先在脚本菜单里填写");
      this.name = "BdussMissingError";
    }
  };
  function ensureClient() {
    if (!hasBduss()) throw new BdussMissingError();
    const trimmed = getSettings().bduss.trim();
    if (trimmed === initializedBduss) return;
    initClient(new TiebaClient({ bduss: trimmed }));
    initializedBduss = trimmed;
  }
  function invalidateClient() {
    initializedBduss = null;
  }

  // src/core/identity.ts
  function hasEffect(value) {
    return typeof value === "object" && value !== null && typeof value.pipe === "function";
  }
  function callSdkLoose(factory) {
    ensureClient();
    return requestQueue.run(() => {
      const produced = factory();
      return hasEffect(produced) ? Effect_exports.runPromise(produced) : Promise.resolve(produced);
    });
  }
  function snapshotProfile(user, ref) {
    return {
      id: Number(user?.id ?? 0) || void 0,
      uid: user?.tiebaUid ? String(user.tiebaUid) : void 0,
      un: user?.name || void 0,
      nickname: user?.nameShow || ref.nickname || void 0,
      portrait: user?.portrait ? stripPortraitQuery(user.portrait) : ref.portrait ? stripPortraitQuery(ref.portrait) : void 0,
      level: toNumber(user?.levelId) || void 0,
      tbAge: user?.tbAge || void 0,
      postNum: toNumber(user?.postNum) || void 0,
      fansNum: toNumber(user?.fansNum) || void 0,
      concernNum: toNumber(user?.concernNum) || void 0,
      likeNum: toNumber(user?.myLikeNum) || void 0,
      intro: user?.intro || void 0,
      ip: user?.ipAddress || void 0,
      // profile 本身就带着关注贴吧名单：隐藏关注贴吧的用户只能从这里和 panel 恢复，
      // 顺手记进缓存，成分检测就不用再多发一次请求
      likeForum: (user?.likeForum ?? []).map((forum) => forum?.forumName).filter(Boolean),
      gender: toNumber(user?.sex) || toNumber(user?.gender) || void 0,
      isBawu: toNumber(user?.isBawu) === 1,
      bawuType: user?.bawuType || void 0,
      vipLevel: toNumber(user?.vipInfo?.vLevel) || void 0
    };
  }
  async function resolveIdentity(ref, force = false) {
    const key = profileCacheKey(ref);
    const cached4 = force ? null : readProfileCache(key);
    if (cached4?.id) {
      return {
        id: cached4.id,
        uid: cached4.uid,
        un: cached4.un,
        nickname: cached4.nickname,
        portrait: cached4.portrait,
        profile: cached4
      };
    }
    let raw = null;
    if (ref.userId) {
      raw = await callSdkLoose(() => getProfile(Number(ref.userId)));
    } else if (ref.portrait) {
      raw = await callSdkLoose(() => getProfile(stripPortraitQuery(ref.portrait)));
    } else if (ref.un) {
      const info = await callSdkLoose(() => getUserInfo(ref.un));
      if (info?.id) {
        raw = await callSdkLoose(() => getProfile(Number(info.id)));
      }
    }
    const user = raw?.user;
    if (!user?.id) {
      throw new Error("无法识别该用户（缺少贴吧号 / 用户 ID / 用户名）");
    }
    const snapshot = snapshotProfile(user, ref);
    writeProfileCache(key, snapshot);
    return {
      id: Number(user.id),
      uid: snapshot.uid,
      un: snapshot.un,
      nickname: snapshot.nickname,
      portrait: snapshot.portrait,
      profile: snapshot
    };
  }

  // src/core/userForums.ts
  var HIDDEN_FORUMS_NOTE = "该用户的关注贴吧未公开，以下数据从用户数据中还原，可能不完整。";
  var NO_USERNAME_NOTE = "注意：该用户没有设置用户名，「吧内等级」无法查询。";
  var NO_LEVEL_NOTE = "部分吧缺少等级信息。";
  async function loadUserForums(id, profileForums = []) {
    let items = [];
    let primaryFailed = false;
    try {
      const forums = await callSdkLoose(() => getLikeForum(id));
      items = (Array.isArray(forums) ? forums : []).map((forum) => ({
        name: forum.name,
        display: forum.name_show || forum.name,
        level: toNumber(forum.level_id) || void 0,
        levelName: forum.level_name || void 0,
        slogan: forum.slogan || void 0
      }));
    } catch {
      primaryFailed = true;
    }
    if (!items.length) {
      const hidden = await callSdkLoose(() => getHiddenLikeForum(id));
      const graded = Object.entries(
        hidden?.grade ?? {}
      ).flatMap(
        ([level, group]) => (group?.forum_list ?? []).map((name) => ({
          name,
          display: name,
          level: toNumber(level) || void 0
        }))
      );
      const recovered = mergeForums(graded, hidden?.plain ?? [], profileForums);
      return {
        forums: recovered,
        hidden: true,
        recovered: recovered.length
      };
    }
    const merged = mergeForums(items, [], profileForums);
    return {
      forums: merged,
      hidden: merged.length > items.length,
      recovered: merged.length - items.length
    };
  }
  function mergeForums(base, extraNames, profileNames) {
    const seen = new Set(base.map((item) => item.name));
    const out = [...base];
    for (const name of [...extraNames, ...profileNames]) {
      const clean = String(name ?? "").trim();
      if (!clean || seen.has(clean)) continue;
      seen.add(clean);
      out.push({ name: clean, display: clean });
    }
    return out;
  }

  // src/core/userPost.ts
  var ENDPOINT = "/c/u/feed/userpost?cmd=303002";
  var CLIENT_VERSION_OLD2 = "8.9.8.5";
  function buildRequest(uid, isThread, pn) {
    const message = UserPostReqIdl.fromPartial({
      data: {
        userId: String(uid),
        isThread,
        needContent: 1,
        pn,
        common: { ClientType: 2, ClientVersion: CLIENT_VERSION_OLD2 }
      }
    });
    return UserPostReqIdl.encode(message).finish();
  }
  async function fetchRaw(uid, isThread, pn) {
    ensureClient();
    return requestQueue.run(async () => {
      const client = getClient();
      const buffer = await Effect_exports.runPromise(
        client.postProtobuf(ENDPOINT, buildRequest(uid, isThread, pn))
      );
      const decoded = UserPostResIdl.decode(buffer);
      const errorno = decoded?.error?.errorno;
      if (errorno) {
        throw new TiebaServerError(errorno, decoded?.error?.errmsg ?? "");
      }
      return {
        postList: rememberForumNames(decoded?.data?.postList ?? []),
        hidden: toNumber(decoded?.data?.hidePost) > 0
      };
    });
  }
  function rememberForumNames(items) {
    for (const item of items) {
      const id = String(item?.forumId ?? "");
      const name = String(item?.forumName ?? "").trim();
      if (!id || id === "0" || !name) continue;
      const entry = forumNames.get(id);
      if (!entry || !entry.name) forumNames.set(id, { name, ts: Date.now() });
    }
    return items;
  }
  function textOf(contents) {
    if (!Array.isArray(contents)) return "";
    return contents.map((item) => item?.text ?? "").join("").replace(/\s+/g, " ").trim();
  }
  async function loadTopicPage(uid, page) {
    const raw = await fetchRaw(uid, 1, page);
    return {
      hidden: raw.hidden,
      rows: raw.postList.map((item) => ({
        kind: "topic",
        threadId: String(item.threadId ?? ""),
        postId: String(item.postId ?? ""),
        title: item.title || "",
        preview: textOf(item.firstPostContent),
        forumName: item.forumName || "",
        createTime: toNumber(item.createTime)
      }))
    };
  }
  async function loadReplyPage(uid, page) {
    const raw = await fetchRaw(uid, 0, page);
    const result = processUserPosts(raw.postList, false);
    const posts = await Effect_exports.runPromise(result);
    const names = await resolveForumNames(
      raw.postList.map((item) => String(item?.forumId ?? ""))
    );
    return {
      hidden: raw.hidden,
      rows: (posts ?? []).map((post) => ({
        kind: post.affiliated ? "sub" : "reply",
        threadId: String(post.threadId ?? ""),
        // 必须用**正文级**的 pid（cid），不能用 PostInfoList.postId：
        // 一条 feed 记录可以带多条正文（他在同一个帖子里连发几楼），
        // 记录级 pid 是这几行共用的，用它去查楼层会让同一帖的每一行都查回同一个楼层。
        // 实测（2026-09-27，uid 874540992）：一条记录含 3 条正文，
        // 记录级 pid 对应 112 楼，而第二、三条正文其实在 111 / 其它楼。
        postId: String(post.cid || post.postId || ""),
        title: post.title || post.content || "",
        preview: post.content || "",
        forumName: names.get(String(post.forumId ?? "")) || post.forumName || "",
        createTime: toNumber(post.createTime),
        replyTo: post.replyTo || void 0
      }))
    };
  }
  var forumNames = /* @__PURE__ */ new Map();
  var FORUM_NAME_CACHE_MAX = 500;
  var FORUM_NAME_EMPTY_TTL_MS = 5 * 60 * 1e3;
  function isFresh2(entry) {
    if (!entry) return false;
    if (entry.name) return true;
    return Date.now() - entry.ts < FORUM_NAME_EMPTY_TTL_MS;
  }
  var FORUM_NAME_CONCURRENCY = 3;
  var FORUM_NAME_MIN_GAP_MS = 150;
  var lastForumNameLookupAt = 0;
  async function waitForumNameSlot() {
    const configured = Number(getSettings().minIntervalMs);
    const gap = Math.max(
      FORUM_NAME_MIN_GAP_MS,
      Number.isFinite(configured) && configured > 0 ? Math.floor(configured / FORUM_NAME_CONCURRENCY) : FORUM_NAME_MIN_GAP_MS
    );
    const now = Date.now();
    const wait = Math.max(0, lastForumNameLookupAt + gap - now);
    lastForumNameLookupAt = Math.max(
      now,
      lastForumNameLookupAt + gap
    );
    if (wait > 0) await new Promise((resolve) => setTimeout(resolve, wait));
  }
  var forumNameInFlight = /* @__PURE__ */ new Map();
  async function lookupForumName(id) {
    const inFlight2 = forumNameInFlight.get(id);
    if (inFlight2) return inFlight2;
    ensureClient();
    const task = (async () => {
      try {
        return String(
          await Effect_exports.runPromise(getForumName(Number(id))) ?? ""
        ).trim();
      } catch {
        return "";
      }
    })();
    forumNameInFlight.set(id, task);
    try {
      return await task;
    } finally {
      forumNameInFlight.delete(id);
    }
  }
  async function resolveForumNames(ids3) {
    const wanted = Array.from(
      new Set(ids3.filter((id) => id && id !== "0"))
    ).filter((id) => !isFresh2(forumNames.get(id)));
    let cursor = 0;
    const worker = async () => {
      while (cursor < wanted.length) {
        const id = wanted[cursor];
        cursor += 1;
        if (isFresh2(forumNames.get(id))) continue;
        await waitForumNameSlot();
        if (isFresh2(forumNames.get(id))) continue;
        let name = "";
        for (let attempt = 0; attempt < 2 && !name; attempt += 1) {
          name = await lookupForumName(id);
        }
        forumNames.set(id, { name, ts: Date.now() });
      }
    };
    await Promise.all(
      Array.from(
        { length: Math.min(FORUM_NAME_CONCURRENCY, wanted.length) },
        worker
      )
    );
    if (forumNames.size > FORUM_NAME_CACHE_MAX) {
      const stale = Array.from(forumNames.entries()).sort((a, b) => a[1].ts - b[1].ts).slice(0, forumNames.size - FORUM_NAME_CACHE_MAX);
      for (const [key] of stale) forumNames.delete(key);
    }
    const out = /* @__PURE__ */ new Map();
    for (const id of ids3) {
      const entry = forumNames.get(id);
      if (entry) out.set(id, entry.name);
    }
    return out;
  }
  async function loadTopicRows(uid, page) {
    return (await loadTopicPage(uid, page)).rows;
  }
  async function loadReplyRows(uid, page) {
    return (await loadReplyPage(uid, page)).rows;
  }

  // src/core/errno.ts
  var KNOWN_ERRNO = {
    3e5: {
      hint: "贴吧这次没有把数据交出来；同一个请求重试有时能成功",
      observed: "HANDOFF §5 #18 / #26：实测出现在取某个用户的发帖记录时（同一 uid 有时正常、有时回 300000）"
    }
  };
  var UNKNOWN_MAX = 20;
  var unknownErrno = [];
  function recordUnknownErrno(code, msg, where) {
    const line = `${(/* @__PURE__ */ new Date()).toISOString()} ${where} → errno=${code}${msg ? ` errmsg=${JSON.stringify(msg)}` : ""}`;
    unknownErrno.push(line);
    if (unknownErrno.length > UNKNOWN_MAX) {
      unknownErrno.splice(0, unknownErrno.length - UNKNOWN_MAX);
    }
  }
  function recentUnknownErrno() {
    return unknownErrno.slice();
  }
  function formatServerError(code, msg) {
    const numeric = Number(code);
    const note = Number.isFinite(numeric) ? KNOWN_ERRNO[numeric] : void 0;
    const tail = msg && String(msg).trim() ? `：${String(msg).trim()}` : "（贴吧没有给出说明文字）";
    if (note) return `贴吧接口返回错误 ${code}${tail} —— ${note.hint}`;
    return `贴吧接口返回错误 ${code}${tail}（未收录的错误码，已记进诊断日志）`;
  }
  function asServerError(error) {
    if (!error || typeof error !== "object") return null;
    const code = error.code;
    if (typeof code !== "number" || !Number.isFinite(code)) return null;
    const msg = error.msg;
    return { code, msg: typeof msg === "string" ? msg : "" };
  }
  function describeRequestError(error, where = "请求") {
    const serverError = asServerError(error);
    if (serverError) {
      if (!(serverError.code in KNOWN_ERRNO)) {
        recordUnknownErrno(serverError.code, serverError.msg, where);
      }
      return formatServerError(serverError.code, serverError.msg);
    }
    const kind = error?.kind;
    if (kind === "timeout") {
      return "请求超时：贴吧接口 30 秒内没有回应（网络慢或被限流，稍后再试）";
    }
    if (kind === "network") {
      return "网络错误：连不上贴吧接口（检查网络或代理，必要时重新登录贴吧）";
    }
    if (kind === "abort") return "请求已取消";
    if (kind === "unavailable") {
      return error instanceof Error ? error.message : "当前环境不支持 GM_xmlhttpRequest，请检查脚本管理器";
    }
    if (error instanceof Error) return error.message;
    if (error === void 0 || error === null) return "未知错误";
    return String(error);
  }

  // src/core/compositionDetect.ts
  function normalizePages(value) {
    const num = Number(value);
    if (!Number.isFinite(num) || num < 1) return 1;
    return Math.min(Math.floor(num), 10);
  }
  async function detectComposition(target, rules, options = {}) {
    const pages = normalizePages(options.pages ?? 1);
    const stat = {
      forums: 0,
      forumsRecovered: 0,
      topics: 0,
      replies: 0,
      topicPages: 0,
      replyPages: 0,
      hidden: false,
      failed: [],
      verdict: { insufficient: false, note: "" }
    };
    const posts = [];
    let forums = [];
    const needForums = rules.some((rule) => rule.forumKeywords.length);
    const needPosts = rules.some(
      (rule) => rule.postKeywords.length || rule.postForumKeywords.length
    );
    if (needForums) {
      try {
        const loaded = await loadUserForums(
          target.id,
          target.profileForums ?? []
        );
        forums = loaded.forums.map((forum) => forum.name);
        stat.forums = forums.length;
        stat.forumsRecovered = loaded.recovered;
      } catch (error) {
        stat.failed.push(`关注的吧：${describeRequestError(error, "成分·关注的吧")}`);
      }
    }
    if (needPosts) {
      for (let page = 1; page <= pages; page += 1) {
        try {
          const result = await loadTopicPage(target.id, page);
          stat.topicPages = page;
          stat.topics += result.rows.length;
          stat.hidden = stat.hidden || result.hidden;
          for (const row of result.rows) {
            posts.push({
              title: row.title,
              preview: row.preview,
              kind: "topic",
              forumName: row.forumName,
              // 时间 / 帖子 id 一并带上：面板要按时间倒序，并跳到那条帖子
              createTime: row.createTime,
              threadId: row.threadId,
              postId: row.postId
            });
          }
          if (!result.rows.length) break;
        } catch (error) {
          stat.failed.push(`主题帖：${describeRequestError(error, "成分·主题帖")}`);
          break;
        }
      }
      for (let page = 1; page <= pages; page += 1) {
        try {
          const result = await loadReplyPage(target.id, page);
          stat.replyPages = page;
          stat.replies += result.rows.length;
          stat.hidden = stat.hidden || result.hidden;
          for (const row of result.rows) {
            posts.push({
              title: row.title,
              preview: row.preview,
              kind: row.kind === "sub" ? "sub" : "reply",
              forumName: row.forumName,
              createTime: row.createTime,
              threadId: row.threadId,
              postId: row.postId,
              replyTo: row.replyTo
            });
          }
          if (!result.rows.length) break;
        } catch (error) {
          stat.failed.push(`回复：${describeRequestError(error, "成分·回复")}`);
          break;
        }
      }
    }
    const hits = matchComposition(
      { uid: target.uid, userId: target.id, forums, posts },
      rules,
      // 匹配方式来自设置：不带 `=` 前缀的关键词按它走（单个词写成 `=xxx` 一定精确）
      { mode: getSettings().compositionKeywordMatch }
    );
    stat.verdict = compositionVerdict({
      hits: hits.length,
      failed: stat.failed,
      hidden: stat.hidden,
      needForums,
      needPosts,
      forums: stat.forums,
      posts: stat.topics + stat.replies
    });
    return { hits, stat };
  }

  // src/page/badges.ts
  var BADGES_CLASS = "tb-eztb-badges";
  var BADGE_CLASS = "tb-eztb-badge";
  var MAX_VISIBLE = 3;
  function availableSlack(button) {
    const row = button.closest(".head-line");
    if (!row) return Number.POSITIVE_INFINITY;
    const spacer = row.querySelector(".head-spacer");
    if (!spacer) return Number.POSITIVE_INFINITY;
    return spacer.getBoundingClientRect().width - 6;
  }
  var badgeRefs = /* @__PURE__ */ new WeakMap();
  function getBadgeRef(element) {
    return badgeRefs.get(element);
  }
  function makeBadge(hit, ref) {
    const badge = document.createElement("span");
    badge.className = `${BADGE_CLASS}${hit.sure ? "" : " tb-eztb-badge-unsure"}`;
    badge.textContent = hit.rule.name;
    badge.style.setProperty("--tb-eztb-badge-hue", String(badgeHue(hit.rule.name)));
    badge.title = hitsTooltip(hit);
    badge.tabIndex = 0;
    badge.setAttribute("role", "button");
    badgeRefs.set(badge, ref);
    return badge;
  }
  function hitsTooltip(hit) {
    return [
      `成分：${hit.rule.name}`,
      `标记原因：${hit.summary}`,
      hit.sure ? "" : "（证据较弱，可能是误判）",
      "点击查看详情"
    ].filter(Boolean).join("\n");
  }
  function clearBadges(button) {
    const next4 = button.nextElementSibling;
    if (next4?.classList?.contains(BADGES_CLASS)) next4.remove();
  }
  function renderBadges(button, hits, ref) {
    clearBadges(button);
    if (!hits.length || !button.isConnected) return;
    const container = document.createElement("span");
    container.className = BADGES_CLASS;
    container.dataset.count = String(hits.length);
    button.insertAdjacentElement("afterend", container);
    const budget = availableSlack(button);
    const fits = () => container.getBoundingClientRect().width <= budget;
    const tryAppend = (element) => {
      container.appendChild(element);
      if (fits()) return true;
      container.removeChild(element);
      return false;
    };
    const shown = [];
    for (const hit of hits.slice(0, MAX_VISIBLE)) {
      if (!tryAppend(makeBadge(hit, ref))) break;
      shown.push(hit);
    }
    while (shown.length < hits.length) {
      const more = document.createElement("span");
      more.className = `${BADGE_CLASS} tb-eztb-badge-more`;
      more.textContent = `+${hits.length - shown.length}`;
      more.title = hits.slice(shown.length).map((hit) => `${hit.rule.name}：${hit.summary}`).join("\n");
      more.tabIndex = 0;
      more.setAttribute("role", "button");
      badgeRefs.set(more, ref);
      if (tryAppend(more)) break;
      const last3 = shown.length ? container.lastElementChild : null;
      if (!last3) break;
      container.removeChild(last3);
      shown.pop();
    }
    if (!container.childElementCount) {
      const dot = document.createElement("span");
      dot.className = `${BADGE_CLASS} tb-eztb-badge-dot`;
      dot.textContent = "●";
      dot.style.setProperty(
        "--tb-eztb-badge-hue",
        String(badgeHue(hits[0].rule.name))
      );
      dot.title = hits.map(hitsTooltip).join("\n\n");
      dot.tabIndex = 0;
      dot.setAttribute("role", "button");
      badgeRefs.set(dot, ref);
      container.appendChild(dot);
    }
  }
  var INSUFFICIENT_TEXT = "证据不足";
  function renderInsufficientBadge(button, ref, note) {
    clearBadges(button);
    if (!button.isConnected) return;
    const container = document.createElement("span");
    container.className = BADGES_CLASS;
    container.dataset.count = "0";
    container.dataset.insufficient = "1";
    button.insertAdjacentElement("afterend", container);
    const tooltip = `${note}
（没有命中任何规则，但本次的数据不足以判定）
点击查看详情`;
    const badge = document.createElement("span");
    badge.className = `${BADGE_CLASS} tb-eztb-badge-insufficient`;
    badge.textContent = INSUFFICIENT_TEXT;
    badge.title = tooltip;
    badge.tabIndex = 0;
    badge.setAttribute("role", "button");
    badgeRefs.set(badge, ref);
    container.appendChild(badge);
    if (container.getBoundingClientRect().width > availableSlack(button)) {
      container.removeChild(badge);
      const dot = document.createElement("span");
      dot.className = `${BADGE_CLASS} tb-eztb-badge-dot tb-eztb-badge-insufficient`;
      dot.textContent = "●";
      dot.title = tooltip;
      dot.tabIndex = 0;
      dot.setAttribute("role", "button");
      badgeRefs.set(dot, ref);
      container.appendChild(dot);
    }
  }

  // src/features/compositionScan.ts
  var emptyStat = () => ({
    forums: 0,
    forumsRecovered: 0,
    topics: 0,
    replies: 0,
    topicPages: 0,
    replyPages: 0,
    hidden: false,
    failed: [],
    verdict: { insufficient: false, note: "" }
  });
  var buttonsByKey = /* @__PURE__ */ new Map();
  var refsByKey = /* @__PURE__ */ new Map();
  var checkedKeys = /* @__PURE__ */ new Set();
  var pending3 = /* @__PURE__ */ new Map();
  var draining = false;
  var noBdussWarned = false;
  function rulesText() {
    return getSettings().compositionRules;
  }
  function rulesHash() {
    return hashRules(rulesText());
  }
  function hasRules() {
    return parseRules(rulesText()).length > 0;
  }
  function maxPerPage() {
    const value = Number(getSettings().compositionMaxPerPage);
    return Number.isFinite(value) && value > 0 ? Math.floor(value) : 20;
  }
  function applyToButtons(key, hits, stat) {
    const ref = refsByKey.get(key);
    const buttons = buttonsByKey.get(key);
    if (!ref || !buttons) return;
    for (const button of buttons) {
      if (!button.isConnected) continue;
      if (hits.length) {
        renderBadges(button, hits, ref);
      } else if (stat?.verdict?.insufficient) {
        renderInsufficientBadge(button, ref, stat.verdict.note);
      } else {
        clearBadges(button);
      }
    }
  }
  async function checkUser(ref, options = {}) {
    const key = compositionCacheKey(ref);
    if (!hasRules()) {
      return { hits: [], stat: emptyStat(), fromCache: false, noRules: true };
    }
    if (!hasBduss()) {
      return { hits: [], stat: emptyStat(), fromCache: false, noBduss: true };
    }
    if (!options.force && key) {
      const cached4 = readCompositionCache(key, rulesHash());
      if (cached4) {
        applyToButtons(key, cached4.hits, cached4.stat);
        return { hits: cached4.hits, stat: cached4.stat, fromCache: true };
      }
    }
    const rules = parseRules(rulesText());
    const identity4 = await resolveIdentity(ref, options.force === true);
    const detection = await detectComposition(
      {
        id: identity4.id,
        uid: identity4.uid,
        // profile 里带着关注贴吧名单，交给检测去补齐 / 恢复隐藏的部分
        profileForums: identity4.profile?.likeForum ?? []
      },
      rules,
      { pages: getSettings().compositionPages }
    );
    if (key) {
      writeCompositionCache(key, {
        rulesHash: rulesHash(),
        hits: detection.hits,
        stat: detection.stat
      });
      checkedKeys.add(key);
      applyToButtons(key, detection.hits, detection.stat);
    }
    return { hits: detection.hits, stat: detection.stat, fromCache: false };
  }
  function enqueue(key, ref, force = false) {
    if (pending3.has(key) || checkedKeys.has(key)) return;
    if (checkedKeys.size + pending3.size >= maxPerPage()) return;
    refsByKey.set(key, ref);
    if (force) pending3.set(key, true);
    else if (!pending3.has(key)) pending3.set(key, false);
    void drain();
  }
  async function drain() {
    if (draining) return;
    draining = true;
    try {
      while (pending3.size) {
        const key = pending3.keys().next().value;
        const force = pending3.get(key) === true;
        pending3.delete(key);
        const ref = refsByKey.get(key);
        if (!ref) continue;
        if (checkedKeys.has(key)) continue;
        checkedKeys.add(key);
        try {
          await checkUser(ref, { force });
        } catch (error) {
          log.warn("成分检测失败：", error);
        }
      }
    } finally {
      draining = false;
    }
  }
  function registerUserForComposition(ref, button) {
    const key = compositionCacheKey(ref);
    if (!key) return;
    let buttons = buttonsByKey.get(key);
    if (!buttons) {
      buttons = /* @__PURE__ */ new Set();
      buttonsByKey.set(key, buttons);
    }
    buttons.add(button);
    if (!refsByKey.has(key)) refsByKey.set(key, ref);
    if (!hasRules()) return;
    if (!hasBduss()) {
      if (!noBdussWarned) {
        noBdussWarned = true;
        log.warn("还没设置 BDUSS，成分检测不会工作");
      }
      return;
    }
    const cached4 = readCompositionCache(key, rulesHash());
    if (cached4) {
      applyToButtons(key, cached4.hits);
      return;
    }
    enqueue(key, ref);
  }
  function rescanPage() {
    dropCompositionMemory();
    checkedKeys.clear();
    pending3.clear();
    for (const [key, ref] of refsByKey) {
      for (const button of buttonsByKey.get(key) ?? []) clearBadges(button);
      enqueue(key, ref, true);
    }
  }

  // src/core/bdussCheck.ts
  var BDUSS_PROBE_URL = "https://tieba.baidu.com/f/user/json_userinfo";
  var INVALID_PROBE = "eztb-invalid-probe";
  function pickAccountName(payload) {
    if (!payload || typeof payload !== "object") return void 0;
    const record = payload;
    const containers = [
      record,
      record.data,
      record.user,
      record.userinfo
    ];
    for (const container of containers) {
      if (!container || typeof container !== "object") continue;
      for (const key of ["user_name", "username", "name_show", "name"]) {
        const value = container[key];
        if (typeof value === "string" && value.trim()) return value.trim();
      }
    }
    return void 0;
  }
  async function whoAmI(bduss) {
    const response = await requestQueue.run(
      () => gmRequest({
        method: "GET",
        url: BDUSS_PROBE_URL,
        headers: {
          ...bduss ? { Cookie: `BDUSS=${bduss}` } : {},
          Referer: "https://tieba.baidu.com/"
        },
        responseType: "text",
        timeout: 15e3
      })
    );
    const raw = response.response;
    const text = (typeof raw === "string" ? raw : raw === void 0 || raw === null ? "" : String(raw)).trim();
    if (!text || text === "null") return { loggedIn: false };
    let parsed;
    try {
      parsed = JSON.parse(text);
    } catch {
      return { loggedIn: false };
    }
    if (!parsed || typeof parsed !== "object") return { loggedIn: false };
    return { loggedIn: true, account: pickAccountName(parsed) };
  }
  async function checkBduss(bduss) {
    const value = bduss.trim();
    const checkedAt = Date.now();
    if (!value) {
      return {
        status: "empty",
        message: "还没有填 BDUSS，先粘贴凭据再校验。",
        checkedAt
      };
    }
    let browser;
    let probe;
    try {
      browser = await whoAmI(null);
      probe = await whoAmI(INVALID_PROBE);
    } catch (error) {
      return {
        status: "error",
        message: `校验没能完成：${error instanceof Error ? error.message : String(error)}`,
        checkedAt
      };
    }
    const headerIgnored = probe.loggedIn;
    let real;
    try {
      real = await whoAmI(value);
    } catch (error) {
      return {
        status: "error",
        message: `校验没能完成：${error instanceof Error ? error.message : String(error)}`,
        checkedAt
      };
    }
    if (real.loggedIn && !headerIgnored) {
      return {
        status: "ok",
        account: real.account,
        message: `校验通过：这份 BDUSS 当前有效${real.account ? `（账号「${real.account}」）` : ""}。`,
        checkedAt
      };
    }
    if (headerIgnored) {
      const browserName = browser.account ? `「${browser.account}」` : "（没认出来是谁）";
      return {
        status: "unknown",
        account: browser.account,
        message: `无法确认你粘贴的这份 BDUSS：这个脚本管理器不接受脚本设置的 Cookie 头，请求用的是浏览器自己的登录状态（当前登录${browserName}）。请改用能直接查询的方式确认（比如随便点一个用户的「查询」，能出数据就说明凭据没问题）。`,
        checkedAt
      };
    }
    if (browser.loggedIn) {
      return {
        status: "invalid",
        message: "校验没通过：贴吧没有认下这份 BDUSS（无效或已过期）。请重新复制一次；注意别把前后的空格或不相关的 cookie 一起粘进来。",
        checkedAt
      };
    }
    return {
      status: "invalid",
      message: "校验没通过：这个端点没有把凭据认下来。可能是这份 BDUSS 无效/已过期，也可能是脚本管理器没有发送脚本设置的 Cookie 头、且浏览器当前未登录贴吧。两种情况下查询都会失败，建议先按 F12 → Application → Cookies 重新复制一份。",
      checkedAt
    };
  }

  // src/core/forumLevel.ts
  var CACHE_KEY3 = "tbEztbToolboxForumLevelV1";
  var CACHE_MAX3 = 500;
  var MAX_THREADS = 3;
  var cache4 = createKvCache({
    storageKey: CACHE_KEY3,
    max: CACHE_MAX3,
    validate: (entry) => entry.level > 0
  });
  var cacheKey = (targetId, forumName) => `${targetId}:${forumName}`;
  function readForumLevelCache(targetId, forumName) {
    const hit = cache4.read(cacheKey(targetId, forumName));
    return hit ? hit.level : null;
  }
  function writeForumLevelCache(targetId, forumName, level) {
    cache4.write(cacheKey(targetId, forumName), { level });
  }
  function clearForumLevelCache() {
    cache4.clear();
  }
  async function findThreads(targetId, forumName) {
    const candidates = [];
    const collect = (rows, via) => {
      for (const row of rows) {
        if (row.forumName !== forumName || !row.threadId) continue;
        if (candidates.some((item) => item.tid === row.threadId)) continue;
        candidates.push({ tid: row.threadId, via });
      }
    };
    try {
      collect(await loadTopicRows(targetId, 1), "topic");
    } catch {
    }
    if (!candidates.length) {
      try {
        collect(await loadReplyRows(targetId, 1), "reply");
      } catch {
      }
    }
    return candidates;
  }
  async function fetchUserForumLevel(targetId, forumName) {
    const cached4 = readForumLevelCache(targetId, forumName);
    if (cached4) return { level: cached4, via: "cache" };
    const candidates = await findThreads(targetId, forumName);
    if (!candidates.length) {
      return {
        reason: `最近一页帖子里没有他在「${forumName}」的帖子，读不到他在这个吧的等级`
      };
    }
    let lastError = "";
    for (const candidate of candidates.slice(0, MAX_THREADS)) {
      try {
        const page = await callSdkLoose(
          () => getPosts(Number(candidate.tid), 1, { rn: 30 })
        );
        const users = page?.userList ?? [];
        const me = users.find((user) => String(user?.id) === String(targetId));
        const level = toNumber(me?.levelId);
        if (level > 0) {
          writeForumLevelCache(targetId, forumName, level);
          return { level, via: candidate.via };
        }
      } catch (error) {
        lastError = describeRequestError(error, `查等级·${forumName}`);
      }
    }
    return {
      reason: lastError || `在他这几个帖子的第 1 页里没找到他的楼层（回复可能在后几页），读不到等级`
    };
  }

  // src/core/replyFloor.ts
  var CACHE_KEY4 = "tbEztbToolboxReplyFloorV1";
  var CACHE_MAX4 = 800;
  var cache5 = createKvCache({
    storageKey: CACHE_KEY4,
    max: CACHE_MAX4,
    validate: (entry) => entry.floor > 0
  });
  var cacheKey2 = (threadId, postId) => `${threadId}:${postId}`;
  function readReplyFloorCache(threadId, postId) {
    return cache5.read(cacheKey2(threadId, postId));
  }
  function writeReplyFloorCache(threadId, postId, floor, excerpt) {
    return cache5.write(cacheKey2(threadId, postId), { floor, excerpt });
  }
  function clearReplyFloorCache() {
    cache5.clear();
  }
  function contentText(contents) {
    if (!Array.isArray(contents)) return "";
    return contents.map((item) => item?.text ?? "").join("").replace(/\s+/g, " ").trim();
  }
  async function fetchReplyFloor(threadId, postId) {
    const tid = toNumber(threadId);
    const pid = toNumber(postId);
    if (!tid || !pid) {
      return { reason: "这条记录没有楼层可查（缺 threadId / postId）" };
    }
    const cached4 = readReplyFloorCache(threadId, postId);
    if (cached4) {
      return {
        floor: cached4.floor,
        excerpt: cached4.excerpt,
        via: "cache"
      };
    }
    try {
      const data = await callSdkLoose(
        () => getComments({ tid, pid, pn: 1 })
      );
      const floor = toNumber(data?.post?.floor);
      if (!(floor > 0)) {
        return {
          reason: "贴吧没有返回楼层号（这一楼可能已被删除）"
        };
      }
      const entry = writeReplyFloorCache(
        threadId,
        postId,
        floor,
        contentText(data?.post?.content)
      );
      return { floor: entry.floor, excerpt: entry.excerpt, via: "request" };
    } catch (error) {
      return { reason: describeRequestError(error, "查楼层") };
    }
  }

  // src/core/activityRule.ts
  var UNKNOWN_FORUM = "未知贴吧";
  function countPostsByForum(rows) {
    const out = {};
    for (const row of rows) {
      const name = String(row.forumName ?? "").trim() || UNKNOWN_FORUM;
      out[name] = (out[name] ?? 0) + 1;
    }
    return out;
  }
  function findSignInForums(forums, byForum, levelThreshold) {
    const threshold2 = Number.isFinite(levelThreshold) ? levelThreshold : 6;
    const out = [];
    for (const forum of forums) {
      const level = Number(forum.level ?? 0);
      if (!(level >= threshold2)) continue;
      const posts = Number(byForum[forum.name] ?? 0);
      if (posts > 0) continue;
      out.push({ forumName: forum.name, level, posts });
    }
    return out.sort((a, b) => b.level - a.level);
  }
  function signInSummary(candidates, levelThreshold, sample) {
    const sampleText = `样本：最近一页发帖（主题帖 ${sample.topics} 条 + 回复 ${sample.replies} 条）`;
    if (!candidates.length) {
      return `没有发现「等级 ≥ ${levelThreshold} 但最近没在该吧发言」的吧。判定条件：吧内等级 ≥ ${levelThreshold}，且最近这批帖子里在该吧 0 条发言。${sampleText}。`;
    }
    const names = candidates.slice(0, 5).map((item) => `${item.forumName}(Lv.${item.level})`).join("、");
    return `疑似只签到 ${candidates.length} 个吧：${names}${candidates.length > 5 ? " 等" : ""}。判定条件：吧内等级 ≥ ${levelThreshold}，且最近这批帖子里在该吧 0 条发言。${sampleText}——所以也可能是"以前发言多、最近没来"，请结合其它信息判断。`;
  }

  // src/core/forumActivity.ts
  var CACHE_KEY5 = "tbEztbToolboxForumActivityV1";
  var CACHE_MAX5 = 300;
  var TTL_MS = 24 * 60 * 60 * 1e3;
  var cache6 = createKvCache({
    storageKey: CACHE_KEY5,
    max: CACHE_MAX5,
    ttlMs: TTL_MS,
    // 对方的发帖记录被隐藏时活跃度无从判断，这种结果不算数
    validate: (entry) => !entry.hidden
  });
  function readForumActivityCache(uid) {
    return cache6.read(String(uid));
  }
  function writeForumActivityCache(uid, value) {
    cache6.write(String(uid), value);
  }
  function clearForumActivityCache() {
    cache6.clear();
  }
  async function loadForumActivity(uid, force = false) {
    if (!force) {
      const cached4 = readForumActivityCache(uid);
      if (cached4) return cached4;
    }
    const failed = [];
    const rows = [];
    let topics = 0;
    let replies = 0;
    let hidden = false;
    try {
      const page = await loadTopicPage(uid, 1);
      topics = page.rows.length;
      hidden = hidden || page.hidden;
      rows.push(...page.rows);
    } catch (error) {
      failed.push(`主题帖：${describeRequestError(error, "签到检测·主题帖")}`);
    }
    try {
      const page = await loadReplyPage(uid, 1);
      replies = page.rows.length;
      hidden = hidden || page.hidden;
      rows.push(...page.rows);
    } catch (error) {
      failed.push(`回复：${describeRequestError(error, "签到检测·回复")}`);
    }
    const value = {
      byForum: countPostsByForum(rows),
      topics,
      replies,
      hidden,
      failed,
      ts: Date.now()
    };
    if (!failed.length && !hidden) writeForumActivityCache(uid, value);
    return value;
  }

  // src/ui/modal.ts
  var FOCUSABLE_SELECTOR = 'button,[href],input,select,textarea,[tabindex]:not([tabindex="-1"])';
  var activeClose = null;
  function openDialog(options) {
    closeOpenDialog();
    const root = document.createElement("div");
    root.className = "tb-eztb-mask";
    const avatar = options.avatarUrl ? `<img class="tb-eztb-avatar" src="${escapeHtml(options.avatarUrl)}" alt="">` : "";
    const tabs = options.tabs?.length ? `<div class="tb-eztb-tabs">${options.tabs.map(
      (tab) => `<button class="tb-eztb-tab" data-tab="${escapeHtml(tab.id)}">${escapeHtml(tab.label)}</button>`
    ).join("")}</div>` : "";
    root.innerHTML = `<div class="tb-eztb-dialog" role="dialog" aria-modal="true" aria-label="${escapeHtml(options.title)}"><div class="tb-eztb-head">` + avatar + `<div class="tb-eztb-head-main"><div class="tb-eztb-title">${escapeHtml(options.title)}</div><div class="tb-eztb-sub">${options.subtitleHtml ?? ""}</div></div><button class="tb-eztb-close" title="关闭" aria-label="关闭">×</button></div>` + tabs + `<div class="tb-eztb-body"></div><div class="tb-eztb-foot">${options.footerHtml ?? ""}</div></div>`;
    document.body.appendChild(root);
    const dialogEl = root.querySelector(".tb-eztb-dialog");
    const body = root.querySelector(".tb-eztb-body");
    const footer = root.querySelector(".tb-eztb-foot");
    const titleEl = root.querySelector(".tb-eztb-title");
    const subEl = root.querySelector(".tb-eztb-sub");
    const previouslyFocused = document.activeElement instanceof HTMLElement ? document.activeElement : null;
    let disposed = false;
    const close2 = () => {
      if (disposed) return;
      disposed = true;
      if (activeClose === close2) activeClose = null;
      root.remove();
      document.removeEventListener("keydown", onKeydown, true);
      if (previouslyFocused?.isConnected) previouslyFocused.focus();
      try {
        options.onClose?.();
      } catch (error) {
        log.warn("弹窗关闭回调抛错：", error);
      }
    };
    const onKeydown = (event) => {
      if (event.key === "Escape") {
        event.stopPropagation();
        close2();
        return;
      }
      if (event.key !== "Tab") return;
      const items = Array.from(
        dialogEl.querySelectorAll(FOCUSABLE_SELECTOR)
      ).filter((el) => !el.hasAttribute("disabled") && el.offsetParent !== null);
      if (!items.length) return;
      const first2 = items[0];
      const last3 = items[items.length - 1];
      const current = document.activeElement instanceof HTMLElement ? document.activeElement : null;
      const inside = current !== null && items.includes(current);
      if (event.shiftKey) {
        if (!inside || current === first2) {
          event.preventDefault();
          last3.focus();
        }
        return;
      }
      if (!inside || current === last3) {
        event.preventDefault();
        first2.focus();
      }
    };
    document.addEventListener("keydown", onKeydown, true);
    activeClose = close2;
    dialogEl.tabIndex = -1;
    dialogEl.focus({ preventScroll: true });
    root.querySelector(".tb-eztb-close")?.addEventListener("click", () => close2());
    root.addEventListener("click", (event) => {
      if (event.target === root) close2();
    });
    const tabButtons = Array.from(
      root.querySelectorAll(".tb-eztb-tab")
    );
    const activateTab = (id) => {
      for (const button of tabButtons) {
        button.classList.toggle("active", button.dataset.tab === id);
      }
    };
    for (const button of tabButtons) {
      button.addEventListener("click", () => {
        const id = button.dataset.tab;
        if (!id) return;
        activateTab(id);
        options.onTab?.(id);
      });
    }
    if (options.activeTab) activateTab(options.activeTab);
    return {
      root,
      body,
      footer,
      close: close2,
      setTitle: (text) => {
        titleEl.textContent = text;
        dialogEl.setAttribute("aria-label", text);
      },
      setSubtitle: (html) => {
        subEl.innerHTML = html;
      },
      setAvatar: (url) => {
        const img = root.querySelector(".tb-eztb-avatar");
        if (img && url) img.src = url;
      },
      activateTab
    };
  }
  function closeOpenDialog() {
    activeClose?.();
    document.querySelector(".tb-eztb-mask")?.remove();
  }

  // src/features/settingsDialog.ts
  function openSettingsDialog(options = {}) {
    const current = getSettings();
    const dialog = openDialog({
      title: "eztb 工具箱设置",
      subtitleHtml: "数据直连贴吧接口，不经过任何第三方服务"
    });
    const parts2 = [];
    if (options.requireBduss) {
      parts2.push(
        `<div class="tb-eztb-warn">还没有填写 BDUSS，所有查询都会失败。请先按下面的说明获取并粘贴。</div>`
      );
    }
    parts2.push(
      `<div class="tb-eztb-warn"><b>安全提示：</b>BDUSS 等同于你账号的登录凭据，任何拿到它的人都能以你的身份操作。它只保存在本机浏览器里，不要发给别人。</div>`
    );
    parts2.push(`<div class="tb-eztb-form">`);
    parts2.push(`<div class="tb-eztb-field">`);
    parts2.push(`<label for="tb-eztb-bduss">BDUSS</label>`);
    parts2.push(
      `<textarea id="tb-eztb-bduss" class="tb-eztb-textarea" placeholder="粘贴以 BDUSS= 开头的内容，或只粘贴值本身">${escapeHtml(current.bduss)}</textarea>`
    );
    parts2.push(
      `<div class="tb-eztb-hint">自己动手复制的三步：① 在<b>已登录</b>的贴吧页面按 F12；② 打开 Application（Chrome/Edge）/ 存储（Firefox）→ Cookies → <code>tieba.baidu.com</code>；③ 找到名为 <code>BDUSS</code> 的那一行，复制它的 Value 粘到上面。整段 <code>BDUSS=xxxx;</code> 直接粘进来也可以，脚本会自己截取。</div>`
    );
    parts2.push(
      `<div class="tb-eztb-actions" style="justify-content:flex-start;margin-top:0;"><button data-act="check-bduss">校验 BDUSS</button></div>`
    );
    parts2.push(`<div class="tb-eztb-hint" id="tb-eztb-bduss-status"></div>`);
    parts2.push(`</div>`);
    parts2.push(`<div class="tb-eztb-field">`);
    parts2.push(`<label for="tb-eztb-help">辅助获取网址</label>`);
    parts2.push(
      `<input id="tb-eztb-help" class="tb-eztb-input" value="${escapeHtml(current.bdussHelpUrl)}">`
    );
    parts2.push(
      `<div class="tb-eztb-hint">会用浏览器打开该网址，方便你复制 BDUSS。注意：这类第三方网站可能记录你粘贴的凭据，请自行判断是否可信；用 F12 手动复制永远是更安全的方式。</div>`
    );
    parts2.push(`</div>`);
    parts2.push(`<div class="tb-eztb-field">`);
    parts2.push(`<label for="tb-eztb-interval">请求最小间隔（毫秒）</label>`);
    parts2.push(
      `<input id="tb-eztb-interval" class="tb-eztb-input" type="number" min="0" step="50" value="${current.minIntervalMs}">`
    );
    parts2.push(
      `<div class="tb-eztb-hint">所有贴吧接口请求都会被这个间隔串行排队，避免请求过密触发风控。建议不低于 300。<br>例外只有一个：帖子里「按吧反查吧名」那种几十字节的小请求——它最多 3 个并发、间隔取"这个值的三分之一"与 150ms 里的较大者（贴吧自己的 SDK 也是这么预热的）。不这样，进「发帖」页签后回复那一路要等好几秒，饼图会长时间只有主题帖的数据。</div>`
    );
    parts2.push(`</div>`);
    parts2.push(`<div class="tb-eztb-field">`);
    parts2.push(`<label for="tb-eztb-maxpages">单个列表最多加载页数</label>`);
    parts2.push(
      `<input id="tb-eztb-maxpages" class="tb-eztb-input" type="number" min="1" step="1" value="${current.maxPagesPerList}">`
    );
    parts2.push(
      `<div class="tb-eztb-hint">每页 20 条。也用作「共同关注」先读几页、以及「搜全部」的页数上限。</div>`
    );
    parts2.push(`</div>`);
    parts2.push(`<div class="tb-eztb-field">`);
    parts2.push(`<label for="tb-eztb-default-tab">打开面板时默认停在</label>`);
    parts2.push(`<select id="tb-eztb-default-tab" class="tb-eztb-input">`);
    for (const tab of PANEL_TABS) {
      parts2.push(
        `<option value="${tab.id}"${current.defaultTab === tab.id ? " selected" : ""}>${tab.label}</option>`
      );
    }
    parts2.push(`</select>`);
    parts2.push(
      `<div class="tb-eztb-hint">点用户名旁的「查询」时先显示哪个页签。页面上的「成分」标记仍然直接打开「成分」页签，不受这里影响。</div>`
    );
    parts2.push(`</div>`);
    parts2.push(`<div class="tb-eztb-field">`);
    parts2.push(`<label for="tb-eztb-remember-tab">记住上次看过的页签</label>`);
    parts2.push(`<select id="tb-eztb-remember-tab" class="tb-eztb-input">`);
    parts2.push(
      `<option value="1"${current.rememberLastTab ? " selected" : ""}>开启（覆盖上面的默认页签）</option>`
    );
    parts2.push(
      `<option value="0"${current.rememberLastTab ? "" : " selected"}>关闭</option>`
    );
    parts2.push(`</select>`);
    parts2.push(
      `<div class="tb-eztb-hint">开着时，下次打开面板会停在你上次实际看过的那个页签；关着就一直用上面的默认页签。</div>`
    );
    parts2.push(`</div>`);
    parts2.push(`<div class="tb-eztb-field">`);
    parts2.push(`<label for="tb-eztb-self">我自己的贴吧号（「共同关注」用）</label>`);
    parts2.push(
      `<input id="tb-eztb-self" class="tb-eztb-input" placeholder="贴吧号 / 用户名 / 主页链接，留空则不做共同关注比对" value="${escapeHtml(current.selfIdentity)}">`
    );
    parts2.push(
      `<div class="tb-eztb-hint">填上之后，「共同关注」页签会读一次<b>你自己</b>的关注列表，再和对方的求交集（全部只读，不会关注或取关任何人）。不填时那个页签只会提示你来这里填。<br>注意：这里要填自己的<b>贴吧号</b>（面板副标题里那个，例如 523640824）或用户名；填纯数字时脚本会先按贴吧号查你。</div>`
    );
    parts2.push(`</div>`);
    parts2.push(`<div class="tb-eztb-field">`);
    parts2.push(`<label for="tb-eztb-match">关键词匹配方式</label>`);
    parts2.push(`<select id="tb-eztb-match" class="tb-eztb-input">`);
    for (const option3 of KEYWORD_MATCH_MODES) {
      parts2.push(
        `<option value="${option3.id}"${current.compositionKeywordMatch === option3.id ? " selected" : ""}>${option3.label}</option>`
      );
    }
    parts2.push(`</select>`);
    parts2.push(
      `<div class="tb-eztb-hint"><b>包含匹配</b>：关键词出现在吧名 / 文本的任意位置就算命中。<b>完全匹配</b>：吧名要整个相等（<code>V</code> 命中「V吧」、不命中「zerosievert吧」），英文 / 数字词要独立成词（<code>V</code> 不命中 <code>zerosievert</code>）；纯中文关键词没有词边界，两种方式等价。<br>只想让个别短词精确时，别动这个开关，直接在规则里写 <code>=V</code>（单个词前面加 <code>=</code> 就一定是完全匹配）。</div>`
    );
    parts2.push(`</div>`);
    parts2.push(`<div class="tb-eztb-field">`);
    parts2.push(`<label for="tb-eztb-rules">成分关键词规则</label>`);
    parts2.push(
      `<textarea id="tb-eztb-rules" class="tb-eztb-textarea tb-eztb-textarea-tall" spellcheck="false" placeholder="${escapeHtml(RULE_FORMAT_HINT)}">${escapeHtml(current.compositionRules)}</textarea>`
    );
    parts2.push(
      `<div class="tb-eztb-hint">${escapeHtml(RULE_FORMAT_HINT)}<br>命中的用户会在用户名旁显示标记；点标记可以看命中了什么。格式说明见仓库的 <code>docs/rules.md</code>。</div>`
    );
    parts2.push(`<div class="tb-eztb-hint" id="tb-eztb-rules-issues"></div>`);
    parts2.push(`<div class="tb-eztb-actions" style="justify-content:flex-start;margin-top:0;">`);
    parts2.push(`<button data-act="rules-example">填入示例（二游大战）</button>`);
    parts2.push(`<button data-act="rules-clear">清空规则</button>`);
    parts2.push(`</div>`);
    parts2.push(`</div>`);
    parts2.push(`<div class="tb-eztb-field">`);
    parts2.push(`<label for="tb-eztb-composition-auto">页面自动检测</label>`);
    parts2.push(`<select id="tb-eztb-composition-auto" class="tb-eztb-input">`);
    parts2.push(`<option value="1"${current.compositionAuto ? " selected" : ""}>开启</option>`);
    parts2.push(`<option value="0"${current.compositionAuto ? "" : " selected"}>关闭</option>`);
    parts2.push(`</select>`);
    parts2.push(
      `<div class="tb-eztb-hint">开启后会在后台逐个检查页面上的用户（串行限速、同一用户只查一次）。规则表为空时不会发起任何请求。</div>`
    );
    parts2.push(`</div>`);
    parts2.push(`<div class="tb-eztb-field">`);
    parts2.push(`<label for="tb-eztb-maxcheck">每页最多检测人数</label>`);
    parts2.push(
      `<input id="tb-eztb-maxcheck" class="tb-eztb-input" type="number" min="1" max="200" step="1" value="${current.compositionMaxPerPage}">`
    );
    parts2.push(
      `<div class="tb-eztb-hint">每个用户最多 3 个请求（关注的吧 + 主题帖 + 回复）。默认 20 人 ≈ 60 个请求，仍然按上面的间隔一个一个发。</div>`
    );
    parts2.push(`</div>`);
    parts2.push(`<div class="tb-eztb-field">`);
    parts2.push(`<label for="tb-eztb-composition-pages">成分检测每路翻几页</label>`);
    parts2.push(
      `<input id="tb-eztb-composition-pages" class="tb-eztb-input" type="number" min="1" max="10" step="1" value="${current.compositionPages}">`
    );
    parts2.push(
      `<div class="tb-eztb-hint">只影响「成分」判定：主题帖与回复**各**按这个页数取数（每页 60 条），默认 1 页。调大会看到更早的帖子，代价是每个用户多 (页数−1)×2 个请求；某一页取到 0 条就会提前停下。</div>`
    );
    parts2.push(`</div>`);
    parts2.push(`<div class="tb-eztb-field">`);
    parts2.push(`<label for="tb-eztb-cachedays">成分缓存天数</label>`);
    parts2.push(
      `<input id="tb-eztb-cachedays" class="tb-eztb-input" type="number" min="1" max="365" step="1" value="${current.compositionCacheDays}">`
    );
    parts2.push(
      `<div class="tb-eztb-hint">同一个用户在这段时间内不再重复查询；改规则会让缓存自动失效。</div>`
    );
    parts2.push(`</div>`);
    parts2.push(`<div class="tb-eztb-field">`);
    parts2.push(`<label for="tb-eztb-signin-level">「疑似只签到」的等级门槛</label>`);
    parts2.push(
      `<input id="tb-eztb-signin-level" class="tb-eztb-input" type="number" min="1" max="18" step="1" value="${current.signInLevelThreshold}">`
    );
    parts2.push(
      `<div class="tb-eztb-hint">「关注的吧」里的「检测签到号」用它判定：吧内等级 ≥ 这个值，且最近一页发帖里在该吧 0 条发言，就标成疑似只签到。</div>`
    );
    parts2.push(`</div>`);
    parts2.push(`<div class="tb-eztb-field">`);
    parts2.push(`<label for="tb-eztb-io">设置导入 / 导出</label>`);
    parts2.push(
      `<textarea id="tb-eztb-io" class="tb-eztb-textarea" spellcheck="false" placeholder="点「导出到文本框」把当前设置写进这里；把别处的设置粘进来，再点「从文本框导入」"></textarea>`
    );
    parts2.push(
      `<div class="tb-eztb-hint">导出的内容<b>不包含 BDUSS</b>；导入时也<b>不会读取 BDUSS</b>，你自己的凭据不会被别人的文件覆盖。导入后立即生效，等于替你按了一次保存。</div>`
    );
    parts2.push(
      `<div class="tb-eztb-actions" style="justify-content:flex-start;margin-top:0;"><button data-act="export">导出到文本框</button><button data-act="io-copy">复制</button><button data-act="import">从文本框导入</button></div>`
    );
    parts2.push(`<div class="tb-eztb-hint" id="tb-eztb-io-status"></div>`);
    parts2.push(`</div>`);
    parts2.push(`<div class="tb-eztb-actions">`);
    parts2.push(`<button data-act="help">打开辅助获取网址</button>`);
    parts2.push(`<button data-act="clear">清空资料缓存</button>`);
    parts2.push(`<button data-act="clear-composition">清空成分缓存</button>`);
    parts2.push(`<button data-act="clear-forum-level">清空吧内等级缓存</button>`);
    parts2.push(`<button data-act="clear-reply-floor">清空楼层缓存</button>`);
    parts2.push(`<button data-act="clear-activity">清空签到检测缓存</button>`);
    parts2.push(`<button data-act="save" class="primary">保存</button>`);
    parts2.push(`</div>`);
    parts2.push(`</div>`);
    dialog.body.innerHTML = parts2.join("");
    const readForm = () => {
      const value = (id) => (dialog.body.querySelector(`#${id}`)?.value ?? "").trim();
      const rawValue = (id) => dialog.body.querySelector(`#${id}`)?.value ?? "";
      let bduss = value("tb-eztb-bduss");
      const matched = bduss.match(/BDUSS=([^;\s]+)/i);
      if (matched) bduss = matched[1];
      return {
        bduss,
        bdussHelpUrl: value("tb-eztb-help"),
        minIntervalMs: Number(value("tb-eztb-interval")),
        maxPagesPerList: Number(value("tb-eztb-maxpages")),
        compositionRules: rawValue("tb-eztb-rules").trim(),
        compositionAuto: value("tb-eztb-composition-auto") !== "0",
        compositionMaxPerPage: Number(value("tb-eztb-maxcheck")),
        compositionPages: Number(value("tb-eztb-composition-pages")),
        compositionKeywordMatch: value("tb-eztb-match") === "exact" ? "exact" : "contains",
        compositionCacheDays: Number(value("tb-eztb-cachedays")),
        signInLevelThreshold: Number(value("tb-eztb-signin-level")),
        defaultTab: normalizePanelTabId(value("tb-eztb-default-tab")),
        rememberLastTab: value("tb-eztb-remember-tab") === "1",
        selfIdentity: value("tb-eztb-self")
      };
    };
    const textarea = () => dialog.body.querySelector("#tb-eztb-rules");
    const issuesEl = () => dialog.body.querySelector("#tb-eztb-rules-issues");
    const refreshRuleIssues = () => {
      const el = issuesEl();
      if (!el) return;
      const box = textarea();
      const { rules, issues: issues2 } = parseRulesDetailed(box?.value ?? "");
      if (!issues2.length) {
        el.textContent = rules.length ? `已解析出 ${rules.length} 条规则，没有发现问题。` : "还没有可用的规则（规则表为空时不会发起任何检测请求）。";
        el.classList.remove("tb-eztb-warn");
        return;
      }
      const lines = issues2.map(
        (issue) => `第 ${issue.line} 行${issue.level === "error" ? "（错误）" : ""}：${issue.message}`
      );
      el.textContent = `已解析出 ${rules.length} 条规则，有 ${issues2.length} 处要留意：` + lines.join(" ");
      el.classList.add("tb-eztb-warn");
    };
    const ioBox = () => dialog.body.querySelector("#tb-eztb-io");
    const ioStatus = (text) => {
      const el = dialog.body.querySelector("#tb-eztb-io-status");
      if (el) el.textContent = text;
    };
    const fillForm = (settings) => {
      const set6 = (id, value) => {
        const el = dialog.body.querySelector(`#${id}`);
        if (el) el.value = value;
      };
      set6("tb-eztb-bduss", settings.bduss);
      set6("tb-eztb-help", settings.bdussHelpUrl);
      set6("tb-eztb-interval", String(settings.minIntervalMs));
      set6("tb-eztb-maxpages", String(settings.maxPagesPerList));
      set6("tb-eztb-rules", settings.compositionRules);
      set6("tb-eztb-composition-auto", settings.compositionAuto ? "1" : "0");
      set6("tb-eztb-maxcheck", String(settings.compositionMaxPerPage));
      set6("tb-eztb-composition-pages", String(settings.compositionPages));
      set6("tb-eztb-match", settings.compositionKeywordMatch);
      set6("tb-eztb-cachedays", String(settings.compositionCacheDays));
      set6("tb-eztb-signin-level", String(settings.signInLevelThreshold));
      set6("tb-eztb-default-tab", settings.defaultTab);
      set6("tb-eztb-remember-tab", settings.rememberLastTab ? "1" : "0");
      set6("tb-eztb-self", settings.selfIdentity);
      refreshRuleIssues();
    };
    dialog.body.querySelector('[data-act="export"]')?.addEventListener("click", () => {
      const box = ioBox();
      if (!box) return;
      box.value = exportSettingsJson();
      box.focus();
      box.select();
      ioStatus("已填入上面的文本框（不含 BDUSS），可以直接全选复制。");
    });
    dialog.body.querySelector('[data-act="io-copy"]')?.addEventListener("click", () => {
      const box = ioBox();
      if (!box) return;
      if (!box.value.trim()) {
        ioStatus("文本框是空的，先点「导出到文本框」。");
        return;
      }
      box.focus();
      box.select();
      void (async () => {
        try {
          await navigator.clipboard.writeText(box.value);
          ioStatus("已复制到剪贴板。");
        } catch {
          ioStatus("浏览器不允许直接写剪贴板，内容已选中，按 Ctrl+C 复制。");
        }
      })();
    });
    dialog.body.querySelector('[data-act="import"]')?.addEventListener("click", () => {
      const box = ioBox();
      if (!box) return;
      const result = importSettingsJson(box.value);
      if (!result.ok) {
        ioStatus(`导入失败：${result.reason}`);
        return;
      }
      fillForm(result.settings);
      requestQueue.setMinInterval(result.settings.minIntervalMs);
      invalidateClient();
      rescanPage();
      ioStatus("已导入并保存（BDUSS 未改动）。");
    });
    dialog.body.querySelector('[data-act="check-bduss"]')?.addEventListener("click", (event) => {
      const button = event.currentTarget;
      const status = dialog.body.querySelector(
        "#tb-eztb-bduss-status"
      );
      const value = readForm().bduss;
      button.disabled = true;
      button.textContent = "校验中…";
      if (status) status.textContent = "正在问贴吧「当前是谁」……";
      void checkBduss(value).then((result) => {
        if (status) {
          status.textContent = `${result.message}（校验时间：${new Date(result.checkedAt).toLocaleString()}）`;
        }
        if (result.status === "ok") invalidateClient();
      }).catch((error) => {
        if (status) {
          status.textContent = `校验没能完成：${error instanceof Error ? error.message : String(error)}`;
        }
      }).finally(() => {
        button.disabled = false;
        button.textContent = "校验 BDUSS";
      });
    });
    dialog.body.querySelector('[data-act="rules-example"]')?.addEventListener("click", () => {
      const el = textarea();
      if (el) el.value = EXAMPLE_RULES;
      refreshRuleIssues();
    });
    dialog.body.querySelector('[data-act="rules-clear"]')?.addEventListener("click", () => {
      const el = textarea();
      if (el) el.value = "";
      refreshRuleIssues();
    });
    textarea()?.addEventListener("input", refreshRuleIssues);
    refreshRuleIssues();
    dialog.body.querySelector('[data-act="help"]')?.addEventListener("click", () => {
      const url = readForm().bdussHelpUrl;
      if (url) window.open(url, "_blank", "noopener,noreferrer");
    });
    dialog.body.querySelector('[data-act="clear"]')?.addEventListener("click", () => {
      clearProfileCache();
      const button = dialog.body.querySelector(
        '[data-act="clear"]'
      );
      if (button) button.textContent = "已清空";
    });
    dialog.body.querySelector('[data-act="clear-composition"]')?.addEventListener("click", () => {
      clearCompositionCache();
      const button = dialog.body.querySelector(
        '[data-act="clear-composition"]'
      );
      if (button) button.textContent = "已清空";
    });
    dialog.body.querySelector('[data-act="clear-forum-level"]')?.addEventListener("click", () => {
      clearForumLevelCache();
      const button = dialog.body.querySelector(
        '[data-act="clear-forum-level"]'
      );
      if (button) button.textContent = "已清空";
    });
    dialog.body.querySelector('[data-act="clear-reply-floor"]')?.addEventListener("click", () => {
      clearReplyFloorCache();
      const button = dialog.body.querySelector(
        '[data-act="clear-reply-floor"]'
      );
      if (button) button.textContent = "已清空";
    });
    dialog.body.querySelector('[data-act="clear-activity"]')?.addEventListener("click", () => {
      clearForumActivityCache();
      const button = dialog.body.querySelector(
        '[data-act="clear-activity"]'
      );
      if (button) button.textContent = "已清空";
    });
    dialog.body.querySelector('[data-act="save"]')?.addEventListener("click", () => {
      invalidateClient();
      const next4 = updateSettings(readForm());
      requestQueue.setMinInterval(next4.minIntervalMs);
      dialog.close();
      rescanPage();
      options.onSaved?.();
    });
  }

  // src/core/version.ts
  var SCRIPT_VERSION = "1.11.0" ? "1.11.0" : "dev";

  // src/page/adapters.ts
  function parseDataField(el) {
    const raw = el?.getAttribute?.("data-field");
    if (!raw) return null;
    try {
      return JSON.parse(raw.replace(/'/g, '"'));
    } catch {
      return null;
    }
  }
  function portraitFromHref(href) {
    if (!href) return null;
    try {
      const url = new URL(href, location.href);
      const id = url.searchParams.get("id");
      return id ? stripPortraitQuery(id) : null;
    } catch {
      const matched = String(href).match(/[?&]id=([^&]+)/);
      return matched ? stripPortraitQuery(decodeURIComponent(matched[1])) : null;
    }
  }
  function processOldPostAuthor(nameEl, mount2) {
    const post = nameEl.closest(".l_post");
    const dName = nameEl.closest("li.d_name");
    const card = post?.querySelector(".j_user_card") ?? null;
    const postData = parseDataField(post);
    const nameData = parseDataField(nameEl);
    const dNameData = parseDataField(dName);
    const cardData = parseDataField(card);
    const img = nameEl.closest(".d_author")?.querySelector("img[username]") ?? null;
    const author = postData?.author ?? {};
    mount2(
      {
        userId: author.user_id ?? dNameData?.user_id ?? null,
        un: decodeUserName(author.user_name) || decodeUserName(nameData?.un) || decodeUserName(cardData?.un) || decodeUserName(img?.getAttribute("username")),
        portrait: stripPortraitQuery(author.portrait) || stripPortraitQuery(nameData?.id) || stripPortraitQuery(cardData?.id) || portraitFromHref(nameEl.getAttribute("href")) || "",
        nickname: cleanText(nameEl)
      },
      nameEl
    );
  }
  function processOldFrsAuthor(nameEl, mount2) {
    const holder = nameEl.closest("[data-field]");
    const data = parseDataField(holder);
    const author = data?.author ?? data?.author_user ?? {};
    mount2(
      {
        userId: author.user_id ?? data?.user_id ?? null,
        un: decodeUserName(author.user_name ?? author.name) || decodeUserName(data?.user_name ?? data?.author_name) || decodeUserName(nameEl.getAttribute("username")),
        portrait: stripPortraitQuery(author.portrait) || portraitFromHref(nameEl.getAttribute("href")) || "",
        nickname: cleanText(nameEl)
      },
      nameEl
    );
  }
  function processOldLzlAuthor(atEl, mount2) {
    const item = atEl.closest(".lzl_item, li[data-field]");
    const itemData = parseDataField(item);
    const author = itemData?.author ?? itemData?.user ?? {};
    mount2(
      {
        userId: author.user_id ?? null,
        un: decodeUserName(author.user_name) || decodeUserName(atEl.getAttribute("username")) || decodeUserName(parseDataField(atEl)?.un),
        portrait: stripPortraitQuery(author.portrait) || portraitFromHref(atEl.getAttribute("href")) || "",
        nickname: cleanText(atEl)
      },
      atEl
    );
  }
  function processNewHeadline(headline, mount2) {
    const link = headline.querySelector('a.name-info-link[href*="home/main?id="]') ?? headline.querySelector('a[href*="home/main?id="]');
    if (!link) return;
    const nameEl = headline.querySelector(".head-name") ?? link;
    const wrapper = headline.querySelector(".btn-wrapper") ?? headline;
    mount2(
      {
        userId: null,
        un: "",
        portrait: portraitFromHref(link.getAttribute("href")) ?? "",
        nickname: cleanText(nameEl)
      },
      nameEl,
      wrapper
    );
  }

  // src/page/scanner.ts
  var DONE_ATTR = "data-tb-eztb-toolbox-done";
  var LEGACY_BUTTON_CLASS = "tb-eztb-follow-btn";
  var legacyWarned = false;
  var BUTTON_CLASS = "tb-eztb-btn";
  var INJECTED_SELECTOR = `.${BUTTON_CLASS}, .tb-eztb-badges`;
  var TARGETS = [
    {
      selector: ".p_author_name",
      handler: processOldPostAuthor,
      label: "旧版楼层"
    },
    {
      selector: "a.frs-author-name",
      handler: processOldFrsAuthor,
      label: "旧版列表"
    },
    {
      selector: ".lzl_cnt > .at, .lzl_content_main > .at",
      handler: processOldLzlAuthor,
      label: "旧版楼中楼"
    },
    { selector: ".head-line", handler: processNewHeadline, label: "新版用户行" }
  ];
  function scan(root, mount2) {
    if (!root?.querySelectorAll) return;
    for (const target of TARGETS) {
      for (const el of Array.from(root.querySelectorAll(target.selector))) {
        if (el.getAttribute(DONE_ATTR)) continue;
        el.setAttribute(DONE_ATTR, "1");
        try {
          target.handler(el, mount2);
        } catch (error) {
          log.warn(`处理${target.label}失败：`, error);
        }
      }
    }
  }
  function healHeadline(node, mount2) {
    const headline = node.classList?.contains("head-line") ? node : node.closest?.(".head-line");
    if (!headline) return;
    if (!headline.getAttribute(DONE_ATTR)) return;
    if (headline.querySelector(`.${BUTTON_CLASS}`)) return;
    try {
      processNewHeadline(headline, mount2);
    } catch (error) {
      log.warn("补回按钮失败：", error);
    }
  }
  var pendingScan = false;
  var pendingNodes = /* @__PURE__ */ new Set();
  var pendingHeal = /* @__PURE__ */ new Set();
  var currentMount = null;
  var BATCH_MAX_ROOTS = 60;
  function scheduleFrame(task) {
    if (typeof requestAnimationFrame === "function") {
      requestAnimationFrame(() => task());
      return;
    }
    setTimeout(task, 16);
  }
  function enqueue2(node) {
    if (pendingNodes.has(node)) return;
    if (pendingNodes.size > BATCH_MAX_ROOTS) {
      pendingNodes.add(node);
      return;
    }
    for (const queued of pendingNodes) {
      if (queued.contains(node)) return;
      if (node.contains(queued)) pendingNodes.delete(queued);
    }
    pendingNodes.add(node);
  }
  function scanSelf(node, mount2) {
    if (node.hasAttribute?.(DONE_ATTR)) return;
    for (const target of TARGETS) {
      if (!node.matches?.(target.selector)) continue;
      node.setAttribute(DONE_ATTR, "1");
      try {
        target.handler(node, mount2);
      } catch (error) {
        log.warn(`处理${target.label}失败：`, error);
      }
      return;
    }
  }
  function flushPending() {
    pendingScan = false;
    const mount2 = currentMount;
    const nodes = Array.from(pendingNodes).slice(0, BATCH_MAX_ROOTS);
    const rest = Array.from(pendingNodes).slice(BATCH_MAX_ROOTS);
    pendingNodes.clear();
    const heads = Array.from(pendingHeal);
    pendingHeal.clear();
    if (!mount2) return;
    for (const node of rest) pendingNodes.add(node);
    for (const node of nodes) {
      if (!node.isConnected) continue;
      scanSelf(node, mount2);
      scan(node, mount2);
    }
    for (const node of heads) {
      if (node.isConnected) healHeadline(node, mount2);
    }
    if (pendingNodes.size) scheduleFlush();
  }
  function scheduleFlush() {
    if (pendingScan) return;
    pendingScan = true;
    scheduleFrame(flushPending);
  }
  function resetPageMarks(mount2) {
    for (const el of Array.from(document.querySelectorAll(INJECTED_SELECTOR))) {
      el.remove();
    }
    for (const el of Array.from(
      document.querySelectorAll(`[${DONE_ATTR}]`)
    )) {
      el.removeAttribute(DONE_ATTR);
    }
    pendingNodes.clear();
    pendingHeal.clear();
    scan(document, mount2);
  }
  var lastHref = "";
  function onSoftNavigation(mount2) {
    const href = location.href;
    if (href === lastHref) return;
    lastHref = href;
    try {
      resetPageMarks(mount2);
    } catch (error) {
      log.warn("软导航后重置页面标记失败：", error);
    }
  }
  function watchSoftNavigation(mount2) {
    lastHref = location.href;
    window.addEventListener("popstate", () => onSoftNavigation(mount2));
    window.addEventListener("hashchange", () => onSoftNavigation(mount2));
    for (const name of ["pushState", "replaceState"]) {
      const original = history[name];
      if (typeof original !== "function") continue;
      const wrapped = function(...args2) {
        const result = original.apply(this, args2);
        if (location.href !== lastHref) onSoftNavigation(mount2);
        return result;
      };
      try {
        history[name] = wrapped;
      } catch (error) {
        log.warn(`包装 history.${name} 失败（软导航后不会自动重置标记）：`, error);
      }
    }
  }
  function startScanner(mount2) {
    currentMount = mount2;
    scan(document, mount2);
    if (!legacyWarned && document.querySelector(`.${LEGACY_BUTTON_CLASS}`)) {
      legacyWarned = true;
      log.warn(
        "检测到旧版脚本（tieba-eztb-follow.user.js）的按钮仍在页面上。它会在每个用户名旁再插一个「查关注」按钮，且点击已失效；请在油猴里卸载它，避免重复与干扰。"
      );
    }
    watchSoftNavigation(mount2);
    if (!window.MutationObserver) return;
    const observer = new MutationObserver((mutations) => {
      for (const mutation of mutations) {
        for (const node of Array.from(mutation.addedNodes)) {
          if (node.nodeType === Node.ELEMENT_NODE) {
            enqueue2(node);
          }
        }
        const target = mutation.target;
        if (target && target.nodeType === Node.ELEMENT_NODE) {
          pendingHeal.add(target);
        }
      }
      if (pendingNodes.size || pendingHeal.size) scheduleFlush();
    });
    observer.observe(document.body ?? document.documentElement, {
      childList: true,
      subtree: true
    });
  }

  // src/features/diagnose.ts
  var SELECTORS = [
    ".l_post",
    ".p_author_name",
    ".d_author",
    ".lzl_cnt > .at",
    "a.frs-author-name",
    ".head-line",
    ".head-name",
    "a.name-info-link"
  ];
  function countOf(selector) {
    try {
      return document.querySelectorAll(selector).length;
    } catch {
      return -1;
    }
  }
  function userLinkClasses() {
    const tally = /* @__PURE__ */ new Map();
    for (const link of Array.from(
      document.querySelectorAll('a[href*="home/main?id="]')
    )) {
      const className = link.getAttribute("class") ?? "(无 class)";
      tally.set(className, (tally.get(className) ?? 0) + 1);
    }
    return Array.from(tally, ([className, count3]) => ({ className, count: count3 })).sort((a, b) => b.count - a.count).slice(0, 12);
  }
  function selfCheckLines() {
    const lines = [];
    const buttons = Array.from(
      document.querySelectorAll(`.${BUTTON_CLASS}`)
    ).slice(0, 3);
    if (!buttons.length) {
      lines.push("  （本页还没有注入按钮，跳过）");
      return lines;
    }
    const pointerOk = buttons.filter(
      (button) => getComputedStyle(button).pointerEvents === "auto"
    );
    lines.push(
      `  ${pointerOk.length === buttons.length ? "PASS" : "FAIL"} 按钮 pointer-events = auto —— ${pointerOk.length}/${buttons.length}` + (pointerOk.length === buttons.length ? "" : "（不成立就会「看得见、点不动」，坑 #1）")
    );
    const zOk = buttons.filter(
      (button) => getComputedStyle(button).zIndex === "5"
    );
    lines.push(
      `  ${zOk.length === buttons.length ? "PASS" : "FAIL"} 按钮 z-index = 5 —— ${zOk.length}/${buttons.length}` + (zOk.length === buttons.length ? "" : "（大于 5 会盖住本该在上面的页面弹层，坑 #3）")
    );
    const containers = Array.from(
      document.querySelectorAll(`.${BADGES_CLASS}`)
    ).slice(0, 3);
    if (!containers.length) {
      lines.push("  （本页没有成分徽章，跳过徽章相关的两条）");
      return lines;
    }
    const nowrapOk = containers.filter(
      (container) => getComputedStyle(container).whiteSpace.includes("nowrap")
    );
    lines.push(
      `  ${nowrapOk.length === containers.length ? "PASS" : "FAIL"} 徽章容器不折行（white-space: nowrap） —— ${nowrapOk.length}/${containers.length}` + (nowrapOk.length === containers.length ? "" : "（折行会压住下面的正文，坑 #14）")
    );
    const fitOk = containers.filter((container) => {
      const row = container.closest(".head-line");
      if (!row) return true;
      const rowBox = row.getBoundingClientRect();
      const box = container.getBoundingClientRect();
      return box.height <= rowBox.height + 1;
    });
    lines.push(
      `  ${fitOk.length === containers.length ? "PASS" : "FAIL"} 徽章待在头部行的高度内 —— ${fitOk.length}/${containers.length}`
    );
    return lines;
  }
  function breakerLines() {
    const snapshot = breakerSnapshot();
    if (!snapshot.open) {
      return [
        ` 正常（连续失败 ${snapshot.consecutiveFailures} 次；连续 ${snapshot.threshold} 次才熔断）`
      ];
    }
    return [
      ` 已暂停：连续失败 ${snapshot.consecutiveFailures} 次，约 ${Math.ceil(snapshot.remainingMs / 1e3)} 秒后自动恢复`,
      ` 期间被挡回去的请求：${snapshot.pausedRequests} 个`
    ];
  }
  function buildDiagnoseReport() {
    const lines = [
      `URL: ${location.href}`,
      `标题: ${document.title}`,
      // 用户报障时第一件要知道的事：他装的是哪一版
      `脚本版本: ${SCRIPT_VERSION}`,
      `脚本已运行: 是`,
      "",
      "扫描器选择器命中数：",
      ...SELECTORS.map((selector) => `  ${selector} = ${countOf(selector)}`),
      `  [本脚本已处理标记] = ${countOf("[data-tb-eztb-toolbox-done]")}`,
      `  [旧脚本遗留按钮] = ${countOf(".tb-eztb-follow-btn")}`,
      `  [已注入按钮] = ${countOf(`.${BUTTON_CLASS}`)}`,
      "",
      "关键约束自检（这几条不成立，界面上就会出现「点不动 / 压住正文」）：",
      ...selfCheckLines(),
      "",
      "页面上的用户主页链接（按 class 统计）：",
      ...userLinkClasses().map((item) => `  ${item.count} × ${item.className}`),
      "",
      `在飞请求: ${inFlightCount()}`,
      "请求熔断状态：",
      ...breakerLines(),
      "",
      "存储写入失败记录（空 = 一切正常）：",
      ...storageIssueLines(),
      "",
      "贴吧返回过但本脚本还没收录的错误码（报给开发者就能补进对照表）：",
      ...unknownErrnoLines(),
      "",
      "最近的日志（最多 20 条）：",
      ...recentLogs().slice(-20).map((line) => `  ${line}`),
      "",
      `UA: ${navigator.userAgent}`
    ];
    return lines.join("\n");
  }
  function unknownErrnoLines() {
    const unknown = recentUnknownErrno();
    if (!unknown.length) return ["  （无）"];
    return unknown.map((line) => `  ${line}`);
  }
  function storageIssueLines() {
    const issues2 = getStorageIssues();
    if (!issues2.length) return ["  （无）"];
    return issues2.map(
      (issue) => `  ${new Date(issue.at).toISOString()} ${issue.storageKey}: ${issue.message}`
    );
  }
  function openDiagnoseDialog() {
    const report = buildDiagnoseReport();
    const dialog = openDialog({
      title: "eztb 页面诊断",
      subtitleHtml: "把下面的内容整段复制发给开发者"
    });
    dialog.body.innerHTML = `<pre class="tb-eztb-report">${escapeHtml(report)}</pre><div class="tb-eztb-actions"><button data-act="copy" class="primary">复制报告</button><button data-act="abort">中断在飞请求</button><button data-act="reset-breaker">重置熔断</button></div>`;
    dialog.body.querySelector('[data-act="reset-breaker"]')?.addEventListener("click", (event) => {
      const button = event.currentTarget;
      const before2 = breakerSnapshot();
      resetBreaker();
      button.textContent = before2.open ? "已重置，可以继续查询" : "本来就没熔断";
    });
    dialog.body.querySelector('[data-act="abort"]')?.addEventListener("click", (event) => {
      const button = event.currentTarget;
      const count3 = abortAllInFlight();
      button.textContent = count3 > 0 ? `已中断 ${count3} 个` : "当前没有在飞请求";
    });
    dialog.body.querySelector('[data-act="copy"]')?.addEventListener("click", () => {
      const button = dialog.body.querySelector(
        '[data-act="copy"]'
      );
      navigator.clipboard?.writeText(report).then(() => {
        if (button) button.textContent = "已复制";
      }).catch(() => {
        if (button) button.textContent = "复制失败，请手动选中";
      });
    });
    console.log("[eztb] 页面诊断\n" + report);
  }

  // src/core/lastTab.ts
  var LAST_TAB_KEY = "tbEztbToolboxLastTabV1";
  function readLastTab() {
    try {
      const stored = GM_getValue(LAST_TAB_KEY, "");
      if (typeof stored !== "string" || !stored) return null;
      return normalizePanelTabId(stored);
    } catch {
      return null;
    }
  }
  function writeLastTab(id) {
    try {
      GM_setValue(LAST_TAB_KEY, id);
    } catch {
    }
  }

  // src/core/evidenceHtml.ts
  var KIND_LABEL = {
    topic: "主题",
    reply: "回复",
    sub: "楼中楼"
  };
  function evidenceLink(evidence) {
    const post = evidence.post;
    if (!post?.threadId) return null;
    const base = threadUrl(post.threadId);
    if (post.kind === "topic" || !post.postId) {
      return { href: base, label: "打开主题帖" };
    }
    return {
      href: `${base}?pid=${encodeURIComponent(post.postId)}`,
      label: "打开这一楼"
    };
  }
  function buildEvidenceHtml(evidence, options = {}) {
    const post = evidence.post;
    const parts2 = [];
    const kindTag = post ? `<span class="tb-eztb-tag tb-eztb-tag-${post.kind}">${KIND_LABEL[post.kind]}</span>` : "";
    const time = post?.createTime ? `<span class="tb-eztb-evidence-time">${escapeHtml(formatTimestamp(post.createTime))}</span>` : "";
    const replyTo = post?.kind === "sub" && post.replyTo ? `<span class="tb-eztb-evidence-replyto">回复 ${escapeHtml(post.replyTo)}</span>` : "";
    const forum = post?.forumName && post.kind !== "topic" ? `<span class="tb-eztb-evidence-forum">${escapeHtml(post.forumName)}</span>` : "";
    parts2.push(`<div class="tb-eztb-evidence">`);
    parts2.push(
      `<div class="tb-eztb-evidence-head">` + kindTag + `<span class="tb-eztb-evidence-reason">${escapeHtml(evidence.reason)}</span><span class="tb-eztb-evidence-keyword">${escapeHtml(evidence.keyword)}</span>` + time + forum + replyTo + `</div>`
    );
    if (evidence.excerpt) {
      parts2.push(
        `<div class="tb-eztb-evidence-text">${highlightKeywords(evidence.excerpt, [evidence.keyword])}</div>`
      );
    }
    const link = evidenceLink(evidence);
    if (link) {
      const floorSlot = renderFloorSlot(post, options);
      parts2.push(
        `<div class="tb-eztb-evidence-actions"><a class="tb-eztb-evidence-link" href="${escapeHtml(link.href)}" target="_blank" rel="noopener noreferrer">${link.label}</a>` + floorSlot + `</div>`
      );
    }
    parts2.push(`</div>`);
    return parts2.join("");
  }
  function renderFloorSlot(post, options) {
    if (!post || post.kind === "topic" || !post.postId || !post.threadId) return "";
    const known = options.floorFor?.({
      threadId: post.threadId,
      postId: post.postId
    });
    if (known && known > 0) {
      return `<span class="tb-eztb-floor">${known}楼</span>`;
    }
    return `<button type="button" class="tb-eztb-floorbtn" data-thread="${escapeHtml(post.threadId)}" data-post="${escapeHtml(post.postId)}" title="发帖记录里没有楼层号，点一下去这个帖子里查他在第几楼">查楼层</button>`;
  }

  // src/features/panel/composition.ts
  function bindFloorButtons(root) {
    for (const button of Array.from(
      root.querySelectorAll(".tb-eztb-floorbtn")
    )) {
      if (button.dataset.bound === "1") continue;
      button.dataset.bound = "1";
      button.addEventListener("click", (event) => {
        event.preventDefault();
        event.stopPropagation();
        if (button.disabled) return;
        const threadId = button.dataset.thread ?? "";
        const postId = button.dataset.post ?? "";
        if (!threadId || !postId) return;
        button.disabled = true;
        button.textContent = "查询中…";
        void (async () => {
          const result = await fetchReplyFloor(threadId, postId);
          if (result.floor) {
            const span2 = document.createElement("span");
            span2.className = "tb-eztb-floor";
            span2.textContent = `${result.floor}楼`;
            span2.title = result.excerpt ? `${result.floor} 楼的内容：${result.excerpt}` : `${result.floor} 楼`;
            button.replaceWith(span2);
            return;
          }
          button.disabled = false;
          button.textContent = "查不到";
          button.title = result.reason ?? "没查到";
        })();
      });
    }
  }
  function renderCompositionTab(body, ref, force = false) {
    body.innerHTML = `<div class="tb-eztb-loading"><div class="tb-eztb-spinner"></div>正在检测成分…</div>`;
    const actions = (html) => `<div class="tb-eztb-actions" style="justify-content:flex-start;margin-top:12px;">${html}</div>`;
    void (async () => {
      let result;
      try {
        result = await checkUser(ref, { force });
      } catch (error) {
        body.innerHTML = `<div class="tb-eztb-error">${escapeHtml(describeRequestError(error))}</div>` + actions(
          `<button type="button" data-act="recheck" class="primary">重试</button>`
        );
        bindRecheck();
        return;
      }
      if (result.noRules) {
        body.innerHTML = `<div class="tb-eztb-hint">还没有配置成分关键词规则，因此没有做任何检测（也没有发出请求）。</div>` + actions(
          `<button type="button" data-act="settings">去配置关键词</button>`
        );
        body.querySelector('[data-act="settings"]')?.addEventListener("click", () => openSettingsDialog());
        return;
      }
      if (result.noBduss) {
        body.innerHTML = `<div class="tb-eztb-warn">成分检测需要读取关注吧与发帖，请先设置 BDUSS。</div>` + actions(
          `<button type="button" data-act="settings" class="primary">去设置 BDUSS</button>`
        );
        body.querySelector('[data-act="settings"]')?.addEventListener(
          "click",
          () => openSettingsDialog({ requireBduss: true })
        );
        return;
      }
      const { hits, stat } = result;
      const statLine = `已检查：关注的吧 ${stat.forums} 个` + (stat.forumsRecovered ? `（其中 ${stat.forumsRecovered} 个来自隐藏关注贴吧的恢复）` : "") + ` · 主题帖 ${stat.topics} 条 · 回复 ${stat.replies} 条` + (result.fromCache ? "（来自缓存）" : "");
      const rules = parseRules(getSettings().compositionRules);
      const hitBlocks = hits.map((hit) => {
        const evidences = hit.evidences.map(
          (evidence) => buildEvidenceHtml(evidence, {
            floorFor: (target) => readReplyFloorCache(target.threadId, target.postId)?.floor ?? null
          })
        ).join("");
        const newest = newestEvidenceAt(hit);
        return `<div class="tb-eztb-hit"><div class="tb-eztb-hit-head"><span class="tb-eztb-badge" style="--tb-eztb-badge-hue:${badgeHue(hit.rule.name)}">${escapeHtml(hit.rule.name)}</span>` + (hit.sure ? "" : `<span class="tb-eztb-hit-unsure">证据较弱，可能是误判</span>`) + (newest ? `<span class="tb-eztb-hit-newest">最近依据 ${escapeHtml(formatTimestamp(newest))}</span>` : "") + `</div>` + evidences + `</div>`;
      }).join("");
      const body_ = (hits.length ? `<div class="tb-eztb-hint">命中 ${hits.length} 条规则（共配置 ${rules.length} 条）</div><div class="tb-eztb-hits">${hitBlocks}</div>` : `<div class="tb-eztb-empty">没有命中任何关键词：这个用户关注的吧与发帖里都没出现规则表中的词。</div>`) + `<div class="tb-eztb-hint" style="margin-top:12px;">${escapeHtml(statLine)}</div>` + (stat.failed.length ? `<div class="tb-eztb-warn">部分数据没取到：${escapeHtml(stat.failed.join("；"))}</div>` : "") + actions(
        `<button type="button" data-act="recheck">重新检测</button><button type="button" data-act="settings">关键词设置</button>`
      );
      body.innerHTML = body_;
      body.querySelector('[data-act="settings"]')?.addEventListener("click", () => openSettingsDialog());
      bindFloorButtons(body);
      bindRecheck();
      function bindRecheck() {
        body.querySelector('[data-act="recheck"]')?.addEventListener("click", () => renderCompositionTab(body, ref, true));
      }
    })();
  }

  // src/features/panel/pagedList.ts
  function mountPagedList(options) {
    const settings = getSettings();
    const maxPages = Math.max(1, settings.maxPagesPerList);
    options.body.innerHTML = `<div class="tb-eztb-notice"></div><div class="tb-eztb-list"></div><button class="tb-eztb-more" disabled>加载中…</button><div class="tb-eztb-hint"></div>`;
    const listEl = options.body.querySelector(".tb-eztb-list");
    const moreBtn = options.body.querySelector(".tb-eztb-more");
    const hintEl = options.body.querySelector(".tb-eztb-hint");
    const noticeEl = options.body.querySelector(".tb-eztb-notice");
    let page = 0;
    let loaded = 0;
    let totalPages = Number.POSITIVE_INFINITY;
    let loading = false;
    let exhaustedFlag = false;
    let cappedFlag = false;
    let hiddenFlag = false;
    let failedPageNum = null;
    const items = [];
    const refreshFooter = () => {
      const summary5 = options.summaryText?.(loaded, totalPages);
      const parts2 = [];
      if (summary5) parts2.push(summary5);
      if (loading) parts2.push("正在加载…");
      else if (moreBtn.disabled) parts2.push("已全部加载");
      hintEl.textContent = parts2.join(" · ");
    };
    const loadNext = async () => {
      if (loading) return;
      loading = true;
      moreBtn.disabled = true;
      moreBtn.textContent = "加载中…";
      refreshFooter();
      try {
        const result = await options.loadPage(page + 1);
        page += 1;
        failedPageNum = null;
        loaded += result.items.length;
        items.push(...result.items);
        if (result.totalPages && result.totalPages > 0) {
          totalPages = result.totalPages;
        }
        if (result.items.length) {
          listEl.insertAdjacentHTML(
            "beforeend",
            result.items.map(options.renderRow).join("")
          );
        }
        if (result.hidden) {
          hiddenFlag = true;
          noticeEl.innerHTML = `<div class="tb-eztb-warn">${escapeHtml(
            options.hiddenText ?? options.emptyText
          )}</div>`;
        }
        options.onPage?.(result);
        const noMoreData = result.items.length === 0 || page >= totalPages && Number.isFinite(totalPages);
        const hitCap = page >= maxPages;
        exhaustedFlag = noMoreData || hitCap;
        cappedFlag = hitCap && !noMoreData;
        if (!loaded && exhaustedFlag) {
          if (!result.hidden) {
            listEl.innerHTML = `<div class="tb-eztb-empty">${escapeHtml(options.emptyText)}</div>`;
          }
        }
        moreBtn.disabled = exhaustedFlag;
        moreBtn.textContent = exhaustedFlag ? "没有更多了" : "加载更多";
      } catch (error) {
        const message = describeRequestError(error);
        failedPageNum = page + 1;
        options.onError?.(error);
        listEl.insertAdjacentHTML(
          "beforeend",
          `<div class="tb-eztb-error">${escapeHtml(message)}</div>`
        );
        moreBtn.disabled = false;
        moreBtn.textContent = "重试";
      } finally {
        loading = false;
        refreshFooter();
      }
    };
    moreBtn.addEventListener("click", () => {
      void loadNext();
    });
    void loadNext();
    return {
      loadNext,
      rows: () => items.slice(),
      pages: () => page,
      exhausted: () => exhaustedFlag,
      capped: () => cappedFlag,
      hidden: () => hiddenFlag,
      failedPage: () => failedPageNum
    };
  }

  // src/features/panel/rows.ts
  function renderUserRow(user) {
    const display = user.name_show || user.name || "贴吧用户";
    const portrait = stripPortraitQuery(user.portrait);
    const href = portrait ? `https://tieba.baidu.com/home/main?id=${encodeURIComponent(portrait)}` : "";
    return `<a class="tb-eztb-row" ${href ? `href="${escapeHtml(href)}" target="_blank" rel="noopener noreferrer"` : ""}>` + (portrait ? `<img class="tb-eztb-row-avatar" src="${escapeHtml(portraitUrl(portrait))}" alt="">` : `<span class="tb-eztb-row-avatar"></span>`) + `<span class="tb-eztb-row-main"><span class="tb-eztb-row-title">${escapeHtml(display)}</span>` + (user.name ? `<span class="tb-eztb-row-sub">${escapeHtml(user.name)}</span>` : "") + `</span></a>`;
  }

  // src/features/panel/fans.ts
  function renderFansTab(body, identity4) {
    mountPagedList({
      body,
      emptyText: "该用户没有公开的粉丝",
      summaryText: (loaded, totalPages) => Number.isFinite(totalPages) ? `已加载 ${loaded} 位 / 共 ${totalPages} 页` : `已加载 ${loaded} 位`,
      loadPage: async (page) => {
        const res = await callSdkLoose(() => getFans(identity4.id, page));
        const items = Array.isArray(res?.user_list) ? res.user_list : [];
        const totalPages = toNumber(res?.page?.total_page);
        return { items, totalPages: totalPages || void 0 };
      },
      renderRow: renderUserRow
    });
  }

  // src/features/panel/forums.ts
  function applyForumActivity(body, items, activity, levelThreshold) {
    const activityEl = body.querySelector(".tb-eztb-activity");
    const parts2 = [];
    if (activity.hidden) {
      parts2.push(
        `<div class="tb-eztb-warn">该用户隐藏了发帖记录，读不到发帖样本，因此没法判断「等级与活跃度是否相符」。</div>`
      );
    } else {
      const candidates = findSignInForums(items, activity.byForum, levelThreshold);
      const candidateNames = new Set(candidates.map((item) => item.forumName));
      parts2.push(
        `<div class="tb-eztb-hint">${escapeHtml(
          signInSummary(candidates, levelThreshold, {
            topics: activity.topics,
            replies: activity.replies
          })
        )}</div>`
      );
      for (const row of Array.from(
        body.querySelectorAll(".tb-eztb-row[data-forum]")
      )) {
        const name = row.dataset.forum ?? "";
        const count3 = activity.byForum[name] ?? 0;
        const main = row.querySelector(".tb-eztb-row-main");
        if (main) {
          let sub = main.querySelector(".tb-eztb-row-sub");
          if (!sub) {
            sub = document.createElement("span");
            sub.className = "tb-eztb-row-sub";
            main.appendChild(sub);
          }
          if (sub.dataset.baseHtml === void 0) {
            sub.dataset.baseHtml = sub.innerHTML;
          }
          sub.innerHTML = sub.dataset.baseHtml + ` <span class="tb-eztb-row-extra">近期发言 ${count3} 条</span>`;
        }
        if (!candidateNames.has(name)) continue;
        const meta = row.querySelector(".tb-eztb-row-meta");
        if (!meta || meta.querySelector(".tb-eztb-signin")) continue;
        const level = items.find((item) => item.name === name)?.level;
        const mark = document.createElement("span");
        mark.className = "tb-eztb-signin";
        mark.textContent = "疑似只签到";
        mark.title = `吧内等级 Lv.${level}（≥ ${levelThreshold}），但最近一页发帖里在这个吧 0 条发言。可能是只签到不发言，也可能是最近没来。`;
        meta.prepend(mark);
      }
    }
    if (activity.failed.length) {
      parts2.push(
        `<div class="tb-eztb-warn">部分数据没取到：${escapeHtml(activity.failed.join("；"))}</div>`
      );
    }
    if (activityEl) activityEl.innerHTML = parts2.join("");
  }
  function renderFollowForumsTab(body, identity4) {
    body.innerHTML = `<div class="tb-eztb-loading"><div class="tb-eztb-spinner"></div>正在加载…</div>`;
    void (async () => {
      try {
        const { forums: items, hidden } = await loadUserForums(
          identity4.id,
          identity4.profile?.likeForum ?? []
        );
        if (!items.length) {
          body.innerHTML = `<div class="tb-eztb-empty">该用户没有公开的关注贴吧</div>`;
          return;
        }
        for (const item of items) {
          if (item.level) continue;
          const cached4 = readForumLevelCache(identity4.id, item.name);
          if (cached4) {
            item.level = cached4;
            item.levelFromPost = true;
          }
        }
        const withLevel = items.filter((item) => item.level).length;
        const missingLevel = items.length - withLevel;
        const notes = [
          hidden ? HIDDEN_FORUMS_NOTE : "",
          // 缺等级就说明一次：隐藏关注贴吧的用户同样会看到（F1 精简后不再重复这件事）
          missingLevel ? NO_LEVEL_NOTE : "",
          hidden && !identity4.profile?.un ? NO_USERNAME_NOTE : ""
        ].filter(Boolean);
        body.innerHTML = notes.map((note) => `<div class="tb-eztb-warn">${escapeHtml(note)}</div>`).join("") + `<div class="tb-eztb-hint">共 ${items.length} 个${withLevel ? ` · 其中 ${withLevel} 个有等级信息` : " · 都没有等级信息"}</div><div class="tb-eztb-actions" style="justify-content:flex-start;margin:8px 0;"><button type="button" class="tb-eztb-minibtn" data-act="activity">检测签到号</button><span class="tb-eztb-hint">等级高、最近又不在该吧发言的吧</span></div><div class="tb-eztb-activity"></div><div class="tb-eztb-list">` + items.map(
          (item) => [
            `<a class="tb-eztb-row" data-forum="${escapeHtml(item.name)}" href="${escapeHtml(forumUrl(item.name))}" target="_blank" rel="noopener noreferrer">`,
            `<span class="tb-eztb-row-main">`,
            `<span class="tb-eztb-row-title">${escapeHtml(item.display)}</span>`,
            item.slogan || item.levelName ? `<span class="tb-eztb-row-sub">${escapeHtml(item.slogan || item.levelName)}</span>` : "",
            `</span>`,
            item.level ? `<span class="tb-eztb-row-meta"${item.levelFromPost ? ' title="这个等级是从他在这吧的帖子里读到的"' : ""}>Lv.${item.level}</span>` : `<span class="tb-eztb-row-meta"><button type="button" class="tb-eztb-levelbtn" data-forum="${escapeHtml(item.name)}" title="面板与资料接口都拿不到这个吧的等级，点一下去他在该吧的帖子里找">查等级</button></span>`,
            `</a>`
          ].join("")
        ).join("") + `</div>`;
        const activityButton = body.querySelector(
          '[data-act="activity"]'
        );
        const activityEl = body.querySelector(".tb-eztb-activity");
        activityButton?.addEventListener("click", () => {
          if (activityButton.disabled) return;
          activityButton.disabled = true;
          const originalLabel = activityButton.textContent ?? "检测签到号";
          activityButton.textContent = "检测中…";
          if (activityEl) {
            activityEl.innerHTML = `<div class="tb-eztb-hint">正在读取他最近一页的发帖…</div>`;
          }
          void (async () => {
            try {
              const activity = await loadForumActivity(identity4.id);
              applyForumActivity(
                body,
                items,
                activity,
                getSettings().signInLevelThreshold
              );
              activityButton.textContent = "重新检测";
            } catch (error) {
              if (activityEl) {
                activityEl.innerHTML = `<div class="tb-eztb-error">${escapeHtml(describeRequestError(error))}</div>`;
              }
              activityButton.textContent = originalLabel;
            } finally {
              activityButton.disabled = false;
            }
          })();
        });
        for (const button of Array.from(
          body.querySelectorAll(".tb-eztb-levelbtn")
        )) {
          const forumName = button.dataset.forum ?? "";
          button.addEventListener("click", (event) => {
            event.preventDefault();
            event.stopPropagation();
            if (button.disabled || !forumName) return;
            button.disabled = true;
            button.textContent = "查询中…";
            void (async () => {
              try {
                const result = await fetchUserForumLevel(
                  identity4.id,
                  forumName
                );
                if (result.level) {
                  const meta = document.createElement("span");
                  meta.className = "tb-eztb-row-meta";
                  meta.textContent = `Lv.${result.level}`;
                  meta.title = `这个等级是从他${result.via === "reply" ? "回复过的帖子" : "在本吧的帖子"}里读到的`;
                  button.replaceWith(meta);
                  return;
                }
                button.textContent = "查不到";
                button.title = result.reason ?? "没查到";
                button.disabled = false;
              } catch (error) {
                button.textContent = "查询失败";
                button.title = describeRequestError(error);
                button.disabled = false;
              }
            })();
          });
        }
      } catch (error) {
        body.innerHTML = `<div class="tb-eztb-error">${escapeHtml(describeRequestError(error))}</div>`;
      }
    })();
  }

  // src/features/panel/follows.ts
  var FOLLOW_PAGE_SIZE = 20;
  function renderFollowUsersTab(body, identity4) {
    mountPagedList({
      body,
      emptyText: "该用户没有公开的关注的人",
      summaryText: (loaded, totalPages) => Number.isFinite(totalPages) ? `已加载 ${loaded} 人 / 共约 ${totalPages * FOLLOW_PAGE_SIZE} 人` : `已加载 ${loaded} 人`,
      loadPage: async (page) => {
        const res = await callSdkLoose(() => getFollow(identity4.id, page));
        const items = Array.isArray(res?.follow_list) ? res.follow_list : [];
        const total = toNumber(res?.total_follow_num);
        return {
          items,
          totalPages: total > 0 ? Math.ceil(total / FOLLOW_PAGE_SIZE) : void 0
        };
      },
      renderRow: renderUserRow
    });
  }

  // src/core/mutualFollows.ts
  function followKey(user) {
    if (!user) return "";
    if (user.id !== void 0 && user.id !== null && String(user.id)) {
      return `id:${String(user.id)}`;
    }
    const portrait = String(user.portrait ?? "").split("?")[0];
    if (portrait) return `portrait:${portrait}`;
    const name = String(user.name ?? user.name_show ?? "").trim();
    return name ? `name:${name}` : "";
  }
  function intersectFollows(mine, theirs) {
    const myKeys = /* @__PURE__ */ new Set();
    for (const user of mine) {
      const key = followKey(user);
      if (key) myKeys.add(key);
    }
    const common = [];
    const seen = /* @__PURE__ */ new Set();
    let byName = 0;
    for (const user of theirs) {
      const key = followKey(user);
      if (!key || !myKeys.has(key) || seen.has(key)) continue;
      seen.add(key);
      if (key.startsWith("name:")) byName += 1;
      common.push(user);
    }
    return { common, byName };
  }
  function buildMutualSummary(input) {
    const mineLabel = input.mineLabel ?? "我";
    const parts2 = [
      `共同关注 ${input.common} 人`,
      `${mineLabel}这边读了 ${input.mineRead} 人（${input.minePages} 页）`,
      `对方读了 ${input.theirsRead} 人（${input.theirsPages} 页）`
    ];
    if (input.byName) {
      parts2.push(`其中 ${input.byName} 个是按用户名比上的（可能有同名）`);
    }
    if (input.capped) {
      parts2.push("已到这边的页数上限，可能还有没比对到的");
    }
    return parts2.join(" · ");
  }

  // src/features/panel/mutual.ts
  var INITIAL_PAGES = 3;
  function parseSelfRef(raw) {
    const value = String(raw ?? "").trim();
    if (!value) return null;
    const fromUrl = value.match(/[?&]id=([^&\s]+)/);
    const body = fromUrl ? decodeURIComponent(fromUrl[1]) : value;
    if (/^\d+$/.test(body)) return { userId: Number(body) };
    if (body.startsWith("tb.") || body.includes(".")) return { portrait: body };
    return { un: body };
  }
  async function resolveSelfIdentity(ref) {
    if (typeof ref.userId === "number" && Number.isFinite(ref.userId)) {
      try {
        const byUid = await callSdkLoose(() => getUserByUid(ref.userId));
        const internalId = Number(byUid?.id ?? 0);
        if (internalId) {
          return {
            id: internalId,
            label: byUid?.nameShow || byUid?.name || String(ref.userId)
          };
        }
      } catch {
      }
    }
    const identity4 = await resolveIdentity(ref);
    return {
      id: identity4.id,
      label: identity4.nickname || identity4.un || "我"
    };
  }
  async function loadFollowPage(uid, page) {
    const res = await callSdkLoose(() => getFollow(uid, page));
    return Array.isArray(res?.follow_list) ? res.follow_list : [];
  }
  function renderMutualTab(body, identity4) {
    const settings = getSettings();
    const selfRef = parseSelfRef(settings.selfIdentity);
    if (!selfRef) {
      body.innerHTML = `<div class="tb-eztb-notice"><div class="tb-eztb-warn">要看「共同关注」，得先告诉脚本你自己是谁：在设置里填上你自己的<b>贴吧号</b>（或用户名 / 主页链接）。</div><div class="tb-eztb-hint">脚本会用这个身份读一次你自己的「关注的人」，再和对方的关注列表求交集。全部只读，不会关注或取关任何人。</div></div>`;
      return;
    }
    const maxPages = Math.max(
      INITIAL_PAGES,
      Math.min(Number(settings.maxPagesPerList) || INITIAL_PAGES, 50)
    );
    body.innerHTML = `<div class="tb-eztb-notice"></div><div class="tb-eztb-hint" data-role="mutual-summary">正在读双方的关注列表…</div><div class="tb-eztb-list"></div><button class="tb-eztb-more" data-role="mutual-more">再比一页</button><div class="tb-eztb-hint" data-role="mutual-foot"></div>`;
    const noticeEl = body.querySelector(".tb-eztb-notice");
    const summaryEl = body.querySelector('[data-role="mutual-summary"]');
    const listEl = body.querySelector(".tb-eztb-list");
    const moreBtn = body.querySelector('[data-role="mutual-more"]');
    const footEl = body.querySelector('[data-role="mutual-foot"]');
    let minePages = 0;
    let theirsPages = 0;
    let mine = [];
    let theirs = [];
    let capped = false;
    let loading = false;
    const loadOneMorePage = async () => {
      const wantMine = minePages < maxPages;
      const wantTheirs = theirsPages < maxPages;
      if (!wantMine && !wantTheirs) {
        capped = true;
        return false;
      }
      if (wantMine) {
        const rows = await loadFollowPage(selfUid, minePages + 1);
        minePages += 1;
        mine = mine.concat(rows);
        if (!rows.length) minePages = maxPages;
      }
      if (wantTheirs) {
        const rows = await loadFollowPage(identity4.id, theirsPages + 1);
        theirsPages += 1;
        theirs = theirs.concat(rows);
        if (!rows.length) theirsPages = maxPages;
      }
      return true;
    };
    const render2 = () => {
      const { common, byName } = intersectFollows(mine, theirs);
      summaryEl.textContent = buildMutualSummary({
        common: common.length,
        byName,
        mineRead: mine.length,
        minePages,
        theirsRead: theirs.length,
        theirsPages,
        capped,
        mineLabel: selfLabel
      });
      listEl.innerHTML = common.length ? common.map(renderUserRow).join("") : `<div class="tb-eztb-empty">在已经读到的这些页里没有共同关注</div>`;
      moreBtn.disabled = loading || minePages >= maxPages && theirsPages >= maxPages;
      moreBtn.textContent = loading ? "读取中…" : moreBtn.disabled ? "到页数上限了" : "再比一页";
    };
    let selfUid = null;
    let selfLabel = "我";
    const run3 = async () => {
      if (loading) return;
      loading = true;
      render2();
      try {
        await loadOneMorePage();
        noticeEl.innerHTML = "";
      } catch (error) {
        noticeEl.innerHTML = `<div class="tb-eztb-error">${escapeHtml(
          describeRequestError(error, "共同关注")
        )}</div>`;
      } finally {
        loading = false;
        render2();
      }
    };
    moreBtn.addEventListener("click", () => {
      void run3();
    });
    void (async () => {
      try {
        const self = await resolveSelfIdentity(selfRef);
        selfUid = self.id;
        selfLabel = self.label;
        footEl.textContent = `以「${selfLabel}」的身份比对（每页 20 人，最多 ${maxPages} 页）`;
        await run3();
      } catch (error) {
        noticeEl.innerHTML = `<div class="tb-eztb-error">认不出设置里的「我自己」：${escapeHtml(
          describeRequestError(error, "共同关注·我")
        )}</div>`;
        summaryEl.textContent = "";
        moreBtn.disabled = true;
      }
    })();
  }

  // src/core/postStats.ts
  function mergeForumCounts(a, b) {
    const out = { ...a };
    for (const [forum, count3] of Object.entries(b)) {
      out[forum] = (out[forum] ?? 0) + count3;
    }
    return out;
  }
  function totalForumCount(counts) {
    return Object.values(counts).reduce((sum2, value) => sum2 + value, 0);
  }
  function postRowSubParts(post) {
    const parts2 = [];
    if (post.forumName) {
      parts2.push(
        `<span class="tb-eztb-row-forum">${escapeHtml(post.forumName)}</span>`
      );
    }
    if (post.kind === "sub" && post.replyTo) {
      parts2.push(
        `<span class="tb-eztb-row-replyto">↩ ${escapeHtml(post.replyTo)}</span>`
      );
    }
    if (post.kind !== "topic" && post.preview) {
      parts2.push(escapeHtml(post.preview));
    }
    return parts2;
  }
  var PIE_COLORS = [
    "#1677ff",
    "#e8a33d",
    "#3fb950",
    "#a371f7",
    "#e5534b",
    "#1f9ea8"
  ];
  var PIE_OTHER_COLOR = "#b6bcc6";
  function buildForumStats(counts) {
    const total = totalForumCount(counts);
    if (!total) return [];
    return Object.entries(counts).filter(([, count3]) => count3 > 0).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([forum, count3]) => ({
      forum,
      count: count3,
      fraction: count3 / total,
      percentText: `${(count3 / total * 100).toFixed(1)}%`
    }));
  }
  function buildForumFilterOptionsHtml(counts, selected) {
    const options = buildForumStats(counts).map((stat) => {
      const value = escapeHtml(stat.forum);
      const isSelected = stat.forum === selected ? " selected" : "";
      return `<option value="${value}"${isSelected}>${value}（${stat.count}）</option>`;
    });
    return `<option value=""${selected ? "" : " selected"}>全部吧</option>` + options.join("");
  }
  function postMatchesQuery(post, query) {
    const needle = query.trim().toLowerCase();
    if (!needle) return true;
    return `${post.title ?? ""} ${post.preview ?? ""}`.toLowerCase().includes(needle);
  }
  function mergePostRows(topicRows, replyRows) {
    return [...topicRows, ...replyRows].sort((a, b) => b.createTime - a.createTime);
  }
  function buildPostFilterHint(input) {
    const forum = input.forum.trim();
    const query = input.query.trim();
    if (!forum && !query) return "";
    const label = forum && query ? `筛选「${forum}」+ 搜索「${query}」` : forum ? `筛选「${forum}」` : `搜索「${query}」`;
    const { topic, reply } = input.matched;
    if (topic + reply === 0) {
      return query ? `${label}：已加载的 ${input.loadedTotal} 条里没有命中` : `${label}：该用户在这个吧没有发帖或回复`;
    }
    return `${label}：主题帖 ${topic} 个 · 回复 ${reply} 条`;
  }
  function buildSearchAllSummary(input) {
    const query = input.query.trim();
    const loadedTotal = input.loaded.topic + input.loaded.reply;
    const matchedTotal = input.matched.topic + input.matched.reply;
    const scope3 = input.complete ? `已翻完主题帖 ${input.pages.topic} 页、回复 ${input.pages.reply} 页` : `翻到上限（每路最多 ${input.pageLimit} 页）时仍有更早的没加载，已翻主题帖 ${input.pages.topic} 页、回复 ${input.pages.reply} 页`;
    const hit = matchedTotal === 0 ? `没有命中` : `命中 ${matchedTotal} 条（主题帖 ${input.matched.topic} · 回复 ${input.matched.reply}）`;
    return `搜索「${query}」：${scope3}，共 ${loadedTotal} 条，${hit}。`;
  }
  function buildForumListHtml(counts, open) {
    const stats = buildForumStats(counts);
    if (stats.length < 2) return "";
    const total = totalForumCount(counts);
    const button = `<button type="button" class="tb-eztb-pielistbtn" data-act="pie-all">${open ? "收起" : `查看全部 ${stats.length} 个吧的占比`}</button>`;
    if (!open) return `<div class="tb-eztb-pielistwrap">${button}</div>`;
    const rows = stats.map(
      (stat) => `<div class="tb-eztb-pieitem" data-forum="${escapeHtml(stat.forum)}"><span class="tb-eztb-pieitem-name" title="${escapeHtml(stat.forum)}">${escapeHtml(stat.forum)}</span><span class="tb-eztb-pieitem-bar"><i style="width:${(stat.fraction * 100).toFixed(1)}%"></i></span><b class="tb-eztb-pieitem-count">${stat.count}</b><span class="tb-eztb-pieitem-percent">${stat.percentText}</span></div>`
    ).join("");
    return `<div class="tb-eztb-pielistwrap">${button}<div class="tb-eztb-pielist"><div class="tb-eztb-pielist-head">共 ${stats.length} 个吧 · ${total} 条发言</div>` + rows + `</div></div>`;
  }
  function buildPieNotes(states) {
    const loading = states.filter((state) => state.loading);
    const failed = states.filter((state) => !state.loading && state.error);
    const parts2 = [];
    if (loading.length) {
      const labels = loading.map((state) => `「${state.label}」`).join("、");
      parts2.push(
        `<div class="tb-eztb-pie-pending">${labels}的数据还在加载，下面的占比<b>还不完整</b>——到齐后会自动补上。</div>`
      );
    }
    for (const state of failed) {
      const reason = escapeHtml(state.error ?? "");
      if (!state.hasRows) {
        const page = state.failedPage ?? 1;
        parts2.push(
          `<div class="tb-eztb-warn">「${state.label}」的第 ${page} 页就没取到（饼图里缺这一路的条数）：${reason}</div>`
        );
        continue;
      }
      const detail = state.failedPage === void 0 ? "后续页没取到" : state.loadedPages ? `第 ${state.failedPage} 页没取到（前 ${state.loadedPages} 页已经计入饼图）` : `第 ${state.failedPage} 页没取到`;
      parts2.push(
        `<div class="tb-eztb-warn">「${state.label}」的${detail}（饼图只统计到已经加载出来的那部分）：${reason}</div>`
      );
    }
    return parts2.join("");
  }
  function buildForumSlices(counts, maxSlices = 5) {
    const total = totalForumCount(counts);
    if (!total) return [];
    const ranked = Object.entries(counts).filter(([, count3]) => count3 > 0).sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]));
    const head5 = ranked.slice(0, maxSlices);
    const rest = ranked.slice(maxSlices);
    const slices = head5.map(([forum, count3], index) => ({
      forum,
      label: forum,
      count: count3,
      color: PIE_COLORS[index % PIE_COLORS.length],
      fraction: count3 / total,
      percentText: `${(count3 / total * 100).toFixed(1)}%`
    }));
    if (rest.length) {
      const count3 = rest.reduce((sum2, [, value]) => sum2 + value, 0);
      slices.push({
        forum: null,
        label: `其它 ${rest.length} 个吧`,
        count: count3,
        color: PIE_OTHER_COLOR,
        fraction: count3 / total,
        percentText: `${(count3 / total * 100).toFixed(1)}%`
      });
    }
    return slices;
  }
  var RADIUS = 46;
  var STROKE = 18;
  var CIRCUMFERENCE = 2 * Math.PI * RADIUS;
  function buildForumPieSvg(counts, maxSlices = 5) {
    const slices = buildForumSlices(counts, maxSlices);
    const total = totalForumCount(counts);
    if (!total) {
      return `<figure class="tb-eztb-pie"><svg class="tb-eztb-pie-svg" viewBox="0 0 120 120" role="img" aria-label="暂无发帖数据"><circle class="tb-eztb-pie-track" cx="60" cy="60" r="${RADIUS}" fill="none" stroke-width="${STROKE}"></circle></svg><figcaption class="tb-eztb-pie-legend"><div class="tb-eztb-pie-empty">还没有加载到发帖记录</div></figcaption></figure>`;
    }
    let acc = 0;
    const arcs = slices.filter((slice) => slice.count > 0).map((slice) => {
      const length2 = slice.fraction * CIRCUMFERENCE;
      const gap = CIRCUMFERENCE - length2;
      const offset = -acc;
      acc += length2;
      return `<circle class="tb-eztb-pie-slice" cx="60" cy="60" r="${RADIUS}" fill="none" stroke="${slice.color}" stroke-width="${STROKE}" stroke-dasharray="${length2.toFixed(3)} ${gap.toFixed(3)}" stroke-dashoffset="${offset.toFixed(3)}" data-forum="${escapeHtml(slice.forum ?? "")}"><title>${escapeHtml(slice.label)} ${slice.count} 条（${slice.percentText}）</title></circle>`;
    }).join("");
    const legend = slices.map(
      (slice) => `<span class="tb-eztb-pie-item" data-forum="${escapeHtml(slice.forum ?? "")}"><i class="tb-eztb-pie-dot" style="background:${slice.color}"></i><span class="tb-eztb-pie-label" title="${escapeHtml(slice.label)}">${escapeHtml(slice.label)}</span><b class="tb-eztb-pie-count">${slice.count}</b><span class="tb-eztb-pie-percent">${slice.percentText}</span></span>`
    ).join("");
    return `<figure class="tb-eztb-pie"><svg class="tb-eztb-pie-svg" viewBox="0 0 120 120" role="img" aria-label="发帖都发在哪些吧"><g transform="rotate(-90 60 60)">${arcs}</g></svg><figcaption class="tb-eztb-pie-legend">${legend}<div class="tb-eztb-pie-total">已加载 ${total} 条 · ${Object.keys(counts).length} 个吧</div></figcaption></figure>`;
  }

  // src/features/panel/posts.ts
  var POST_KIND_LABEL = {
    topic: "主题",
    reply: "回复",
    sub: "楼中楼"
  };
  var HIDDEN_POSTS_NOTE = "发帖信息设为私密。";
  function renderFloorSlot2(post) {
    if (!post.postId) return "";
    const cached4 = readReplyFloorCache(post.threadId, post.postId);
    if (cached4) {
      return `<span class="tb-eztb-floor" title="${escapeHtml(
        cached4.excerpt ? `${cached4.floor} 楼的内容：${cached4.excerpt}` : `${cached4.floor} 楼`
      )}">${cached4.floor}楼</span>`;
    }
    return `<button type="button" class="tb-eztb-floorbtn" data-thread="${escapeHtml(post.threadId)}" data-post="${escapeHtml(post.postId)}" title="发帖列表里没有楼层号，点一下去这个帖子里查他在第几楼">查楼层</button>`;
  }
  function renderPostRow(post) {
    const isReply = post.kind !== "topic";
    const forum = String(post.forumName ?? "").trim() || UNKNOWN_FORUM;
    const searchText = `${post.title ?? ""} ${post.preview ?? ""}`.toLowerCase().replace(/\s+/g, " ").trim();
    const subParts = postRowSubParts(post);
    return (
      // data-time 是原始时间戳（合并视图按它倒序，测试也按它断言顺序）
      `<a class="tb-eztb-row" data-forum="${escapeHtml(forum)}" data-search="${escapeHtml(searchText)}" data-time="${post.createTime}" href="${escapeHtml(threadUrl(post.threadId))}" target="_blank" rel="noopener noreferrer"><span class="tb-eztb-row-main"><span class="tb-eztb-row-title"><span class="tb-eztb-tag tb-eztb-tag-${post.kind}">${POST_KIND_LABEL[post.kind]}</span>${escapeHtml(post.title || post.preview || "(无标题)")}</span>` + (subParts.length ? `<span class="tb-eztb-row-sub">${subParts.join(" ")}</span>` : `<span class="tb-eztb-row-sub">${escapeHtml(UNKNOWN_FORUM)}</span>`) + `</span><span class="tb-eztb-row-meta tb-eztb-row-meta-stack">` + (isReply ? renderFloorSlot2(post) : "") + `<span class="tb-eztb-row-time">${escapeHtml(formatTimestamp(post.createTime))}</span></span></a>`
    );
  }
  function bindFloorButtons2(root) {
    for (const button of Array.from(
      root.querySelectorAll(".tb-eztb-floorbtn")
    )) {
      if (button.dataset.bound === "1") continue;
      button.dataset.bound = "1";
      button.addEventListener("click", (event) => {
        event.preventDefault();
        event.stopPropagation();
        if (button.disabled) return;
        const threadId = button.dataset.thread ?? "";
        const postId = button.dataset.post ?? "";
        if (!threadId || !postId) return;
        button.disabled = true;
        button.textContent = "查询中…";
        void (async () => {
          const result = await fetchReplyFloor(threadId, postId);
          if (result.floor) {
            const span2 = document.createElement("span");
            span2.className = "tb-eztb-floor";
            span2.textContent = `${result.floor}楼`;
            span2.title = result.excerpt ? `${result.floor} 楼的内容：${result.excerpt}` : `${result.floor} 楼`;
            button.replaceWith(span2);
            return;
          }
          button.textContent = "查不到";
          button.title = result.reason ?? "没查到";
          button.disabled = false;
        })();
      });
    }
  }
  var POST_MODES = [
    {
      id: "split",
      label: "分开",
      title: "主题帖与回复各占一个列表，各自翻页"
    },
    {
      id: "merged",
      label: "合并",
      title: "主题帖与回复合成一个列表（按时间倒序，跨 feed 的顺序是近似的）"
    }
  ];
  var POST_SUBTABS = [
    {
      id: "topic",
      label: "主题帖",
      emptyText: "该用户没有公开的主题帖",
      summaryText: (loaded) => `已加载 ${loaded} 个主题帖`
    },
    {
      id: "reply",
      label: "回复",
      emptyText: "该用户没有公开的回复",
      summaryText: (loaded) => `已加载 ${loaded} 条回复`
    }
  ];
  function mountPostsSubList(pane, identity4, subTab, onRows, onError3) {
    const spec = POST_SUBTABS.find((item) => item.id === subTab);
    return mountPagedList({
      body: pane,
      emptyText: spec.emptyText,
      hiddenText: HIDDEN_POSTS_NOTE,
      summaryText: spec.summaryText,
      // 主题帖与回复是两个独立 feed，各自翻页，不再合并成一个列表：
      // 合并后两条 feed 的页码对不上，跨页的时间倒序只能近似。
      loadPage: async (page) => {
        const feed = subTab === "topic" ? await loadTopicPage(identity4.id, page) : await loadReplyPage(identity4.id, page);
        return { items: feed.rows, hidden: feed.hidden };
      },
      renderRow: renderPostRow,
      onError: (error) => onError3(describeRequestError(error)),
      onPage: (result) => {
        bindFloorButtons2(pane);
        onRows(result.items);
      }
    });
  }
  function renderPostsTab(body, identity4) {
    const active2 = body.dataset.subtab === "reply" ? "reply" : "topic";
    let mode = body.dataset.postmode === "merged" ? "merged" : "split";
    body.innerHTML = // 占比饼图：按"发帖都发在哪些吧"统计，随已加载的行更新
    `<div class="tb-eztb-piestat"></div><div class="tb-eztb-postbar"><div class="tb-eztb-postbar-row"><span class="tb-eztb-postbar-label">显示</span><span class="tb-eztb-modetabs" role="tablist">` + POST_MODES.map(
      (item) => `<button type="button" role="tab" class="tb-eztb-modetab${item.id === mode ? " active" : ""}" data-postmode="${item.id}" title="${item.title}">${item.label}</button>`
    ).join("") + `</span><span class="tb-eztb-postbar-label">只看</span><select class="tb-eztb-input tb-eztb-forumfilter" data-act="forum-filter"><option value="">全部吧</option></select><input type="search" class="tb-eztb-input tb-eztb-postsearch" data-act="post-search" placeholder="在发帖 / 回复里搜内容" value="${escapeHtml(body.dataset.query ?? "")}"><button type="button" class="tb-eztb-minibtn" data-act="search-all" title="把两路还没加载的页都取回来再给结论；页数上限是设置里的「单个列表最多加载页数」">搜全部</button><button type="button" class="tb-eztb-minibtn" data-role="search-stop" disabled title="停止继续翻页，保留已经取到的">停止</button></div><div class="tb-eztb-hint" data-role="filter-hint"></div></div><div class="tb-eztb-postview" data-mode="${mode}"><div class="tb-eztb-splitview"><div class="tb-eztb-subtabs" role="tablist">` + POST_SUBTABS.map(
      (item) => `<button type="button" role="tab" class="tb-eztb-subtab${item.id === active2 ? " active" : ""}" data-subtab="${item.id}">${item.label}</button>`
    ).join("") + `</div>` + POST_SUBTABS.map(
      (item) => `<div class="tb-eztb-subpane${item.id === active2 ? " active" : ""}" data-subpane="${item.id}"></div>`
    ).join("") + `</div><div class="tb-eztb-mergedview"><div class="tb-eztb-notice" data-role="merged-notice"></div><div class="tb-eztb-list" data-role="merged-list"></div><button class="tb-eztb-more" data-role="merged-more" disabled>加载中…</button><div class="tb-eztb-hint" data-role="merged-hint"></div></div></div>`;
    let counts = {};
    let listOpen = false;
    let forumFilter = "";
    const pending4 = new Set(POST_SUBTABS.map((item) => item.id));
    const loadedAny = /* @__PURE__ */ new Set();
    const failures2 = /* @__PURE__ */ new Map();
    const pieEl = body.querySelector(".tb-eztb-piestat");
    const filterSelect = body.querySelector(
      '[data-act="forum-filter"]'
    );
    const searchInput = body.querySelector(
      '[data-act="post-search"]'
    );
    const filterHintEl = body.querySelector(
      '[data-role="filter-hint"]'
    );
    const viewEl = body.querySelector(".tb-eztb-postview");
    const mergedListEl = body.querySelector(
      '[data-role="merged-list"]'
    );
    const mergedMoreBtn = body.querySelector(
      '[data-role="merged-more"]'
    );
    const mergedHintEl = body.querySelector(
      '[data-role="merged-hint"]'
    );
    const mergedNoticeEl = body.querySelector(
      '[data-role="merged-notice"]'
    );
    const searchAllBtn = body.querySelector(
      '[data-act="search-all"]'
    );
    const searchStopBtn = body.querySelector(
      '[data-role="search-stop"]'
    );
    const handles = /* @__PURE__ */ new Map();
    let searchQuery = body.dataset.query ?? "";
    let loadingAll = false;
    let stopLoadingAll = false;
    let searchAllResult = null;
    const pagesLoaded = (id) => handles.get(id)?.pages() ?? 0;
    const loadedRows = (id) => handles.get(id)?.rows() ?? [];
    const matchesForum = (forumName) => !forumFilter || (forumName.trim() || UNKNOWN_FORUM) === forumFilter;
    const matchesFilters = (post) => matchesForum(post.forumName) && postMatchesQuery(post, searchQuery);
    const rowMatchesFilters = (row) => {
      if (forumFilter && (row.dataset.forum ?? UNKNOWN_FORUM) !== forumFilter) {
        return false;
      }
      const needle = searchQuery.trim().toLowerCase();
      return !needle || (row.dataset.search ?? "").includes(needle);
    };
    const updateHint = () => {
      if (!filterHintEl) return;
      if (loadingAll) {
        filterHintEl.textContent = `正在翻页：主题帖 ${pagesLoaded("topic")} 页 / 回复 ${pagesLoaded("reply")} 页（已加载 ${loadedRows("topic").length + loadedRows("reply").length} 条）…点「停止」可以只保留已经取到的。`;
        return;
      }
      if (searchAllResult) {
        filterHintEl.textContent = buildSearchAllSummary(searchAllResult);
        return;
      }
      const matched = {
        topic: loadedRows("topic").filter(matchesFilters).length,
        reply: loadedRows("reply").filter(matchesFilters).length
      };
      filterHintEl.textContent = buildPostFilterHint({
        forum: forumFilter,
        query: searchQuery,
        matched,
        loadedTotal: loadedRows("topic").length + loadedRows("reply").length
      });
    };
    const summarizeSearchAll = () => {
      searchAllResult = {
        query: searchQuery,
        pages: { topic: pagesLoaded("topic"), reply: pagesLoaded("reply") },
        loaded: {
          topic: loadedRows("topic").length,
          reply: loadedRows("reply").length
        },
        matched: {
          topic: loadedRows("topic").filter(matchesFilters).length,
          reply: loadedRows("reply").filter(matchesFilters).length
        },
        // 只有"真的没有更多数据"才算翻完；到页数上限停的要说清可能还有更早的
        complete: POST_SUBTABS.every((item) => {
          const handle = handles.get(item.id);
          return !handle || handle.exhausted() && !handle.capped();
        }),
        pageLimit: getSettings().maxPagesPerList
      };
    };
    const loadAllPages = async () => {
      if (loadingAll) return;
      loadingAll = true;
      stopLoadingAll = false;
      searchAllResult = null;
      if (searchStopBtn) searchStopBtn.disabled = false;
      if (searchAllBtn) searchAllBtn.disabled = true;
      updateHint();
      try {
        await Promise.all(
          POST_SUBTABS.map(async (item) => {
            const handle = handles.get(item.id);
            if (!handle) return;
            while (!stopLoadingAll && !handle.exhausted()) {
              const before2 = handle.rows().length;
              await handle.loadNext();
              updateHint();
              if (handle.rows().length === before2 && !handle.exhausted()) break;
            }
          })
        );
      } finally {
        loadingAll = false;
        if (searchStopBtn) searchStopBtn.disabled = true;
        if (searchAllBtn) searchAllBtn.disabled = false;
        summarizeSearchAll();
        applyFilters();
      }
    };
    const renderMerged = () => {
      if (!mergedListEl) return;
      const topicLoaded = loadedRows("topic");
      const replyLoaded = loadedRows("reply");
      const loadedTotal = topicLoaded.length + replyLoaded.length;
      const rows = mergePostRows(topicLoaded, replyLoaded).filter(matchesFilters);
      mergedListEl.innerHTML = rows.length ? rows.map(renderPostRow).join("") : `<div class="tb-eztb-empty">${escapeHtml(
        loadedTotal ? "没有符合筛选条件的发帖或回复" : "还没有加载到发帖或回复"
      )}</div>`;
      if (mergedNoticeEl) {
        const hiddenAll = POST_SUBTABS.every(
          (item) => handles.get(item.id)?.hidden()
        );
        mergedNoticeEl.innerHTML = hiddenAll && !loadedTotal ? `<div class="tb-eztb-warn">${escapeHtml(HIDDEN_POSTS_NOTE)}</div>` : "";
      }
      bindFloorButtons2(mergedListEl);
      const loading = POST_SUBTABS.some((item) => pending4.has(item.id));
      const done7 = POST_SUBTABS.every((item) => handles.get(item.id)?.exhausted());
      const failed = POST_SUBTABS.map((item) => failures2.get(item.id)).filter(
        (message) => !!message
      );
      if (mergedHintEl) {
        mergedHintEl.textContent = [
          `已加载 ${topicLoaded.length} 个主题帖 + ${replyLoaded.length} 条回复`,
          rows.length !== loadedTotal ? `当前显示 ${rows.length} 条` : "",
          loading ? "还有数据在加载…" : "",
          done7 && failed.length ? `部分数据没取到：${failed.join("；")}` : ""
        ].filter(Boolean).join(" · ");
      }
      if (mergedMoreBtn) {
        mergedMoreBtn.disabled = loading || done7;
        mergedMoreBtn.textContent = loading ? "加载中…" : done7 ? "没有更多了" : "加载更多";
      }
    };
    const applyFilters = () => {
      for (const item of POST_SUBTABS) {
        for (const row of body.querySelectorAll(
          `.tb-eztb-subpane[data-subpane="${item.id}"] .tb-eztb-row`
        )) {
          row.classList.toggle("tb-eztb-filtered-out", !rowMatchesFilters(row));
        }
      }
      renderMerged();
      updateHint();
    };
    const refreshForumFilter = () => {
      if (!filterSelect) return;
      const html = buildForumFilterOptionsHtml(counts, forumFilter);
      if (filterSelect.dataset.options === html) return;
      filterSelect.dataset.options = html;
      filterSelect.innerHTML = html;
      if (!Array.from(filterSelect.options).some(
        (option3) => option3.value === forumFilter
      )) {
        forumFilter = "";
      }
      filterSelect.value = forumFilter;
    };
    filterSelect?.addEventListener("change", () => {
      forumFilter = filterSelect.value;
      searchAllResult = null;
      applyFilters();
    });
    searchInput?.addEventListener("input", () => {
      searchQuery = searchInput.value;
      body.dataset.query = searchQuery;
      searchAllResult = null;
      applyFilters();
    });
    searchInput?.addEventListener("keydown", (event) => {
      if (event.key !== "Enter") return;
      event.preventDefault();
      void loadAllPages();
    });
    searchAllBtn?.addEventListener("click", () => {
      void loadAllPages();
    });
    searchStopBtn?.addEventListener("click", () => {
      stopLoadingAll = true;
    });
    mergedMoreBtn?.addEventListener("click", () => {
      void (async () => {
        await Promise.all(
          POST_SUBTABS.map(
            (item) => handles.get(item.id)?.loadNext() ?? Promise.resolve()
          )
        );
        renderMerged();
        updateHint();
      })();
    });
    for (const button of body.querySelectorAll("[data-postmode]")) {
      button.addEventListener("click", () => {
        const next4 = button.dataset.postmode === "merged" ? "merged" : "split";
        if (next4 === mode) return;
        mode = next4;
        body.dataset.postmode = mode;
        if (viewEl) viewEl.dataset.mode = mode;
        for (const item of body.querySelectorAll("[data-postmode]")) {
          item.classList.toggle("active", item.dataset.postmode === mode);
        }
        applyFilters();
      });
    }
    const updatePie = () => {
      if (!pieEl) return;
      const notes = buildPieNotes(
        POST_SUBTABS.map((item) => {
          const handle = handles.get(item.id);
          return {
            label: item.label,
            loading: pending4.has(item.id),
            error: failures2.get(item.id),
            hasRows: loadedAny.has(item.id),
            // 失败提示要写到页上：只写"后续页没取到"没法判断是第 2 页还是第 9 页
            failedPage: handle?.failedPage() ?? void 0,
            loadedPages: handle?.pages() ?? 0
          };
        })
      );
      pieEl.innerHTML = buildForumPieSvg(counts) + notes + buildForumListHtml(counts, listOpen);
      pieEl.querySelector('[data-act="pie-all"]')?.addEventListener("click", () => {
        listOpen = !listOpen;
        updatePie();
      });
      refreshForumFilter();
      applyFilters();
    };
    updatePie();
    const mounted = /* @__PURE__ */ new Set();
    const mount2 = (id) => {
      if (mounted.has(id)) return;
      mounted.add(id);
      const pane = body.querySelector(
        `.tb-eztb-subpane[data-subpane="${id}"]`
      );
      if (pane) {
        const handle = mountPostsSubList(
          pane,
          identity4,
          id,
          (rows) => {
            pending4.delete(id);
            failures2.delete(id);
            loadedAny.add(id);
            if (!loadingAll) searchAllResult = null;
            counts = mergeForumCounts(counts, countPostsByForum(rows));
            updatePie();
          },
          (message) => {
            pending4.delete(id);
            failures2.set(id, message);
            updatePie();
          }
        );
        handles.set(id, handle);
      }
    };
    const activate = (id) => {
      body.dataset.subtab = id;
      for (const button of body.querySelectorAll(".tb-eztb-subtab")) {
        button.classList.toggle("active", button.dataset.subtab === id);
      }
      for (const pane of body.querySelectorAll(".tb-eztb-subpane")) {
        pane.classList.toggle("active", pane.dataset.subpane === id);
      }
      mount2(id);
    };
    for (const item of POST_SUBTABS) mount2(item.id);
    activate(active2);
    for (const button of body.querySelectorAll(".tb-eztb-subtab")) {
      button.addEventListener("click", () => {
        const id = button.dataset.subtab;
        if (id === "topic" || id === "reply") activate(id);
      });
    }
  }

  // src/features/panel/profile.ts
  function renderProfile(body, identity4) {
    const profile = identity4.profile ?? {};
    const genderText = profile.gender === 1 ? "男" : profile.gender === 2 ? "女" : "未知";
    const rows = [
      ["贴吧号", profile.uid ? String(profile.uid) : "—"],
      ["用户名", profile.un || "—"],
      ["昵称", profile.nickname || "—"],
      ["等级", profile.level ? String(profile.level) : "—"],
      ["吧龄", profile.tbAge || "—"],
      ["发帖数", profile.postNum !== void 0 ? String(profile.postNum) : "—"],
      ["粉丝数", profile.fansNum !== void 0 ? String(profile.fansNum) : "—"],
      ["关注数", profile.concernNum !== void 0 ? String(profile.concernNum) : "—"],
      ["关注吧数", profile.likeNum !== void 0 ? String(profile.likeNum) : "—"],
      ["性别", genderText],
      ["IP 属地", profile.ip || "—"],
      ["会员", profile.vipLevel ? `VIP ${profile.vipLevel}` : "—"],
      ["吧务", profile.isBawu ? profile.bawuType || "是" : "—"],
      ["简介", profile.intro || "—"]
    ];
    body.innerHTML = `<dl class="tb-eztb-kv">${rows.map(
      ([key, value]) => `<dt>${escapeHtml(key)}</dt><dd>${escapeHtml(value)}</dd>`
    ).join("")}</dl><div class="tb-eztb-actions" style="justify-content:flex-start;margin-top:14px;">` + (identity4.portrait ? `<button data-act="home">打开贴吧主页</button>` : "") + `</div>`;
    body.querySelector('[data-act="home"]')?.addEventListener("click", () => {
      if (!identity4.portrait) return;
      window.open(
        `https://tieba.baidu.com/home/main?id=${encodeURIComponent(identity4.portrait)}`,
        "_blank",
        "noopener,noreferrer"
      );
    });
  }

  // src/features/userPanel.ts
  var TABS = PANEL_TABS;
  function openUserPanel(ref, options = {}) {
    const settings = getSettings();
    const initialTab = options.tab ?? (settings.rememberLastTab ? readLastTab() ?? normalizePanelTabId(settings.defaultTab) : normalizePanelTabId(settings.defaultTab));
    const dialog = openDialog({
      title: ref.nickname || ref.un || "贴吧用户",
      subtitleHtml: "正在解析用户信息…",
      avatarUrl: ref.portrait ? portraitUrl(ref.portrait) : void 0,
      tabs: TABS.map((tab) => ({ id: tab.id, label: tab.label })),
      activeTab: initialTab,
      footerHtml: `<span>数据由脚本直连贴吧接口获取</span><span class="tb-eztb-spacer"></span><button type="button" class="tb-eztb-linkbtn" data-act="refresh">刷新当前页签</button><button type="button" class="tb-eztb-linkbtn" data-act="settings">设置</button>`
    });
    dialog.footer.querySelector('[data-act="settings"]')?.addEventListener("click", () => openSettingsDialog());
    const panes = /* @__PURE__ */ new Map();
    const initialized = /* @__PURE__ */ new Set();
    let activeTabId = initialTab;
    let currentIdentity = null;
    let requestedTab = initialTab;
    for (const tab of TABS) {
      dialog.root.querySelector(`.tb-eztb-tab[data-tab="${tab.id}"]`)?.addEventListener("click", () => {
        requestedTab = tab.id;
        if (currentIdentity) switchTab(tab.id, currentIdentity);
      });
    }
    const paneFor = (id) => {
      const existing = panes.get(id);
      if (existing) return existing;
      const pane = document.createElement("div");
      pane.className = "tb-eztb-pane";
      pane.dataset.pane = id;
      dialog.body.appendChild(pane);
      panes.set(id, pane);
      return pane;
    };
    const switchTab = (id, identity4) => {
      if (getSettings().rememberLastTab) writeLastTab(id);
      activeTabId = id;
      for (const [key, pane2] of panes) {
        pane2.classList.toggle("active", key === id);
      }
      const pane = paneFor(id);
      pane.classList.add("active");
      dialog.body.scrollTop = 0;
      if (initialized.has(id)) return;
      initialized.add(id);
      switch (id) {
        case "profile":
          renderProfile(pane, identity4);
          break;
        case "composition":
          renderCompositionTab(pane, ref);
          break;
        case "follow":
          renderFollowUsersTab(pane, identity4);
          break;
        case "mutual":
          renderMutualTab(pane, identity4);
          break;
        case "forums":
          renderFollowForumsTab(pane, identity4);
          break;
        case "fans":
          renderFansTab(pane, identity4);
          break;
        case "posts":
          renderPostsTab(pane, identity4);
          break;
      }
    };
    const applyIdentity = (identity4) => {
      currentIdentity = identity4;
      dialog.setTitle(identity4.nickname || identity4.un || "贴吧用户");
      dialog.setSubtitle(
        [
          identity4.un ? `用户名 ${escapeHtml(identity4.un)}` : "",
          identity4.uid ? `贴吧号 ${escapeHtml(identity4.uid)}` : ""
        ].filter(Boolean).join(" · ") || "已解析"
      );
      if (identity4.portrait) {
        dialog.setAvatar(portraitUrl(identity4.portrait));
      }
    };
    const refreshButton = dialog.footer.querySelector(
      '[data-act="refresh"]'
    );
    refreshButton?.addEventListener("click", () => {
      if (!currentIdentity || refreshButton.disabled) return;
      refreshButton.disabled = true;
      const originalLabel = refreshButton.textContent ?? "刷新当前页签";
      refreshButton.textContent = "刷新中…";
      void (async () => {
        try {
          const identity4 = await resolveIdentity(ref, true);
          applyIdentity(identity4);
          const pane = panes.get(activeTabId);
          if (pane) pane.innerHTML = "";
          initialized.delete(activeTabId);
          switchTab(activeTabId, identity4);
          refreshButton.textContent = "已刷新";
        } catch (error) {
          refreshButton.textContent = "刷新失败";
          log.warn("刷新当前页签失败：", error);
        } finally {
          setTimeout(() => {
            refreshButton.disabled = false;
            refreshButton.textContent = originalLabel;
          }, 1e3);
        }
      })();
    });
    dialog.body.innerHTML = `<div class="tb-eztb-loading"><div class="tb-eztb-spinner"></div>正在解析用户信息…</div>`;
    void (async () => {
      try {
        const identity4 = await resolveIdentity(ref);
        applyIdentity(identity4);
        dialog.body.innerHTML = "";
        switchTab(requestedTab, identity4);
      } catch (error) {
        const message = describeRequestError(error);
        const needBduss = /BDUSS/i.test(message);
        dialog.body.innerHTML = `<div class="tb-eztb-error">${escapeHtml(message)}</div>` + (needBduss ? `<div class="tb-eztb-actions" style="justify-content:flex-start;"><button data-act="config" class="primary">去设置 BDUSS</button></div>` : "");
        dialog.body.querySelector('[data-act="config"]')?.addEventListener(
          "click",
          () => openSettingsDialog({ requireBduss: true })
        );
      }
    })();
  }

  // src/ui/styles.ts
  var THEME_VARS = `
:root{
  --tb-eztb-accent:#1677ff;
  --tb-eztb-accent-border:#bcd8ff;
  --tb-eztb-accent-bg:#e8f3ff;
  --tb-eztb-spinner-track:#d6e4ff;
  --tb-eztb-info-bg:#f2f7ff;
  --tb-eztb-info-border:#cfe0ff;
  --tb-eztb-info-text:#1a4d99;
  --tb-eztb-danger-bg:#fff5f5;
  --tb-eztb-danger-border:#ffd8d8;
  --tb-eztb-danger-text:#c0392b;
  --tb-eztb-warn-bg:#fffaf0;
  --tb-eztb-warn-bg-soft:#fff8e6;
  --tb-eztb-warn-border:#ffe2b8;
  --tb-eztb-warn-text:#8a5a00;
  --tb-eztb-warn-text-strong:#9a6700;
  --tb-eztb-mark-bg:#fff3bf;
  --tb-eztb-text:#222;
  --tb-eztb-text-strong:#24292f;
  --tb-eztb-text-muted:#57606a;
  --tb-eztb-text-dim:#666;
  --tb-eztb-text-faint:#8a8f99;
  --tb-eztb-text-on-soft:#555;
  --tb-eztb-text-busy:#999;
  --tb-eztb-surface:#fff;
  --tb-eztb-surface-alt:#fafbfc;
  --tb-eztb-surface-soft:#f6f8fa;
  --tb-eztb-surface-busy:#fafafa;
  --tb-eztb-surface-hover:#e2e5ea;
  --tb-eztb-chip:#f2f3f5;
  --tb-eztb-chip-alt:#eef0f3;
  --tb-eztb-chip-strong:#eef1f4;
  --tb-eztb-border:#e8e8e8;
  --tb-eztb-border-soft:#e4e8ec;
  --tb-eztb-border-muted:#e0e3e7;
  --tb-eztb-border-input:#d0d7de;
  --tb-eztb-border-busy:#ddd;
  --tb-eztb-pie-track:#eef0f3;
  --tb-eztb-overlay:rgba(0,0,0,.45);
  --tb-eztb-shadow:rgba(0,0,0,.28);
  /* 成分徽章的色相由 JS 按下标给，这里只切明度 */
  --tb-eztb-badge-fg:28%;
  --tb-eztb-badge-bg:94%;
  --tb-eztb-badge-bd:76%;
}
@media (prefers-color-scheme: dark){
  :root{
    --tb-eztb-accent:#4c9aff;
    --tb-eztb-accent-border:#33507a;
    --tb-eztb-accent-bg:#1b2a41;
    --tb-eztb-spinner-track:#33507a;
    --tb-eztb-info-bg:#1c2a3d;
    --tb-eztb-info-border:#33507a;
    --tb-eztb-info-text:#8fbaff;
    --tb-eztb-danger-bg:#3a2326;
    --tb-eztb-danger-border:#5c3236;
    --tb-eztb-danger-text:#ff8b7d;
    --tb-eztb-warn-bg:#322a1c;
    --tb-eztb-warn-bg-soft:#322a1c;
    --tb-eztb-warn-border:#5a4629;
    --tb-eztb-warn-text:#e0b060;
    --tb-eztb-warn-text-strong:#e0b060;
    --tb-eztb-mark-bg:#4a3f1a;
    --tb-eztb-text:#e6e8eb;
    --tb-eztb-text-strong:#e6e8eb;
    --tb-eztb-text-muted:#a8b0ba;
    --tb-eztb-text-dim:#a8b0ba;
    --tb-eztb-text-faint:#8b939d;
    --tb-eztb-text-on-soft:#c2c8d0;
    --tb-eztb-text-busy:#7d858f;
    --tb-eztb-surface:#1c1f24;
    --tb-eztb-surface-alt:#202429;
    --tb-eztb-surface-soft:#262b31;
    --tb-eztb-surface-busy:#262b31;
    --tb-eztb-surface-hover:#333941;
    --tb-eztb-chip:#2b3036;
    --tb-eztb-chip-alt:#2b3036;
    --tb-eztb-chip-strong:#2b3036;
    --tb-eztb-border:#343a41;
    --tb-eztb-border-soft:#343a41;
    --tb-eztb-border-muted:#343a41;
    --tb-eztb-border-input:#3c434b;
    --tb-eztb-border-busy:#3c434b;
    --tb-eztb-pie-track:#343a41;
    --tb-eztb-overlay:rgba(0,0,0,.6);
    --tb-eztb-shadow:rgba(0,0,0,.55);
    --tb-eztb-badge-fg:78%;
    --tb-eztb-badge-bg:20%;
    --tb-eztb-badge-bd:34%;
  }
}
`;
  var STYLE_TEXT = `${THEME_VARS}
.tb-eztb-btn{
  display:inline-block !important;margin-left:6px;padding:2px 10px;
  font:normal 12px/18px -apple-system,BlinkMacSystemFont,"Segoe UI","Microsoft YaHei",sans-serif !important;
  color:var(--tb-eztb-accent) !important;background:var(--tb-eztb-surface) !important;border:1px solid var(--tb-eztb-accent-border) !important;
  border-radius:6px;cursor:pointer;text-decoration:none !important;vertical-align:middle;
  white-space:nowrap;user-select:none;position:relative;
  /* 行被挤时按钮自己不许被压缩（点了才知道还能不能查） */
  flex:0 0 auto;
  /* 只抬到能盖住同层内容即可。曾经设成 2e9，导致页面弹层/遮罩该盖住按钮时盖不住，
     表现为「本该被遮挡却浮在最上层」。5 与基线脚本一致。 */
  z-index:5;
  opacity:1 !important;visibility:visible !important;box-shadow:none;
  /* 贴吧新版页面的操作条容器常为 pointer-events:none（悬停才展开），
     子元素必须显式恢复，否则按钮看得见、点不动。基线脚本同样用这条覆盖。 */
  pointer-events:auto !important;
}
.tb-eztb-btn:hover{background:var(--tb-eztb-accent-bg) !important;border-color:var(--tb-eztb-accent) !important;}
.tb-eztb-btn.busy{color:var(--tb-eztb-text-busy) !important;border-color:var(--tb-eztb-border-busy) !important;background:var(--tb-eztb-surface-busy) !important;cursor:wait;}

.tb-eztb-mask{
  position:fixed;inset:0;z-index:2147483647;display:flex;align-items:center;justify-content:center;
  background:var(--tb-eztb-overlay);
  font-family:-apple-system,BlinkMacSystemFont,"Segoe UI","Microsoft YaHei",sans-serif;
}
.tb-eztb-dialog{
  display:flex;flex-direction:column;width:min(820px,calc(100vw - 32px));
  height:min(84vh,760px);background:var(--tb-eztb-surface) !important;border-radius:12px;overflow:hidden;
  box-shadow:0 12px 48px var(--tb-eztb-shadow);color:var(--tb-eztb-text) !important;font-size:14px;line-height:1.6;
  /* 原生滚动条与表单控件跟着系统偏好走，否则深色弹窗里会拖一条亮色滚动条 */
  color-scheme:light dark;
  /* 弹窗会被注入到贴吧页面里，页面样式可能通过继承污染排版，这里逐项复位 */
  text-align:left !important;text-indent:0 !important;letter-spacing:normal !important;
  word-spacing:normal !important;white-space:normal !important;
  font-weight:400;font-style:normal;
}
.tb-eztb-dialog *{box-sizing:border-box;}
.tb-eztb-head{
  display:flex;align-items:center;gap:10px;padding:12px 16px;
  border-bottom:1px solid var(--tb-eztb-border);background:var(--tb-eztb-surface-alt) !important;flex:0 0 auto;
}
.tb-eztb-avatar{width:34px;height:34px;border-radius:50%;flex:0 0 auto;background:var(--tb-eztb-chip-alt);}
.tb-eztb-head-main{flex:1 1 auto;min-width:0;}
.tb-eztb-title{
  font-weight:600;font-size:15px;color:var(--tb-eztb-text) !important;
  overflow:hidden;text-overflow:ellipsis;white-space:nowrap;
}
.tb-eztb-sub{color:var(--tb-eztb-text-faint) !important;font-size:12px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;}
.tb-eztb-close{
  flex:0 0 auto;width:28px;height:28px;line-height:26px;text-align:center;border:none;
  background:var(--tb-eztb-chip-alt) !important;border-radius:50%;cursor:pointer;font-size:16px;color:var(--tb-eztb-text-on-soft) !important;padding:0;
}
.tb-eztb-close:hover{background:var(--tb-eztb-surface-hover) !important;}
.tb-eztb-tabs{
  display:flex;gap:4px;padding:8px 12px 0;border-bottom:1px solid var(--tb-eztb-border);
  background:var(--tb-eztb-surface) !important;flex:0 0 auto;overflow-x:auto;
}
.tb-eztb-tab{
  border:none;background:transparent !important;cursor:pointer;padding:7px 12px;
  font-size:13px;color:var(--tb-eztb-text-muted) !important;border-bottom:2px solid transparent;white-space:nowrap;
}
.tb-eztb-tab:hover{color:var(--tb-eztb-accent) !important;}
.tb-eztb-tab.active{color:var(--tb-eztb-accent) !important;border-bottom-color:var(--tb-eztb-accent);font-weight:600;}
.tb-eztb-body{position:relative;flex:1 1 auto;min-height:0;overflow:auto;padding:14px 16px;background:var(--tb-eztb-surface) !important;}
/* 每个页签一个独立容器：内容互不覆盖，切换只切显隐，异步回调也不会串台 */
.tb-eztb-pane{display:none !important;}
.tb-eztb-pane.active{display:block !important;}
.tb-eztb-foot{
  display:flex;align-items:center;gap:10px;padding:8px 16px;border-top:1px solid var(--tb-eztb-border);
  background:var(--tb-eztb-surface-alt) !important;flex:0 0 auto;font-size:12px;color:var(--tb-eztb-text-faint) !important;
}
.tb-eztb-foot .tb-eztb-spacer{flex:1 1 auto;}
.tb-eztb-foot a{color:var(--tb-eztb-accent) !important;text-decoration:none;}
.tb-eztb-linkbtn{
  background:none !important;border:none;padding:0;margin:0;cursor:pointer;
  color:var(--tb-eztb-accent) !important;font-size:12px;font-family:inherit;line-height:1.6;
}
.tb-eztb-linkbtn:hover{text-decoration:underline;}
.tb-eztb-linkbtn[disabled]{color:var(--tb-eztb-text-faint) !important;cursor:default;text-decoration:none;}

.tb-eztb-loading{display:flex;align-items:center;justify-content:center;gap:10px;padding:40px 0;color:var(--tb-eztb-text-dim) !important;font-size:13px;}
.tb-eztb-spinner{
  width:22px;height:22px;border:3px solid var(--tb-eztb-spinner-track);border-top-color:var(--tb-eztb-accent);
  border-radius:50%;animation:tb-eztb-spin .8s linear infinite;
}
@keyframes tb-eztb-spin{to{transform:rotate(360deg);}}
.tb-eztb-empty{padding:32px 0;text-align:center;color:var(--tb-eztb-text-faint) !important;font-size:13px;}
.tb-eztb-error{
  margin:0 0 12px;padding:10px 12px;border-radius:8px;background:var(--tb-eztb-danger-bg) !important;
  border:1px solid var(--tb-eztb-danger-border);color:var(--tb-eztb-danger-text) !important;font-size:13px;word-break:break-all;
}
.tb-eztb-warn{
  margin:0 0 12px;padding:10px 12px;border-radius:8px;background:var(--tb-eztb-warn-bg) !important;
  border:1px solid var(--tb-eztb-warn-border);color:var(--tb-eztb-warn-text) !important;font-size:12px;
}

.tb-eztb-kv{display:grid;grid-template-columns:96px 1fr;gap:8px 12px;font-size:13px;margin:0;padding:0;}
.tb-eztb-kv dt{color:var(--tb-eztb-text-faint) !important;}
.tb-eztb-kv dd{margin:0;color:var(--tb-eztb-text) !important;word-break:break-word;}

.tb-eztb-list{display:flex;flex-direction:column;gap:2px;}
.tb-eztb-row{
  display:flex;align-items:center;gap:10px;padding:8px 6px;border-radius:8px;
  text-decoration:none !important;color:inherit !important;
  text-align:left !important;white-space:normal !important;
}
.tb-eztb-row:hover{background:var(--tb-eztb-surface-soft) !important;}
.tb-eztb-row-avatar{width:30px;height:30px;border-radius:50%;flex:0 0 auto;background:var(--tb-eztb-chip-alt);}
/* 标题与副标题必须是块级，否则 overflow/ellipsis 对行内元素无效，
   两行文字会挤在同一行并撑乱行高。 */
.tb-eztb-row-main{
  flex:1 1 auto;min-width:0;display:flex;flex-direction:column;gap:2px;
}
.tb-eztb-row-title{
  display:block;max-width:100%;font-size:13px;line-height:1.45;
  color:var(--tb-eztb-text) !important;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;
}
.tb-eztb-row-sub{
  display:block;max-width:100%;font-size:12px;line-height:1.4;
  color:var(--tb-eztb-text-faint) !important;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;
}
.tb-eztb-row-meta{
  flex:0 0 auto;max-width:40%;font-size:12px;line-height:1.4;
  color:var(--tb-eztb-text-faint) !important;text-align:right;white-space:nowrap;
}
/* 右侧要同时放「查楼层」和时间：竖着排，别把行撑宽 */
.tb-eztb-row-meta-stack{
  display:flex;flex-direction:column;align-items:flex-end;gap:3px;
}
.tb-eztb-row-time{font-size:12px;color:var(--tb-eztb-text-faint) !important;}
/* 副标题里的小吧名：和正文区分开 */
.tb-eztb-row-forum{
  display:inline-block;margin-right:6px;padding:0 5px;border-radius:4px;
  background:var(--tb-eztb-chip) !important;color:var(--tb-eztb-text-muted) !important;font-size:11px;line-height:16px;
}
/* 「检测签到号」之后补上的"近期发言 N 条" */
.tb-eztb-row-extra{color:var(--tb-eztb-text-faint) !important;}
/* 楼中楼回复的对象：淡一点，别抢正文 */
.tb-eztb-row-replyto{color:var(--tb-eztb-text-faint) !important;margin-right:4px;}
/* 楼层号（查到了就换成它） */
.tb-eztb-floor{
  padding:0 6px;border-radius:4px;background:var(--tb-eztb-chip-strong) !important;color:var(--tb-eztb-text-strong) !important;
  font-size:11px;line-height:17px;white-space:nowrap;
}
/* 「疑似只签到」标记：只提示、不结论，所以用弱一点的样式 */
.tb-eztb-signin{
  display:inline-block;margin-right:4px;padding:0 6px;border-radius:999px;
  background:var(--tb-eztb-warn-bg-soft) !important;color:var(--tb-eztb-warn-text-strong) !important;border:1px dashed var(--tb-eztb-warn-border);
  font-size:11px;line-height:16px;white-space:nowrap;
}
/* 「关注的吧」里的签到检测结论区 */
.tb-eztb-activity{margin:0 0 10px;}
.tb-eztb-activity .tb-eztb-hint{margin:0 0 6px;}

/* 「发帖」页签顶部的占比饼图 */
.tb-eztb-piestat{margin:0 0 12px;}
.tb-eztb-pie{
  display:flex;align-items:center;gap:16px;margin:0;padding:10px 12px;
  border:1px solid var(--tb-eztb-border);border-radius:8px;background:var(--tb-eztb-surface-alt) !important;
}
/* 空数据时的那圈底环：颜色必须走变量，写死会在深色模式下变成一圈亮灰 */
.tb-eztb-pie-svg{width:96px;height:96px;flex:0 0 auto;}
.tb-eztb-pie-track{stroke:var(--tb-eztb-pie-track);}
.tb-eztb-pie-legend{display:flex;flex-direction:column;gap:4px;font-size:12px;min-width:0;}
.tb-eztb-pie-item{display:flex;align-items:center;gap:6px;color:var(--tb-eztb-text-muted) !important;}
.tb-eztb-pie-dot{
  width:8px;height:8px;border-radius:50%;flex:0 0 auto;display:inline-block;
}
/* 吧名可以很长：给个上限并省略，别把图例撑破 */
.tb-eztb-pie-label{
  display:inline-block;max-width:150px;overflow:hidden;text-overflow:ellipsis;
  white-space:nowrap;vertical-align:bottom;
}
.tb-eztb-pie-count{color:var(--tb-eztb-text-strong) !important;font-weight:600;}
.tb-eztb-pie-percent{color:var(--tb-eztb-text-faint) !important;}
.tb-eztb-pie-total{color:var(--tb-eztb-text-faint) !important;margin-top:2px;}
.tb-eztb-pie-empty{color:var(--tb-eztb-text-faint) !important;}
/* 「查看全部 N 个吧」按钮与展开后的完整列表 */
.tb-eztb-pielistwrap{margin-top:8px;}
/* 两路 feed 没到齐时的提示：不能让"只有主题帖"的饼图看起来像完整的 */
.tb-eztb-pie-pending{
  margin:6px 0 0;padding:6px 8px;border-radius:6px;font-size:12px;
  background:var(--tb-eztb-info-bg) !important;border:1px solid var(--tb-eztb-info-border);color:var(--tb-eztb-info-text) !important;
}
.tb-eztb-pielistbtn{
  padding:2px 10px;border:1px solid var(--tb-eztb-border-input);border-radius:6px;cursor:pointer;
  background:var(--tb-eztb-surface) !important;color:var(--tb-eztb-accent) !important;font:inherit;font-size:12px;
}
.tb-eztb-pielistbtn:hover{background:var(--tb-eztb-accent-bg) !important;border-color:var(--tb-eztb-accent-border);}
.tb-eztb-pielist{
  margin-top:8px;max-height:240px;overflow:auto;
  border:1px solid var(--tb-eztb-border);border-radius:8px;background:var(--tb-eztb-surface) !important;padding:6px 8px;
}
.tb-eztb-pielist-head{font-size:12px;color:var(--tb-eztb-text-faint) !important;margin:2px 0 6px;}
.tb-eztb-pieitem{display:flex;align-items:center;gap:8px;padding:3px 0;font-size:12px;}
.tb-eztb-pieitem-name{
  flex:0 0 auto;width:120px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;
  color:var(--tb-eztb-text-strong) !important;
}
.tb-eztb-pieitem-bar{
  flex:1 1 auto;min-width:40px;height:8px;border-radius:4px;background:var(--tb-eztb-chip-strong) !important;overflow:hidden;
}
.tb-eztb-pieitem-bar > i{display:block;height:100%;background:var(--tb-eztb-accent) !important;border-radius:4px;}
.tb-eztb-pieitem-count{flex:0 0 auto;min-width:34px;text-align:right;color:var(--tb-eztb-text-strong) !important;}
.tb-eztb-pieitem-percent{flex:0 0 auto;min-width:48px;text-align:right;color:var(--tb-eztb-text-faint) !important;}
/* 三种行内小按钮共用一套样式：「查等级」「查楼层」「检测签到号」。
   注意别互相复用类名——测试和排查都按类名找按钮，混用会点错目标。 */
.tb-eztb-levelbtn,.tb-eztb-floorbtn,.tb-eztb-minibtn{
  padding:1px 8px;border:1px solid var(--tb-eztb-accent-border);border-radius:6px;cursor:pointer;
  background:var(--tb-eztb-surface) !important;color:var(--tb-eztb-accent) !important;font:inherit;font-size:12px;
}
.tb-eztb-levelbtn:hover,.tb-eztb-floorbtn:hover,.tb-eztb-minibtn:hover{background:var(--tb-eztb-accent-bg) !important;}
.tb-eztb-levelbtn[disabled],.tb-eztb-floorbtn[disabled],.tb-eztb-minibtn[disabled]{
  opacity:.6;cursor:default;color:var(--tb-eztb-text-faint) !important;border-color:var(--tb-eztb-border-muted);
}
/* 发帖页签的类型标签：主题 / 回复 / 楼中楼 */
.tb-eztb-tag{
  display:inline-block;margin-right:6px;padding:0 6px;border-radius:4px;
  font-size:11px;line-height:17px;vertical-align:1px;white-space:nowrap;
}
.tb-eztb-tag-topic{background:var(--tb-eztb-accent-bg) !important;color:var(--tb-eztb-accent) !important;border:1px solid var(--tb-eztb-accent-border);}
.tb-eztb-tag-reply{background:var(--tb-eztb-chip) !important;color:var(--tb-eztb-text-muted) !important;border:1px solid var(--tb-eztb-border-muted);}
.tb-eztb-tag-sub{background:var(--tb-eztb-warn-bg-soft) !important;color:var(--tb-eztb-warn-text-strong) !important;border:1px solid var(--tb-eztb-warn-border);}
/* 「发帖」页签里的两个子页签（主题帖 / 回复）：两个 feed 各自分页，互不影响 */
/* 「发帖」页签的工具条：显示方式（分开 / 合并）+ 只看某个吧 + 内容搜索。
   只筛下面的列表，饼图仍然统计全部（把饼图筛成一段没有信息量）。
   选择器带 .tb-eztb-postbar 前缀是为了盖过 .tb-eztb-input 的 width:100%（同优先级时后者会赢）。 */
.tb-eztb-postbar{margin:0 0 10px;}
.tb-eztb-postbar-row{display:flex;align-items:center;gap:8px;flex-wrap:wrap;}
.tb-eztb-postbar-label{font-size:12px;color:var(--tb-eztb-text-muted) !important;white-space:nowrap;}
.tb-eztb-modetabs{display:inline-flex;gap:4px;}
.tb-eztb-modetab{
  padding:3px 12px;border:1px solid var(--tb-eztb-border-input);border-radius:999px;cursor:pointer;
  background:var(--tb-eztb-surface-soft) !important;color:var(--tb-eztb-text-muted) !important;
  font:inherit;font-size:12px;line-height:20px;white-space:nowrap;
}
.tb-eztb-modetab:hover{color:var(--tb-eztb-accent) !important;border-color:var(--tb-eztb-accent-border);}
.tb-eztb-modetab.active{
  background:var(--tb-eztb-accent-bg) !important;border-color:var(--tb-eztb-accent);
  color:var(--tb-eztb-accent) !important;font-weight:600;
}
.tb-eztb-postbar .tb-eztb-forumfilter{width:auto;max-width:220px;padding:4px 8px;font-size:12px;}
.tb-eztb-postbar .tb-eztb-postsearch{width:auto;flex:1 1 160px;max-width:260px;padding:4px 8px;font-size:12px;}
.tb-eztb-postbar .tb-eztb-hint{margin-top:6px;}
/* 分开 / 合并：同一时刻只显示一种视图 */
.tb-eztb-postview[data-mode="split"] .tb-eztb-mergedview{display:none !important;}
.tb-eztb-postview[data-mode="merged"] .tb-eztb-splitview{display:none !important;}
/* 被筛掉的行只藏起来（DOM 里留着），翻页新加载的行走同一套筛选规则 */
.tb-eztb-row.tb-eztb-filtered-out{display:none !important;}
.tb-eztb-subtabs{display:flex;gap:6px;margin:0 0 10px;}
.tb-eztb-subtab{
  padding:3px 12px;border:1px solid var(--tb-eztb-border-input);border-radius:999px;cursor:pointer;
  background:var(--tb-eztb-surface-soft) !important;color:var(--tb-eztb-text-muted) !important;
  font:inherit;font-size:12px;line-height:20px;white-space:nowrap;
}
.tb-eztb-subtab:hover{color:var(--tb-eztb-accent) !important;border-color:var(--tb-eztb-accent-border);}
.tb-eztb-subtab.active{
  background:var(--tb-eztb-accent-bg) !important;border-color:var(--tb-eztb-accent);
  color:var(--tb-eztb-accent) !important;font-weight:600;
}
/* 同 .tb-eztb-pane：只切显隐，切回来时已加载的内容还在 */
.tb-eztb-subpane{display:none !important;}
.tb-eztb-subpane.active{display:block !important;}

/* 「成分」标记：命中关键词时挂在用户名旁的徽章。
   和按钮一样必须显式声明 pointer-events:auto —— 新版页面的 .btn-wrapper
   常态是 pointer-events:none，否则徽章看得见、点不动（同一个坑）。
   还有一条：新版页面的头部行是**固定高度**（.image-text .user-info{height:40px}），
   标记一旦折行就会顶到下面的标题/正文上（实测量到压住 13px）。
   所以这里强制单行、允许被压缩裁剪——少显示几个标记，也不许压内容。 */
.tb-eztb-badges{
  display:inline-flex;flex-wrap:nowrap;align-items:center;gap:4px;
  margin-left:6px;vertical-align:middle;min-width:0;overflow:hidden;
}
/* 行实在挤不下时，先让我们这块被压缩裁剪，而不是把整行顶出去。
   :has 保证只在"这个槽里真的插了我们的标记"时才生效，不干扰页面自己的按钮。 */
.head-line > .btn-wrapper:has(> .tb-eztb-badges){min-width:0;flex-shrink:1;}
/* 回复行（头部行后面紧跟正文块 .comment-content）：
   正文块会**往上顶**到头部行的下半部分（实测：40px 的行，正文从 y=271 开始，
   而按钮默认在这行里垂直居中、占 255~279，正好压住正文第一行的尾巴）。
   这类行里把按钮/标记贴到行顶——行顶那 24px 是空的，正文碰不到。
   用户报的"查询按钮有时部分遮挡发言"就是这个（快照里 20/23 行如此）。 */
.head-line:has(+ .comment-content) > .btn-wrapper{align-self:flex-start;padding-top:0;}
.tb-eztb-badge{
  display:inline-block;padding:0 6px;border-radius:999px;font-size:11px;line-height:17px;
  font-weight:600;white-space:nowrap;cursor:pointer;pointer-events:auto !important;flex:0 0 auto;
  color:hsl(var(--tb-eztb-badge-hue,210) 62% var(--tb-eztb-badge-fg)) !important;
  background:hsl(var(--tb-eztb-badge-hue,210) 92% var(--tb-eztb-badge-bg)) !important;
  border:1px solid hsl(var(--tb-eztb-badge-hue,210) 72% var(--tb-eztb-badge-bd));
}
.tb-eztb-badge:hover{filter:brightness(.97);}
/* 证据较弱（只在回复/楼中楼里出现）：虚线边框 + 降透明度 */
.tb-eztb-badge-unsure{opacity:.72;border-style:dashed;}
.tb-eztb-badge-more{
  background:var(--tb-eztb-chip) !important;color:var(--tb-eztb-text-muted) !important;border-color:var(--tb-eztb-border-input);
}
/* 行里连一个标记都放不下时的兜底：一个小圆点，颜色仍然区分规则 */
.tb-eztb-badge-dot{padding:0 5px;font-size:10px;line-height:17px;}
/* 「证据不足」：没有命中、但这次的数据不足以判定。用中性灰，不参与规则配色，
   免得看起来像"命中了某条规则"（HANDOFF §9.2）。 */
.tb-eztb-badge-insufficient{
  color:var(--tb-eztb-text-muted) !important;
  background:var(--tb-eztb-chip) !important;
  border-color:var(--tb-eztb-border-input);
  border-style:solid;
  font-weight:500;
}
/* 键盘可达：徽章自己是 span（用 button 会被 .btn-wrapper 的样式带跑），
   所以显式给一圈焦点环，键盘用户才看得出焦点在哪。 */
.tb-eztb-badge:focus-visible,.tb-eztb-btn:focus-visible{
  outline:2px solid var(--tb-eztb-accent);
  outline-offset:1px;
}

/* 面板「成分」页签 */
.tb-eztb-hits{display:flex;flex-direction:column;gap:10px;}
.tb-eztb-hit{
  padding:10px 12px;border:1px solid var(--tb-eztb-border);border-radius:8px;background:var(--tb-eztb-surface-alt) !important;
}
.tb-eztb-hit-head{display:flex;align-items:center;gap:8px;margin-bottom:6px;flex-wrap:wrap;}
.tb-eztb-hit-head .tb-eztb-badge{cursor:default;}
.tb-eztb-hit-unsure{font-size:12px;color:var(--tb-eztb-warn-text) !important;}
/* 命中规则右上角写"最近依据"的时间：证据按时间倒序，得让用户看出为什么这么排 */
.tb-eztb-hit-newest{font-size:11px;color:var(--tb-eztb-text-muted) !important;margin-left:auto;}
.tb-eztb-evidence{
  display:flex;flex-wrap:wrap;align-items:center;gap:6px;margin-top:4px;
  font-size:12px;color:var(--tb-eztb-text-muted) !important;
}
/* 一行证据的头部：类型标签 + 原因 + 关键词 + 时间 + 吧名 + 回复对象 */
.tb-eztb-evidence-head{display:flex;flex-wrap:wrap;align-items:center;gap:6px;flex:1 1 100%;}
.tb-eztb-evidence-time,.tb-eztb-evidence-forum,.tb-eztb-evidence-replyto{
  font-size:11px;color:var(--tb-eztb-text-muted) !important;
}
.tb-eztb-evidence-forum::before{content:"·";margin-right:4px;}
.tb-eztb-evidence-keyword{
  padding:0 6px;border-radius:4px;background:var(--tb-eztb-chip-strong) !important;color:var(--tb-eztb-text-strong) !important;
  font-size:11px;line-height:17px;
}
.tb-eztb-evidence-text{
  flex:1 1 100%;font-size:12px;color:var(--tb-eztb-text-muted) !important;word-break:break-word;
}
/* 跳转 + 楼层那一行 */
.tb-eztb-evidence-actions{display:flex;align-items:center;gap:8px;flex:1 1 100%;margin-top:2px;}
.tb-eztb-evidence-link{
  font-size:12px;color:var(--tb-eztb-accent) !important;text-decoration:none;
  border-bottom:1px dashed var(--tb-eztb-accent-border);
}
.tb-eztb-evidence-link:hover{border-bottom-style:solid;}
.tb-eztb-mark{background:var(--tb-eztb-mark-bg) !important;color:inherit !important;padding:0 2px;border-radius:2px;}
.tb-eztb-textarea-tall{min-height:150px;}
.tb-eztb-more{
  display:block;width:100%;margin-top:12px;padding:8px;border:1px solid var(--tb-eztb-border-input);
  background:var(--tb-eztb-surface-soft) !important;border-radius:8px;cursor:pointer;font-size:13px;color:var(--tb-eztb-text-strong) !important;
}
.tb-eztb-more:hover{background:var(--tb-eztb-chip-strong) !important;}
.tb-eztb-more[disabled]{opacity:.6;cursor:default;}

.tb-eztb-form{display:flex;flex-direction:column;gap:12px;}
.tb-eztb-report{
  margin:0 0 12px;padding:10px 12px;border-radius:8px;background:var(--tb-eztb-surface-soft) !important;
  border:1px solid var(--tb-eztb-border-soft);font:12px/1.6 Consolas,Menlo,monospace !important;
  color:var(--tb-eztb-text-strong) !important;white-space:pre-wrap;word-break:break-all;max-height:52vh;overflow:auto;
}
.tb-eztb-field{display:flex;flex-direction:column;gap:6px;}
.tb-eztb-field label{font-size:13px;font-weight:600;color:var(--tb-eztb-text-strong) !important;}
.tb-eztb-textarea,.tb-eztb-input{
  width:100%;padding:8px 10px;border:1px solid var(--tb-eztb-border-input);border-radius:8px;
  font:13px/1.5 -apple-system,BlinkMacSystemFont,"Segoe UI","Microsoft YaHei",sans-serif;
  color:var(--tb-eztb-text-strong) !important;background:var(--tb-eztb-surface) !important;
}
.tb-eztb-textarea{min-height:76px;resize:vertical;word-break:break-all;}
.tb-eztb-hint{font-size:12px;color:var(--tb-eztb-text-faint) !important;}
.tb-eztb-actions{display:flex;gap:8px;justify-content:flex-end;margin-top:4px;flex-wrap:wrap;}
.tb-eztb-actions button{
  border:1px solid var(--tb-eztb-border-input);background:var(--tb-eztb-surface-soft) !important;color:var(--tb-eztb-text-strong) !important;
  border-radius:6px;padding:6px 14px;font-size:13px;cursor:pointer;
}
.tb-eztb-actions button.primary{background:var(--tb-eztb-accent) !important;border-color:var(--tb-eztb-accent);color:var(--tb-eztb-surface) !important;}
.tb-eztb-actions button:hover{opacity:.92;}
`;

  // src/main.ts
  function createButton(ref) {
    const button = document.createElement("button");
    button.type = "button";
    button.className = BUTTON_CLASS;
    button.textContent = "查询";
    button.title = "查看该用户的资料 / 关注的人 / 关注的吧 / 粉丝 / 发帖";
    buttonRefs.set(button, ref);
    button.addEventListener("mousedown", (event) => {
      event.stopPropagation();
    });
    return button;
  }
  var buttonRefs = /* @__PURE__ */ new WeakMap();
  function installClickDelegate() {
    document.addEventListener(
      "click",
      (event) => {
        const target = event.target;
        const badge = target?.closest?.(`.${BADGE_CLASS}`);
        if (badge) {
          const badgeRef = getBadgeRef(badge);
          if (badgeRef) {
            event.preventDefault();
            event.stopPropagation();
            openUserPanel(badgeRef, { tab: "composition" });
            return;
          }
        }
        const button = target?.closest?.(`.${BUTTON_CLASS}`);
        if (!button) return;
        const ref = buttonRefs.get(button);
        if (!ref) return;
        event.preventDefault();
        event.stopPropagation();
        log.debug("按钮被点击，正在打开面板：", describeUser(ref));
        openUserPanel(ref);
      },
      true
    );
  }
  function installKeyboardDelegate() {
    document.addEventListener(
      "keydown",
      (event) => {
        if (event.key !== "Enter" && event.key !== " " && event.key !== "Spacebar") {
          return;
        }
        const target = event.target;
        const badge = target?.closest?.(`.${BADGE_CLASS}`);
        if (!badge) return;
        const badgeRef = getBadgeRef(badge);
        if (!badgeRef) return;
        event.preventDefault();
        event.stopPropagation();
        openUserPanel(badgeRef, { tab: "composition" });
      },
      true
    );
  }
  var mount = (ref, nameEl, wrapper) => {
    if (!ref.userId && !ref.un && !ref.portrait) return;
    const button = createButton(ref);
    if (wrapper) {
      wrapper.appendChild(button);
    } else if (nameEl?.parentNode) {
      nameEl.parentNode.insertBefore(button, nameEl.nextSibling);
    }
    if (getSettings().compositionAuto) {
      registerUserForComposition(ref, button);
    }
  };
  function registerMenuCommands() {
    if (typeof GM_registerMenuCommand !== "function") return;
    try {
      GM_registerMenuCommand("eztb：设置 BDUSS / 运行参数", () => {
        openSettingsDialog();
      });
      GM_registerMenuCommand("eztb：清空用户资料缓存", () => {
        clearProfileCache();
        alert("已清空 eztb 用户资料缓存");
      });
      GM_registerMenuCommand("eztb：清空成分缓存", () => {
        clearCompositionCache();
        alert("已清空 eztb 成分检测缓存");
      });
      GM_registerMenuCommand("eztb：重新检测本页用户", () => {
        rescanPage();
        alert(
          `已重新排队检测本页用户（每页最多 ${getSettings().compositionMaxPerPage} 人，按设置里的间隔逐个进行）`
        );
      });
      GM_registerMenuCommand("eztb：诊断当前页面", () => {
        openDiagnoseDialog();
      });
      GM_registerMenuCommand("eztb：中断当前所有在飞请求", () => {
        const count3 = abortAllInFlight();
        alert(
          count3 > 0 ? `已中断 ${count3} 个在飞请求` : "当前没有在飞请求"
        );
      });
    } catch (error) {
      log.warn("注册菜单命令失败：", error);
    }
  }
  function boot() {
    const style = document.createElement("style");
    style.textContent = STYLE_TEXT;
    (document.head ?? document.documentElement).appendChild(style);
    requestQueue.setMinInterval(getSettings().minIntervalMs);
    registerMenuCommands();
    installClickDelegate();
    installKeyboardDelegate();
    startScanner(mount);
    log.info("已加载：数据直连贴吧接口，不经过第三方服务");
  }
  if (document.readyState === "loading") {
    document.addEventListener("DOMContentLoaded", boot, { once: true });
  } else {
    boot();
  }
})();

/* ===========================================================================
 * NOTICE · 本文件打包进来的第三方代码
 *
 * 这不是 @require 进来的外部脚本，而是构建时打包进来的库（见 src/ 与 build.mjs）。
 * 按 Greasy Fork 的规定，内嵌的库要写明来源、名称与版本。
 * 下面这份清单由 scripts/deps-info.mjs 在构建时从磁盘上的 package.json 与 git 读出，
 * 不是手写的，所以不会随着上游更新而失真。
 *
 *   tieba.js 3.1.3 · 许可 ISC
 *       来源  https://github.com/Dilettante258/tieba.js
 *       锁定提交  db48716f754c4cfd8ebbeb87d447c378dafeb0eb
 *       依上游 package.json 的 license 字段声明为 ISC。该仓库暂未附带 LICENSE 文件，
 *       这里按 ISC 模板补一份（版权人取自 package.json 的 author：Dilettante258）：
 *
 *         Copyright (c) Dilettante258
 *         Permission to use, copy, modify, and/or distribute this software for any
 *         purpose with or without fee is hereby granted, provided that the above
 *         copyright notice and this permission notice appear in all copies.
 *         THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 *         WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 *         MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 *         ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 *         WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 *         ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 *         OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 *       建议仍向上游要一份正式 LICENSE 文件。
 *   上游 eztb v3 · 构建时用的那一份检出（见 sdk.lock.json）
 *       来源  https://github.com/Dilettante258/eazy-tieba
 *       锁定提交  8ca0637c9c4082979f61626718b072a076ba7508
 *   effect 3.19.18 · 许可 MIT
 *       来源  https://github.com/Effect-TS/effect
 *   @bufbuild/protobuf 2.11.0 · 许可 (Apache-2.0 AND BSD-3-Clause)
 *       来源  https://github.com/bufbuild/protobuf-es
 *   long 5.3.2 · 许可 Apache-2.0
 *       来源  https://github.com/dcodeIO/long.js
 *
 * 本工程自己的代码按上面的 @license 发布。
 * =========================================================================== */