@stevenzxs/ccharness 1.0.0

package/dist/chunk-x7qhxrp7.js

@@ -0,0 +1,225 @@
+// @bun
+import {
+  gt,
+  init_semver
+} from "./chunk-4spgkgr3.js";
+import {
+  getGlobalConfig,
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./chunk-a07hgnvm.js";
+import {
+  require_semver
+} from "./chunk-6x35ffpx.js";
+import {
+  init_log,
+  init_privacyLevel,
+  isEssentialTrafficOnly,
+  logError
+} from "./chunk-mss2zjet.js";
+import {
+  init_errors,
+  toError
+} from "./chunk-7fxg2tat.js";
+import {
+  getClaudeConfigHomeDir,
+  init_envUtils
+} from "./chunk-347yx4gw.js";
+import {
+  getIsNonInteractiveSession,
+  init_state
+} from "./chunk-11q9h2zt.js";
+import {
+  axios_default,
+  init_axios
+} from "./chunk-ebd8xb7s.js";
+import {
+  __esm,
+  __toESM
+} from "./chunk-hhsxm2yr.js";
+
+// src/utils/releaseNotes.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+function getChangelogCachePath() {
+  return join(getClaudeConfigHomeDir(), "cache", "changelog.md");
+}
+async function migrateChangelogFromConfig() {
+  const config = getGlobalConfig();
+  if (!config.cachedChangelog) {
+    return;
+  }
+  const cachePath = getChangelogCachePath();
+  try {
+    await mkdir(dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, config.cachedChangelog, {
+      encoding: "utf-8",
+      flag: "wx"
+    });
+  } catch {}
+  saveGlobalConfig(({ cachedChangelog: _, ...rest }) => rest);
+}
+async function fetchAndStoreChangelog() {
+  if (getIsNonInteractiveSession()) {
+    return;
+  }
+  if (isEssentialTrafficOnly()) {
+    return;
+  }
+  const response = await axios_default.get(RAW_CHANGELOG_URL);
+  if (response.status === 200) {
+    const changelogContent = response.data;
+    if (changelogContent === changelogMemoryCache) {
+      return;
+    }
+    const cachePath = getChangelogCachePath();
+    await mkdir(dirname(cachePath), { recursive: true });
+    await writeFile(cachePath, changelogContent, { encoding: "utf-8" });
+    changelogMemoryCache = changelogContent;
+    const changelogLastFetched = Date.now();
+    saveGlobalConfig((current) => ({
+      ...current,
+      changelogLastFetched
+    }));
+  }
+}
+async function getStoredChangelog() {
+  if (changelogMemoryCache !== null) {
+    return changelogMemoryCache;
+  }
+  const cachePath = getChangelogCachePath();
+  try {
+    const content = await readFile(cachePath, "utf-8");
+    changelogMemoryCache = content;
+    return content;
+  } catch {
+    changelogMemoryCache = "";
+    return "";
+  }
+}
+function getStoredChangelogFromMemory() {
+  return changelogMemoryCache ?? "";
+}
+function parseChangelog(content) {
+  try {
+    if (!content)
+      return {};
+    const releaseNotes = {};
+    const sections = content.split(/^## /gm).slice(1);
+    for (const section of sections) {
+      const lines = section.trim().split(`
+`);
+      if (lines.length === 0)
+        continue;
+      const versionLine = lines[0];
+      if (!versionLine)
+        continue;
+      const version = versionLine.split(" - ")[0]?.trim() || "";
+      if (!version)
+        continue;
+      const notes = lines.slice(1).filter((line) => line.trim().startsWith("- ")).map((line) => line.trim().substring(2).trim()).filter(Boolean);
+      if (notes.length > 0) {
+        releaseNotes[version] = notes;
+      }
+    }
+    return releaseNotes;
+  } catch (error) {
+    logError(toError(error));
+    return {};
+  }
+}
+function getRecentReleaseNotes(currentVersion, previousVersion, changelogContent = getStoredChangelogFromMemory()) {
+  try {
+    const releaseNotes = parseChangelog(changelogContent);
+    const baseCurrentVersion = import_semver.coerce(currentVersion);
+    const basePreviousVersion = previousVersion ? import_semver.coerce(previousVersion) : null;
+    if (!basePreviousVersion || baseCurrentVersion && gt(baseCurrentVersion.version, basePreviousVersion.version)) {
+      return Object.entries(releaseNotes).filter(([version]) => !basePreviousVersion || gt(version, basePreviousVersion.version)).sort(([versionA], [versionB]) => gt(versionA, versionB) ? -1 : 1).flatMap(([_, notes]) => notes).filter(Boolean).slice(0, MAX_RELEASE_NOTES_SHOWN);
+    }
+  } catch (error) {
+    logError(toError(error));
+    return [];
+  }
+  return [];
+}
+function getAllReleaseNotes(changelogContent = getStoredChangelogFromMemory()) {
+  try {
+    const releaseNotes = parseChangelog(changelogContent);
+    const sortedVersions = Object.keys(releaseNotes).sort((a, b) => gt(a, b) ? 1 : -1);
+    return sortedVersions.map((version) => {
+      const versionNotes = releaseNotes[version];
+      if (!versionNotes || versionNotes.length === 0)
+        return null;
+      const notes = versionNotes.filter(Boolean);
+      if (notes.length === 0)
+        return null;
+      return [version, notes];
+    }).filter((item) => item !== null);
+  } catch (error) {
+    logError(toError(error));
+    return [];
+  }
+}
+async function checkForReleaseNotes(lastSeenVersion, currentVersion = MACRO.VERSION) {
+  if (process.env.USER_TYPE === "ant") {
+    const changelog = MACRO.VERSION_CHANGELOG;
+    if (changelog) {
+      const commits = changelog.trim().split(`
+`).filter(Boolean);
+      return {
+        hasReleaseNotes: commits.length > 0,
+        releaseNotes: commits
+      };
+    }
+    return {
+      hasReleaseNotes: false,
+      releaseNotes: []
+    };
+  }
+  const cachedChangelog = await getStoredChangelog();
+  if (lastSeenVersion !== currentVersion || !cachedChangelog) {
+    fetchAndStoreChangelog().catch((error) => logError(toError(error)));
+  }
+  const releaseNotes = getRecentReleaseNotes(currentVersion, lastSeenVersion, cachedChangelog);
+  const hasReleaseNotes = releaseNotes.length > 0;
+  return {
+    hasReleaseNotes,
+    releaseNotes
+  };
+}
+function checkForReleaseNotesSync(lastSeenVersion, currentVersion = MACRO.VERSION) {
+  if (process.env.USER_TYPE === "ant") {
+    const changelog = MACRO.VERSION_CHANGELOG;
+    if (changelog) {
+      const commits = changelog.trim().split(`
+`).filter(Boolean);
+      return {
+        hasReleaseNotes: commits.length > 0,
+        releaseNotes: commits
+      };
+    }
+    return {
+      hasReleaseNotes: false,
+      releaseNotes: []
+    };
+  }
+  const releaseNotes = getRecentReleaseNotes(currentVersion, lastSeenVersion);
+  return {
+    hasReleaseNotes: releaseNotes.length > 0,
+    releaseNotes
+  };
+}
+var import_semver, MAX_RELEASE_NOTES_SHOWN = 5, CHANGELOG_URL = "https://github.com/anthropics/claude-code/blob/main/CHANGELOG.md", RAW_CHANGELOG_URL = "https://raw.githubusercontent.com/anthropics/claude-code/refs/heads/main/CHANGELOG.md", changelogMemoryCache = null;
+var init_releaseNotes = __esm(() => {
+  init_axios();
+  init_state();
+  init_config();
+  init_envUtils();
+  init_errors();
+  init_log();
+  init_privacyLevel();
+  init_semver();
+  import_semver = __toESM(require_semver(), 1);
+});
+
+export { CHANGELOG_URL, migrateChangelogFromConfig, fetchAndStoreChangelog, getStoredChangelog, getStoredChangelogFromMemory, parseChangelog, getAllReleaseNotes, checkForReleaseNotes, checkForReleaseNotesSync, init_releaseNotes };

package/dist/chunk-x8b7vft8.js

@@ -0,0 +1,132 @@
+// @bun
+// src/utils/managedEnvConstants.ts
+var PROVIDER_MANAGED_ENV_VARS = new Set([
+  "CLAUDE_CODE_PROVIDER_MANAGED_BY_HOST",
+  "CLAUDE_CODE_USE_BEDROCK",
+  "CLAUDE_CODE_USE_VERTEX",
+  "CLAUDE_CODE_USE_FOUNDRY",
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_BEDROCK_BASE_URL",
+  "ANTHROPIC_VERTEX_BASE_URL",
+  "ANTHROPIC_FOUNDRY_BASE_URL",
+  "ANTHROPIC_FOUNDRY_RESOURCE",
+  "ANTHROPIC_VERTEX_PROJECT_ID",
+  "CLOUD_ML_REGION",
+  "ANTHROPIC_API_KEY",
+  "ANTHROPIC_AUTH_TOKEN",
+  "CLAUDE_CODE_OAUTH_TOKEN",
+  "AWS_BEARER_TOKEN_BEDROCK",
+  "ANTHROPIC_FOUNDRY_API_KEY",
+  "CLAUDE_CODE_SKIP_BEDROCK_AUTH",
+  "CLAUDE_CODE_SKIP_VERTEX_AUTH",
+  "CLAUDE_CODE_SKIP_FOUNDRY_AUTH",
+  "ANTHROPIC_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL_SUPPORTED_CAPABILITIES",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL_NAME",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL_SUPPORTED_CAPABILITIES",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL_NAME",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL_SUPPORTED_CAPABILITIES",
+  "ANTHROPIC_SMALL_FAST_MODEL",
+  "ANTHROPIC_SMALL_FAST_MODEL_AWS_REGION",
+  "CLAUDE_CODE_SUBAGENT_MODEL"
+]);
+var PROVIDER_MANAGED_ENV_PREFIXES = [
+  "VERTEX_REGION_CLAUDE_"
+];
+function isProviderManagedEnvVar(key) {
+  const upper = key.toUpperCase();
+  return PROVIDER_MANAGED_ENV_VARS.has(upper) || PROVIDER_MANAGED_ENV_PREFIXES.some((p) => upper.startsWith(p));
+}
+var SAFE_ENV_VARS = new Set([
+  "ANTHROPIC_CUSTOM_HEADERS",
+  "ANTHROPIC_CUSTOM_MODEL_OPTION",
+  "ANTHROPIC_CUSTOM_MODEL_OPTION_DESCRIPTION",
+  "ANTHROPIC_CUSTOM_MODEL_OPTION_NAME",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL_DESCRIPTION",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL_NAME",
+  "ANTHROPIC_DEFAULT_HAIKU_MODEL_SUPPORTED_CAPABILITIES",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL_DESCRIPTION",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL_NAME",
+  "ANTHROPIC_DEFAULT_OPUS_MODEL_SUPPORTED_CAPABILITIES",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL_DESCRIPTION",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL_NAME",
+  "ANTHROPIC_DEFAULT_SONNET_MODEL_SUPPORTED_CAPABILITIES",
+  "ANTHROPIC_FOUNDRY_API_KEY",
+  "ANTHROPIC_MODEL",
+  "ANTHROPIC_SMALL_FAST_MODEL_AWS_REGION",
+  "ANTHROPIC_SMALL_FAST_MODEL",
+  "AWS_DEFAULT_REGION",
+  "AWS_PROFILE",
+  "AWS_REGION",
+  "BASH_DEFAULT_TIMEOUT_MS",
+  "BASH_MAX_OUTPUT_LENGTH",
+  "BASH_MAX_TIMEOUT_MS",
+  "CLAUDE_BASH_MAINTAIN_PROJECT_WORKING_DIR",
+  "CLAUDE_CODE_API_KEY_HELPER_TTL_MS",
+  "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
+  "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC",
+  "CLAUDE_CODE_DISABLE_TERMINAL_TITLE",
+  "CLAUDE_CODE_ENABLE_TELEMETRY",
+  "CLAUDE_CODE_EXPERIMENTAL_AGENT_TEAMS",
+  "CLAUDE_CODE_IDE_SKIP_AUTO_INSTALL",
+  "CLAUDE_CODE_MAX_OUTPUT_TOKENS",
+  "CLAUDE_CODE_SKIP_BEDROCK_AUTH",
+  "CLAUDE_CODE_SKIP_FOUNDRY_AUTH",
+  "CLAUDE_CODE_SKIP_VERTEX_AUTH",
+  "CLAUDE_CODE_SUBAGENT_MODEL",
+  "CLAUDE_CODE_USE_BEDROCK",
+  "CLAUDE_CODE_USE_FOUNDRY",
+  "CLAUDE_CODE_USE_VERTEX",
+  "DISABLE_AUTOUPDATER",
+  "DISABLE_BUG_COMMAND",
+  "DISABLE_COST_WARNINGS",
+  "DISABLE_ERROR_REPORTING",
+  "DISABLE_FEEDBACK_COMMAND",
+  "DISABLE_TELEMETRY",
+  "ENABLE_TOOL_SEARCH",
+  "MAX_MCP_OUTPUT_TOKENS",
+  "MAX_THINKING_TOKENS",
+  "MCP_TIMEOUT",
+  "MCP_TOOL_TIMEOUT",
+  "OTEL_EXPORTER_OTLP_HEADERS",
+  "OTEL_EXPORTER_OTLP_LOGS_HEADERS",
+  "OTEL_EXPORTER_OTLP_LOGS_PROTOCOL",
+  "OTEL_EXPORTER_OTLP_METRICS_CLIENT_CERTIFICATE",
+  "OTEL_EXPORTER_OTLP_METRICS_CLIENT_KEY",
+  "OTEL_EXPORTER_OTLP_METRICS_HEADERS",
+  "OTEL_EXPORTER_OTLP_METRICS_PROTOCOL",
+  "OTEL_EXPORTER_OTLP_PROTOCOL",
+  "OTEL_EXPORTER_OTLP_TRACES_HEADERS",
+  "OTEL_LOG_TOOL_DETAILS",
+  "OTEL_LOG_USER_PROMPTS",
+  "OTEL_LOGS_EXPORT_INTERVAL",
+  "OTEL_LOGS_EXPORTER",
+  "OTEL_METRIC_EXPORT_INTERVAL",
+  "OTEL_METRICS_EXPORTER",
+  "OTEL_METRICS_INCLUDE_ACCOUNT_UUID",
+  "OTEL_METRICS_INCLUDE_SESSION_ID",
+  "OTEL_METRICS_INCLUDE_VERSION",
+  "OTEL_RESOURCE_ATTRIBUTES",
+  "USE_BUILTIN_RIPGREP",
+  "VERTEX_REGION_CLAUDE_3_5_HAIKU",
+  "VERTEX_REGION_CLAUDE_3_5_SONNET",
+  "VERTEX_REGION_CLAUDE_3_7_SONNET",
+  "VERTEX_REGION_CLAUDE_4_0_OPUS",
+  "VERTEX_REGION_CLAUDE_4_0_SONNET",
+  "VERTEX_REGION_CLAUDE_4_1_OPUS",
+  "VERTEX_REGION_CLAUDE_4_5_SONNET",
+  "VERTEX_REGION_CLAUDE_4_6_SONNET",
+  "VERTEX_REGION_CLAUDE_HAIKU_4_5"
+]);
+
+export { isProviderManagedEnvVar, SAFE_ENV_VARS };

package/dist/chunk-x97w78sk.js

@@ -0,0 +1,184 @@
+// @bun
+import {
+  Select,
+  init_CustomSelect
+} from "./chunk-fyrdmq8b.js";
+import {
+  Dialog,
+  init_Dialog
+} from "./chunk-y1qx0711.js";
+import {
+  ThemedText,
+  init_ink,
+  require_compiler_runtime
+} from "./chunk-y5patg9p.js";
+import {
+  require_jsx_dev_runtime
+} from "./chunk-b95s01h5.js";
+import {
+  init_config1 as init_config,
+  saveGlobalConfig
+} from "./chunk-a07hgnvm.js";
+import {
+  __toESM
+} from "./chunk-hhsxm2yr.js";
+
+// src/components/ApproveApiKey.tsx
+init_ink();
+init_config();
+init_CustomSelect();
+init_Dialog();
+var import_compiler_runtime = __toESM(require_compiler_runtime(), 1);
+var jsx_dev_runtime = __toESM(require_jsx_dev_runtime(), 1);
+function ApproveApiKey(t0) {
+  const $ = import_compiler_runtime.c(17);
+  const {
+    customApiKeyTruncated,
+    onDone
+  } = t0;
+  let t1;
+  if ($[0] !== customApiKeyTruncated || $[1] !== onDone) {
+    t1 = function onChange2(value) {
+      bb2:
+        switch (value) {
+          case "yes": {
+            saveGlobalConfig((current_0) => ({
+              ...current_0,
+              customApiKeyResponses: {
+                ...current_0.customApiKeyResponses,
+                approved: [...current_0.customApiKeyResponses?.approved ?? [], customApiKeyTruncated]
+              }
+            }));
+            onDone(true);
+            break bb2;
+          }
+          case "no": {
+            saveGlobalConfig((current) => ({
+              ...current,
+              customApiKeyResponses: {
+                ...current.customApiKeyResponses,
+                rejected: [...current.customApiKeyResponses?.rejected ?? [], customApiKeyTruncated]
+              }
+            }));
+            onDone(false);
+          }
+        }
+    };
+    $[0] = customApiKeyTruncated;
+    $[1] = onDone;
+    $[2] = t1;
+  } else {
+    t1 = $[2];
+  }
+  const onChange = t1;
+  let t2;
+  if ($[3] !== onChange) {
+    t2 = () => onChange("no");
+    $[3] = onChange;
+    $[4] = t2;
+  } else {
+    t2 = $[4];
+  }
+  let t3;
+  if ($[5] === Symbol.for("react.memo_cache_sentinel")) {
+    t3 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      bold: true,
+      children: "ANTHROPIC_API_KEY"
+    }, undefined, false, undefined, this);
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  let t4;
+  if ($[6] !== customApiKeyTruncated) {
+    t4 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      children: [
+        t3,
+        /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+          children: [
+            ": sk-ant-...",
+            customApiKeyTruncated
+          ]
+        }, undefined, true, undefined, this)
+      ]
+    }, undefined, true, undefined, this);
+    $[6] = customApiKeyTruncated;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  let t5;
+  if ($[8] === Symbol.for("react.memo_cache_sentinel")) {
+    t5 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+      children: "Do you want to use this API key?"
+    }, undefined, false, undefined, this);
+    $[8] = t5;
+  } else {
+    t5 = $[8];
+  }
+  let t6;
+  if ($[9] === Symbol.for("react.memo_cache_sentinel")) {
+    t6 = {
+      label: "Yes",
+      value: "yes"
+    };
+    $[9] = t6;
+  } else {
+    t6 = $[9];
+  }
+  let t7;
+  if ($[10] === Symbol.for("react.memo_cache_sentinel")) {
+    t7 = [t6, {
+      label: /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+        children: [
+          "No (",
+          /* @__PURE__ */ jsx_dev_runtime.jsxDEV(ThemedText, {
+            bold: true,
+            children: "recommended"
+          }, undefined, false, undefined, this),
+          ")"
+        ]
+      }, undefined, true, undefined, this),
+      value: "no"
+    }];
+    $[10] = t7;
+  } else {
+    t7 = $[10];
+  }
+  let t8;
+  if ($[11] !== onChange) {
+    t8 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Select, {
+      defaultValue: "no",
+      defaultFocusValue: "no",
+      options: t7,
+      onChange: (value_0) => onChange(value_0),
+      onCancel: () => onChange("no")
+    }, undefined, false, undefined, this);
+    $[11] = onChange;
+    $[12] = t8;
+  } else {
+    t8 = $[12];
+  }
+  let t9;
+  if ($[13] !== t2 || $[14] !== t4 || $[15] !== t8) {
+    t9 = /* @__PURE__ */ jsx_dev_runtime.jsxDEV(Dialog, {
+      title: "Detected a custom API key in your environment",
+      color: "warning",
+      onCancel: t2,
+      children: [
+        t4,
+        t5,
+        t8
+      ]
+    }, undefined, true, undefined, this);
+    $[13] = t2;
+    $[14] = t4;
+    $[15] = t8;
+    $[16] = t9;
+  } else {
+    t9 = $[16];
+  }
+  return t9;
+}
+
+export { ApproveApiKey };

