@qwen-code/qwen-code 0.23.5-dev.codemode-responses.20260915.f024b37689 → 0.23.5-preview.0

package/chunks/chunk-TPEV2QHG.js

@@ -1,514 +0,0 @@
-// Force strict mode and setup for ESM
-"use strict";
-import {
-  preloadRuntimeFetchModule
-} from "./chunk-EWJTAP3Y.js";
-import {
-  init_esbuild_shims
-} from "./chunk-5O2XNYP6.js";
-import {
-  __name
-} from "./chunk-J2S4EL5Y.js";
-
-// packages/core/src/utils/default-qwen-model.ts
-init_esbuild_shims();
-var DEFAULT_QWEN_MODEL = "coder-model";
-
-// packages/core/src/models/modelConfigErrors.ts
-init_esbuild_shims();
-function getDefaultApiKeyEnvVar(authType) {
-  switch (authType) {
-    case "openai":
-    case "openai-responses":
-      return "OPENAI_API_KEY";
-    case "anthropic":
-      return "ANTHROPIC_API_KEY";
-    case "gemini":
-      return "GEMINI_API_KEY";
-    case "vertex-ai":
-      return "GOOGLE_API_KEY";
-    default:
-      return "API_KEY";
-  }
-}
-__name(getDefaultApiKeyEnvVar, "getDefaultApiKeyEnvVar");
-function getDefaultModelEnvVar(authType) {
-  switch (authType) {
-    case "openai":
-    case "openai-responses":
-      return "OPENAI_MODEL";
-    case "anthropic":
-      return "ANTHROPIC_MODEL";
-    case "gemini":
-      return "GEMINI_MODEL";
-    case "vertex-ai":
-      return "GOOGLE_MODEL";
-    default:
-      return "MODEL";
-  }
-}
-__name(getDefaultModelEnvVar, "getDefaultModelEnvVar");
-var VERTEX_ADC_HINT = " Alternatively, set GOOGLE_CLOUD_PROJECT to authenticate with Application Default Credentials instead of an API key.";
-function adcHint(authType, explicitEnvKey) {
-  return authType === "vertex-ai" && !explicitEnvKey ? VERTEX_ADC_HINT : "";
-}
-__name(adcHint, "adcHint");
-var ModelConfigError = class extends Error {
-  static {
-    __name(this, "ModelConfigError");
-  }
-  constructor(message) {
-    super(message);
-    this.name = new.target.name;
-    Object.setPrototypeOf(this, new.target.prototype);
-  }
-};
-var StrictMissingCredentialsError = class extends ModelConfigError {
-  static {
-    __name(this, "StrictMissingCredentialsError");
-  }
-  code = "STRICT_MISSING_CREDENTIALS";
-  constructor(authType, model, envKey) {
-    const providerKey = authType || "(unknown)";
-    const modelName = model || "(unknown)";
-    super(
-      `Missing credentials for modelProviders model '${modelName}'. ` + (envKey ? `Current configured envKey: '${envKey}'. Set that environment variable, or update modelProviders.${providerKey}[].envKey.` : `Configure modelProviders.${providerKey}[].envKey and set that environment variable.`) + adcHint(authType, envKey)
-    );
-  }
-};
-var StrictMissingModelIdError = class extends ModelConfigError {
-  static {
-    __name(this, "StrictMissingModelIdError");
-  }
-  code = "STRICT_MISSING_MODEL_ID";
-  constructor(authType) {
-    super(
-      `Missing model id for strict modelProviders resolution (authType: ${authType}).`
-    );
-  }
-};
-var MissingApiKeyError = class extends ModelConfigError {
-  static {
-    __name(this, "MissingApiKeyError");
-  }
-  code = "MISSING_API_KEY";
-  constructor(params) {
-    super(
-      `Missing API key for ${params.authType} auth. Current model: '${params.model || "(unknown)"}', baseUrl: '${params.baseUrl || "(default)"}'. Provide an API key via settings (security.auth.apiKey), or set the environment variable '${params.envKey}'.` + adcHint(params.authType, params.explicitEnvKey)
-    );
-  }
-};
-var MissingModelError = class extends ModelConfigError {
-  static {
-    __name(this, "MissingModelError");
-  }
-  code = "MISSING_MODEL";
-  constructor(params) {
-    super(
-      `Missing model for ${params.authType} auth. Set the environment variable '${params.envKey}'.`
-    );
-  }
-};
-var MissingBaseUrlError = class extends ModelConfigError {
-  static {
-    __name(this, "MissingBaseUrlError");
-  }
-  code = "MISSING_BASE_URL";
-  constructor(params) {
-    super(
-      `Missing baseUrl for modelProviders model '${params.model || "(unknown)"}'. Configure modelProviders.${params.authType || "(unknown)"}[].baseUrl.`
-    );
-  }
-};
-var MissingAnthropicBaseUrlEnvError = class extends ModelConfigError {
-  static {
-    __name(this, "MissingAnthropicBaseUrlEnvError");
-  }
-  code = "MISSING_ANTHROPIC_BASE_URL_ENV";
-  constructor() {
-    super("ANTHROPIC_BASE_URL environment variable not found.");
-  }
-};
-
-// packages/core/src/config/models.ts
-init_esbuild_shims();
-var DEFAULT_QWEN_EMBEDDING_MODEL = "text-embedding-v4";
-var MAINLINE_CODER_MODEL = "qwen3.7-max";
-
-// packages/core/src/models/constants.ts
-init_esbuild_shims();
-var MODEL_GENERATION_CONFIG_FIELDS = [
-  "samplingParams",
-  "timeout",
-  "streamIdleTimeoutMs",
-  "maxRetries",
-  "retryInitialDelayMs",
-  "retryMaxDelayMs",
-  "retryErrorCodes",
-  "enableCacheControl",
-  "enableRequestMetadata",
-  "forceGlobalCacheScope",
-  "cacheRetention",
-  "cacheRetentionByBlock",
-  "schemaCompliance",
-  "reasoning",
-  "contextWindowSize",
-  "customHeaders",
-  "extra_body",
-  "thinkingMandatory",
-  "modalities",
-  "splitToolMedia",
-  "toolResultContentFormat"
-];
-var CREDENTIAL_FIELDS = [
-  "model",
-  "apiKey",
-  "apiKeyEnvKey",
-  "baseUrl"
-];
-var PROVIDER_SOURCED_FIELDS = [
-  ...CREDENTIAL_FIELDS,
-  ...MODEL_GENERATION_CONFIG_FIELDS
-];
-var AUTH_ENV_MAPPINGS = {
-  openai: {
-    apiKey: ["OPENAI_API_KEY"],
-    baseUrl: ["OPENAI_BASE_URL"],
-    model: ["OPENAI_MODEL", "QWEN_MODEL"]
-  },
-  "openai-responses": {
-    apiKey: ["OPENAI_API_KEY"],
-    baseUrl: ["OPENAI_BASE_URL"],
-    model: ["OPENAI_MODEL"]
-  },
-  anthropic: {
-    apiKey: ["ANTHROPIC_API_KEY"],
-    baseUrl: ["ANTHROPIC_BASE_URL"],
-    model: ["ANTHROPIC_MODEL"]
-  },
-  gemini: {
-    apiKey: ["GEMINI_API_KEY"],
-    baseUrl: [],
-    model: ["GEMINI_MODEL"]
-  },
-  "vertex-ai": {
-    apiKey: ["GOOGLE_API_KEY"],
-    baseUrl: [],
-    model: ["GOOGLE_MODEL"]
-  },
-  "qwen-oauth": {
-    apiKey: [],
-    baseUrl: [],
-    model: []
-  }
-};
-var DEFAULT_MODELS = {
-  openai: MAINLINE_CODER_MODEL,
-  "qwen-oauth": DEFAULT_QWEN_MODEL
-};
-var QWEN_OAUTH_MODELS = [
-  {
-    id: "coder-model",
-    name: "coder-model",
-    description: "Qwen 3.7 Max \u2014 efficient hybrid model with leading coding performance",
-    capabilities: { vision: true }
-  }
-];
-var QWEN_OAUTH_ALLOWED_MODELS = QWEN_OAUTH_MODELS.map(
-  (model) => model.id
-);
-
-// packages/core/src/core/contentGenerator.ts
-init_esbuild_shims();
-function setSource(sources, path, source) {
-  sources[path] = source;
-}
-__name(setSource, "setSource");
-function getSeedSource(seed, path) {
-  return seed?.[path];
-}
-__name(getSeedSource, "getSeedSource");
-function resolveContentGeneratorConfigWithSources(config, authType, generationConfig, seedSources, options) {
-  const sources = { ...seedSources || {} };
-  const strictModelProvider = options?.strictModelProvider === true;
-  const newContentGeneratorConfig = {
-    ...generationConfig || {},
-    authType,
-    proxy: config?.getProxy()
-  };
-  setSource(sources, "authType", {
-    kind: "computed",
-    detail: "provided by caller"
-  });
-  if (config?.getProxy()) {
-    setSource(sources, "proxy", {
-      kind: "computed",
-      detail: "Config.getProxy()"
-    });
-  }
-  const seedOrUnknown = /* @__PURE__ */ __name((path) => getSeedSource(seedSources, path) ?? { kind: "unknown" }, "seedOrUnknown");
-  for (const field of PROVIDER_SOURCED_FIELDS) {
-    if (generationConfig && field in generationConfig && !sources[field]) {
-      setSource(sources, field, seedOrUnknown(field));
-    }
-  }
-  const validation = validateModelConfig(
-    newContentGeneratorConfig,
-    strictModelProvider
-  );
-  if (!validation.valid) {
-    throw new Error(validation.errors.map((e) => e.message).join("\n"));
-  }
-  return {
-    config: newContentGeneratorConfig,
-    sources
-  };
-}
-__name(resolveContentGeneratorConfigWithSources, "resolveContentGeneratorConfigWithSources");
-var VERTEX_PROJECT_ENV_VAR = "GOOGLE_CLOUD_PROJECT";
-function hasVertexProjectConfigured(lookup = (key) => process.env[key]) {
-  return !!lookup(VERTEX_PROJECT_ENV_VAR)?.trim();
-}
-__name(hasVertexProjectConfigured, "hasVertexProjectConfigured");
-function usesVertexApplicationDefaultCredentials(config) {
-  return config.authType === "vertex-ai" /* USE_VERTEX_AI */ && !config.apiKeyEnvKey && hasVertexProjectConfigured();
-}
-__name(usesVertexApplicationDefaultCredentials, "usesVertexApplicationDefaultCredentials");
-function validateModelConfig(config, isStrictModelProvider = false) {
-  const errors = [];
-  if (config.authType === "qwen-oauth" /* QWEN_OAUTH */) {
-    return { valid: true, errors: [] };
-  }
-  if (!config.apiKey && !usesVertexApplicationDefaultCredentials(config)) {
-    if (isStrictModelProvider) {
-      errors.push(
-        new StrictMissingCredentialsError(
-          config.authType,
-          config.model,
-          config.apiKeyEnvKey
-        )
-      );
-    } else {
-      const envKey = config.apiKeyEnvKey || getDefaultApiKeyEnvVar(config.authType);
-      errors.push(
-        new MissingApiKeyError({
-          authType: config.authType,
-          model: config.model,
-          baseUrl: config.baseUrl,
-          envKey,
-          explicitEnvKey: config.apiKeyEnvKey
-        })
-      );
-    }
-  }
-  if (!config.model) {
-    if (isStrictModelProvider) {
-      errors.push(new StrictMissingModelIdError(config.authType));
-    } else {
-      const envKey = getDefaultModelEnvVar(config.authType);
-      errors.push(new MissingModelError({ authType: config.authType, envKey }));
-    }
-  }
-  if (config.authType === "anthropic" /* USE_ANTHROPIC */ && !config.baseUrl) {
-    if (isStrictModelProvider) {
-      errors.push(
-        new MissingBaseUrlError({
-          authType: config.authType,
-          model: config.model
-        })
-      );
-    } else if (config.authType === "anthropic" /* USE_ANTHROPIC */) {
-      errors.push(new MissingAnthropicBaseUrlEnvError());
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-__name(validateModelConfig, "validateModelConfig");
-function getModuleNotFoundError(error) {
-  let current = error;
-  while (current instanceof Error) {
-    if ("code" in current && current.code === "ERR_MODULE_NOT_FOUND") {
-      return current;
-    }
-    current = current.cause;
-  }
-  return void 0;
-}
-__name(getModuleNotFoundError, "getModuleNotFoundError");
-function wrapProviderLoadError(error, authType) {
-  const moduleNotFoundError = getModuleNotFoundError(error);
-  if (!moduleNotFoundError) {
-    return error;
-  }
-  return new Error(
-    `Qwen Code was updated in the background and needs to be restarted.
-Please exit and restart Qwen Code to use the '${authType}' provider.`,
-    { cause: moduleNotFoundError }
-  );
-}
-__name(wrapProviderLoadError, "wrapProviderLoadError");
-var LazyContentGenerator = class {
-  constructor(loader) {
-    this.loader = loader;
-  }
-  static {
-    __name(this, "LazyContentGenerator");
-  }
-  generatorPromise;
-  preloadedOnly = false;
-  getGenerator() {
-    this.generatorPromise ??= this.loader();
-    return this.generatorPromise;
-  }
-  getGeneratorForUse() {
-    this.preloadedOnly = false;
-    return this.getGenerator();
-  }
-  preload() {
-    if (!this.generatorPromise) {
-      this.preloadedOnly = true;
-    }
-    return this.getGenerator();
-  }
-  resetPreload() {
-    if (!this.preloadedOnly) return;
-    this.preloadedOnly = false;
-    this.generatorPromise = void 0;
-  }
-  async generateContent(request, userPromptId) {
-    return (await this.getGeneratorForUse()).generateContent(
-      request,
-      userPromptId
-    );
-  }
-  async generateContentStream(request, userPromptId) {
-    return (await this.getGeneratorForUse()).generateContentStream(
-      request,
-      userPromptId
-    );
-  }
-  async embedContent(request) {
-    return (await this.getGeneratorForUse()).embedContent(request);
-  }
-};
-async function preloadContentGenerator(generator) {
-  if (generator instanceof LazyContentGenerator) {
-    await generator.preload();
-  }
-}
-__name(preloadContentGenerator, "preloadContentGenerator");
-function resetPreloadedContentGenerator(generator) {
-  if (generator instanceof LazyContentGenerator) {
-    generator.resetPreload();
-  }
-}
-__name(resetPreloadedContentGenerator, "resetPreloadedContentGenerator");
-async function createContentGenerator(generatorConfig, config, isInitialAuth) {
-  const validation = validateModelConfig(generatorConfig, false);
-  if (!validation.valid) {
-    throw new Error(validation.errors.map((e) => e.message).join("\n"));
-  }
-  const authType = generatorConfig.authType;
-  if (!authType) {
-    throw new Error("ContentGeneratorConfig must have an authType");
-  }
-  await preloadRuntimeFetchModule();
-  let loadBaseGenerator;
-  try {
-    if (authType === "openai" /* USE_OPENAI */) {
-      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-5J73W5XZ.js");
-        return createOpenAIContentGenerator(generatorConfig, config);
-      }, "loadBaseGenerator");
-    } else if (authType === "openai-responses" /* USE_OPENAI_RESPONSES */) {
-      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createOpenAIResponsesContentGenerator } = await import("./openaiResponsesContentGenerator-AWRYZLJU.js");
-        return createOpenAIResponsesContentGenerator(generatorConfig, config);
-      }, "loadBaseGenerator");
-    } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
-      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-WIEUEFEY.js");
-      try {
-        const qwenClient = await getQwenOauthClient(
-          config,
-          isInitialAuth ? { requireCachedCredentials: true } : void 0
-        );
-        loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-          const { QwenContentGenerator } = await import("./qwenContentGenerator-H5AAKXPC.js");
-          return new QwenContentGenerator(qwenClient, generatorConfig, config);
-        }, "loadBaseGenerator");
-      } catch (error) {
-        if (getModuleNotFoundError(error)) {
-          throw error;
-        }
-        throw new Error(error instanceof Error ? error.message : String(error));
-      }
-    } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
-      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-H5YPXIDE.js");
-        return createAnthropicContentGenerator(generatorConfig, config);
-      }, "loadBaseGenerator");
-    } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
-      loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createLlmContentGenerator } = await import("./llm-content-generator-CG2HRJZC.js");
-        return createLlmContentGenerator(generatorConfig, config);
-      }, "loadBaseGenerator");
-    } else {
-      throw new Error(
-        `Error creating contentGenerator: Unsupported authType: ${authType}`
-      );
-    }
-  } catch (error) {
-    throw wrapProviderLoadError(error, authType);
-  }
-  return new LazyContentGenerator(async () => {
-    try {
-      const [baseGenerator, { LoggingContentGenerator }] = await Promise.all([
-        loadBaseGenerator(),
-        import("./loggingContentGenerator-TUL6SJVL.js")
-      ]);
-      return new LoggingContentGenerator(
-        baseGenerator,
-        config,
-        generatorConfig
-      );
-    } catch (error) {
-      throw wrapProviderLoadError(error, authType);
-    }
-  });
-}
-__name(createContentGenerator, "createContentGenerator");
-
-export {
-  DEFAULT_QWEN_MODEL,
-  getDefaultApiKeyEnvVar,
-  VERTEX_ADC_HINT,
-  DEFAULT_QWEN_EMBEDDING_MODEL,
-  MAINLINE_CODER_MODEL,
-  MODEL_GENERATION_CONFIG_FIELDS,
-  PROVIDER_SOURCED_FIELDS,
-  AUTH_ENV_MAPPINGS,
-  DEFAULT_MODELS,
-  QWEN_OAUTH_MODELS,
-  QWEN_OAUTH_ALLOWED_MODELS,
-  resolveContentGeneratorConfigWithSources,
-  hasVertexProjectConfigured,
-  preloadContentGenerator,
-  resetPreloadedContentGenerator,
-  createContentGenerator
-};
-/**
- * @license
- * Copyright 2025 Google LLC
- * Copyright 2026 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */

package/chunks/chunk-YVWS4SLL.js

@@ -1,137 +0,0 @@
-// Force strict mode and setup for ESM
-"use strict";
-import {
-  mapSkillConfigToStatus
-} from "./chunk-ZJ7JQUGY.js";
-import {
-  resolveSkillSettings
-} from "./chunk-LMJSPC55.js";
-import {
-  STATUS_SCHEMA_VERSION
-} from "./chunk-54B2LTKP.js";
-import {
-  loadSettings
-} from "./chunk-E7ZTAOJZ.js";
-import {
-  SkillManager,
-  isSafeModeEnv
-} from "./chunk-WBP64MZR.js";
-import {
-  writeStderrLine
-} from "./chunk-7FA2II6K.js";
-import {
-  init_esbuild_shims
-} from "./chunk-5O2XNYP6.js";
-import {
-  __name
-} from "./chunk-J2S4EL5Y.js";
-
-// packages/cli/src/serve/workspace-skills-status.ts
-init_esbuild_shims();
-import * as fs from "node:fs/promises";
-var VALID_SKILL_LEVELS = /* @__PURE__ */ new Set([
-  "project",
-  "user",
-  "extension",
-  "bundled"
-]);
-function createWorkspaceSkillsStatusProvider(options = {}) {
-  const managers = /* @__PURE__ */ new Map();
-  const provider = /* @__PURE__ */ __name((workspaceCwd) => buildWorkspaceSkillsStatus(
-    workspaceCwd,
-    managers,
-    options.workspaceTrusted ?? true,
-    options.includeUntrustedSkills ?? false
-  ), "provider");
-  provider.invalidate = (workspaceCwd) => managers.delete(workspaceCwd);
-  return provider;
-}
-__name(createWorkspaceSkillsStatusProvider, "createWorkspaceSkillsStatusProvider");
-async function buildWorkspaceSkillsStatus(workspaceCwd, managers, workspaceTrusted, includeUntrustedSkills) {
-  try {
-    const settings = loadSettings(workspaceCwd, {
-      consumeCorruptionEnvVars: false,
-      skipLoadEnvironment: true,
-      skipWorkspaceSettings: !workspaceTrusted,
-      workspaceTrusted
-    });
-    let skillManager = managers.get(workspaceCwd);
-    if (!skillManager) {
-      const rawLevels = !workspaceTrusted || isSafeModeEnv() ? void 0 : settings.merged.skills?.disabledLevels;
-      const disabledLevels = new Set(
-        Array.isArray(rawLevels) ? rawLevels.filter(
-          (v) => typeof v === "string" && VALID_SKILL_LEVELS.has(v)
-        ) : []
-      );
-      const safeMode = !workspaceTrusted && !includeUntrustedSkills || isSafeModeEnv();
-      const shim = {
-        // Honor the safe-mode env the same way `Config` does when no explicit
-        // flag is passed, so an operator running in safe mode gets the same
-        // bundled-only listing the child would produce.
-        isSafeMode: /* @__PURE__ */ __name(() => safeMode, "isSafeMode"),
-        // Bare mode is the interactive `--bare` CLI flag; the daemon never runs
-        // bare, so it is always off here.
-        getBareMode: /* @__PURE__ */ __name(() => false, "getBareMode"),
-        getProjectRoot: /* @__PURE__ */ __name(() => workspaceCwd, "getProjectRoot"),
-        // Extension skills need active-extension context that only the child
-        // has; omit them here and let the session snapshot surface them.
-        getActiveExtensions: /* @__PURE__ */ __name(() => [], "getActiveExtensions"),
-        getDisabledSkillLevels: /* @__PURE__ */ __name(() => disabledLevels, "getDisabledSkillLevels")
-      };
-      skillManager = new SkillManager(shim);
-      if (!safeMode) {
-        for (const level of ["project", "user"]) {
-          if (disabledLevels.has(level)) continue;
-          for (const directory of skillManager.getSkillsBaseDirs(level)) {
-            try {
-              await fs.readdir(directory);
-            } catch (error) {
-              if (error.code !== "ENOENT") {
-                throw error;
-              }
-            }
-          }
-        }
-      }
-      managers.set(workspaceCwd, skillManager);
-    }
-    const disablements = resolveSkillSettings(settings).disablements;
-    const skills = await skillManager.listSkills();
-    return {
-      v: STATUS_SCHEMA_VERSION,
-      workspaceCwd,
-      initialized: true,
-      skills: skills.map(
-        (skill) => mapSkillConfigToStatus(skill, disablements)
-      )
-    };
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    writeStderrLine(
-      `qwen serve: daemon-local skills enumeration failed for ${workspaceCwd}: ${message}`
-    );
-    return {
-      v: STATUS_SCHEMA_VERSION,
-      workspaceCwd,
-      initialized: false,
-      skills: [],
-      errors: [
-        {
-          kind: "skills",
-          status: "error",
-          error: message
-        }
-      ]
-    };
-  }
-}
-__name(buildWorkspaceSkillsStatus, "buildWorkspaceSkillsStatus");
-
-export {
-  createWorkspaceSkillsStatusProvider
-};
-/**
- * @license
- * Copyright 2025 Qwen Team
- * SPDX-License-Identifier: Apache-2.0
- */

package/web-shell/assets/channel-DSQQnOZj.js

@@ -1 +0,0 @@
-import{U as a,C as n}from"./mermaid.core-jggSxF1i.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/web-shell/assets/classDiagram-DTDB5LWJ-V94ta08R.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-LCL6LL3I-CoShjpX7.js";import{_ as i}from"./mermaid.core-jggSxF1i.js";import"./chunk-5VM5RSS4-C_IzCGeA.js";import"./chunk-XXDRQBXY-BQSQv30h.js";import"./chunk-POPQ4Y6H-BwRmCDSz.js";import"./chunk-F27PBJKO-C25NZOyD.js";import"./index-H8um-iEl.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/web-shell/assets/classDiagram-v2-JRS7N3AN-V94ta08R.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-LCL6LL3I-CoShjpX7.js";import{_ as i}from"./mermaid.core-jggSxF1i.js";import"./chunk-5VM5RSS4-C_IzCGeA.js";import"./chunk-XXDRQBXY-BQSQv30h.js";import"./chunk-POPQ4Y6H-BwRmCDSz.js";import"./chunk-F27PBJKO-C25NZOyD.js";import"./index-H8um-iEl.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};