package/dist/chunk-xbawq95y.js

@@ -0,0 +1,54 @@
+// @bun
+import {
+  __commonJS
+} from "./chunk-hhsxm2yr.js";
+
+// node_modules/.bun/@aws-sdk+core@3.973.26/node_modules/@aws-sdk/core/dist-cjs/submodules/client/index.js
+var require_client = __commonJS((exports) => {
+  var state = {
+    warningEmitted: false
+  };
+  var emitWarningIfUnsupportedVersion = (version) => {
+    if (version && !state.warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 20) {
+      state.warningEmitted = true;
+      process.emitWarning(`NodeDeprecationWarning: The AWS SDK for JavaScript (v3) will
+no longer support Node.js ${version} in January 2026.
+
+To continue receiving updates to AWS services, bug fixes, and security
+updates please upgrade to a supported Node.js LTS version.
+
+More information can be found at: https://a.co/c895JFp`);
+    }
+  };
+  function setCredentialFeature(credentials, feature, value) {
+    if (!credentials.$source) {
+      credentials.$source = {};
+    }
+    credentials.$source[feature] = value;
+    return credentials;
+  }
+  function setFeature(context, feature, value) {
+    if (!context.__aws_sdk_context) {
+      context.__aws_sdk_context = {
+        features: {}
+      };
+    } else if (!context.__aws_sdk_context.features) {
+      context.__aws_sdk_context.features = {};
+    }
+    context.__aws_sdk_context.features[feature] = value;
+  }
+  function setTokenFeature(token, feature, value) {
+    if (!token.$source) {
+      token.$source = {};
+    }
+    token.$source[feature] = value;
+    return token;
+  }
+  exports.emitWarningIfUnsupportedVersion = emitWarningIfUnsupportedVersion;
+  exports.setCredentialFeature = setCredentialFeature;
+  exports.setFeature = setFeature;
+  exports.setTokenFeature = setTokenFeature;
+  exports.state = state;
+});
+
+export { require_client };