web-core-tcm 0.0.59 → 0.0.62

package/dist/node_modules/zrender/lib/zrender.js

@@ -0,0 +1,129 @@
+import p from "./core/env.js";
+import { guid as S, keys as H, retrieve2 as A } from "./core/util.js";
+import D from "./Handler.js";
+import k from "./Storage.js";
+import w, { getTime as c } from "./animation/Animation.js";
+import M from "./dom/HandlerProxy.js";
+import { lum as m } from "./tool/color.js";
+import { DARK_MODE_THRESHOLD as _ } from "./config.js";
+import z from "./graphic/Group.js";
+var n = {}, y = {};
+function F(t) {
+  delete y[t];
+}
+function P(t) {
+  if (!t)
+    return !1;
+  if (typeof t == "string")
+    return m(t, 1) < _;
+  if (t.colorStops) {
+    for (var e = t.colorStops, r = 0, i = e.length, s = 0; s < i; s++)
+      r += m(e[s].color, 1);
+    return r /= i, r < _;
+  }
+  return !1;
+}
+var T = (function() {
+  function t(e, r, i) {
+    var s = this;
+    this._sleepAfterStill = 10, this._stillFrameAccum = 0, this._needsRefresh = !0, this._needsRefreshHover = !0, this._darkMode = !1, i = i || {}, this.dom = r, this.id = e;
+    var h = new k(), a = i.renderer || "canvas";
+    n[a] || (a = H(n)[0]), i.useDirtyRect = i.useDirtyRect == null ? !1 : i.useDirtyRect;
+    var o = new n[a](r, h, i, e), f = i.ssr || o.ssrOnly;
+    this.storage = h, this.painter = o;
+    var v = !p.node && !p.worker && !f ? new M(o.getViewportRoot(), o.root) : null, d = i.useCoarsePointer, g = d == null || d === "auto" ? p.touchEventsSupported : !!d, R = 44, l;
+    g && (l = A(i.pointerSize, R)), this.handler = new D(h, o, v, o.root, l), this.animation = new w({
+      stage: {
+        update: f ? null : function() {
+          return s._flush(!0);
+        }
+      }
+    }), f || this.animation.start();
+  }
+  return t.prototype.add = function(e) {
+    this._disposed || !e || (this.storage.addRoot(e), e.addSelfToZr(this), this.refresh());
+  }, t.prototype.remove = function(e) {
+    this._disposed || !e || (this.storage.delRoot(e), e.removeSelfFromZr(this), this.refresh());
+  }, t.prototype.configLayer = function(e, r) {
+    this._disposed || (this.painter.configLayer && this.painter.configLayer(e, r), this.refresh());
+  }, t.prototype.setBackgroundColor = function(e) {
+    this._disposed || (this.painter.setBackgroundColor && this.painter.setBackgroundColor(e), this.refresh(), this._backgroundColor = e, this._darkMode = P(e));
+  }, t.prototype.getBackgroundColor = function() {
+    return this._backgroundColor;
+  }, t.prototype.setDarkMode = function(e) {
+    this._darkMode = e;
+  }, t.prototype.isDarkMode = function() {
+    return this._darkMode;
+  }, t.prototype.refreshImmediately = function(e) {
+    this._disposed || (e || this.animation.update(!0), this._needsRefresh = !1, this.painter.refresh(), this._needsRefresh = !1);
+  }, t.prototype.refresh = function() {
+    this._disposed || (this._needsRefresh = !0, this.animation.start());
+  }, t.prototype.flush = function() {
+    this._disposed || this._flush(!1);
+  }, t.prototype._flush = function(e) {
+    var r, i = c();
+    this._needsRefresh && (r = !0, this.refreshImmediately(e)), this._needsRefreshHover && (r = !0, this.refreshHoverImmediately());
+    var s = c();
+    r ? (this._stillFrameAccum = 0, this.trigger("rendered", {
+      elapsedTime: s - i
+    })) : this._sleepAfterStill > 0 && (this._stillFrameAccum++, this._stillFrameAccum > this._sleepAfterStill && this.animation.stop());
+  }, t.prototype.setSleepAfterStill = function(e) {
+    this._sleepAfterStill = e;
+  }, t.prototype.wakeUp = function() {
+    this._disposed || (this.animation.start(), this._stillFrameAccum = 0);
+  }, t.prototype.refreshHover = function() {
+    this._needsRefreshHover = !0;
+  }, t.prototype.refreshHoverImmediately = function() {
+    this._disposed || (this._needsRefreshHover = !1, this.painter.refreshHover && this.painter.getType() === "canvas" && this.painter.refreshHover());
+  }, t.prototype.resize = function(e) {
+    this._disposed || (e = e || {}, this.painter.resize(e.width, e.height), this.handler.resize());
+  }, t.prototype.clearAnimation = function() {
+    this._disposed || this.animation.clear();
+  }, t.prototype.getWidth = function() {
+    if (!this._disposed)
+      return this.painter.getWidth();
+  }, t.prototype.getHeight = function() {
+    if (!this._disposed)
+      return this.painter.getHeight();
+  }, t.prototype.setCursorStyle = function(e) {
+    this._disposed || this.handler.setCursorStyle(e);
+  }, t.prototype.findHover = function(e, r) {
+    if (!this._disposed)
+      return this.handler.findHover(e, r);
+  }, t.prototype.on = function(e, r, i) {
+    return this._disposed || this.handler.on(e, r, i), this;
+  }, t.prototype.off = function(e, r) {
+    this._disposed || this.handler.off(e, r);
+  }, t.prototype.trigger = function(e, r) {
+    this._disposed || this.handler.trigger(e, r);
+  }, t.prototype.clear = function() {
+    if (!this._disposed) {
+      for (var e = this.storage.getRoots(), r = 0; r < e.length; r++)
+        e[r] instanceof z && e[r].removeSelfFromZr(this);
+      this.storage.delAllRoots(), this.painter.clear();
+    }
+  }, t.prototype.dispose = function() {
+    this._disposed || (this.animation.stop(), this.clear(), this.storage.dispose(), this.painter.dispose(), this.handler.dispose(), this.animation = this.storage = this.painter = this.handler = null, this._disposed = !0, F(this.id));
+  }, t;
+})();
+function W(t, e) {
+  var r = new T(S(), t, e);
+  return y[r.id] = r, r;
+}
+function K(t, e) {
+  n[t] = e;
+}
+var u;
+function U(t) {
+  if (typeof u == "function")
+    return u(t);
+}
+function V(t) {
+  u = t;
+}
+export {
+  U as getElementSSRData,
+  W as init,
+  K as registerPainter,
+  V as registerSSRDataGetter
+};

package/dist/src/api/algorithm/alova/implement/comprehensiveAlgorithm.d.ts

@@ -1,4 +1,5 @@
 import { ComprehensiveAlgorithm } from '../..';
+export declare const comprehensiveAlgorithmService: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>>;
 export declare class AlovaComprehensiveAlgorithm extends ComprehensiveAlgorithm {
     static comprehensiveDeepSeekR1Algorithm(data: object): Promise<Response>;
     static comprehensiveDeepSeekV3Algorithm(data: object): Promise<Response>;

package/dist/src/api/algorithm/alova/implement/comprehensiveAlgorithm.js

@@ -1,7 +1,21 @@
-import "../../index.js";
-import { ComprehensiveAlgorithm as o } from "../../comprehensiveAlgorithm.js";
-import { comprehensiveAlgorithmService as t } from "../index.js";
-class n extends o {
+import { ComprehensiveAlgorithm as r } from "../../comprehensiveAlgorithm.js";
+import "../../inquiriesAlgorithm.js";
+import "../../inspectionsAlgorithm.js";
+import "../../lisemsAlgorithm.js";
+import "../../pulsationsAlgorithm.js";
+import "../index.js";
+import { createAlova as o } from "../../../../../node_modules/alova/dist/alova.esm.js";
+import { getServiceEndpoint as i, ServiceType as m } from "../../../config/index.js";
+import s from "../../../../../node_modules/alova/dist/adapter/fetch.esm.js";
+import { responded as p } from "../../../config/alova/index.js";
+const t = o({
+  baseURL: i(m.ComprehensiveAlgorithm),
+  timeout: 3e4,
+  cacheFor: null,
+  requestAdapter: s(),
+  responded: p
+});
+class f extends r {
   static comprehensiveDeepSeekR1Algorithm(e) {
     return t.Post("/千问大模型分析", e, {
       timeout: 3e4
@@ -24,5 +38,6 @@ class n extends o {
   }
 }
 export {
-  n as AlovaComprehensiveAlgorithm
+  f as AlovaComprehensiveAlgorithm,
+  t as comprehensiveAlgorithmService
 };

package/dist/src/api/algorithm/alova/implement/inquiriesAlgorithm.js

@@ -1,7 +1,10 @@
-import "../../index.js";
-import { InquiriesAlgorithm as s } from "../../inquiriesAlgorithm.js";
+import "../../comprehensiveAlgorithm.js";
+import { InquiriesAlgorithm as o } from "../../inquiriesAlgorithm.js";
+import "../../inspectionsAlgorithm.js";
+import "../../lisemsAlgorithm.js";
+import "../../pulsationsAlgorithm.js";
 import { inquiriesAlgorithmService as i } from "../index.js";
-class a extends s {
+class p extends o {
   static complaintsRecognition(t) {
     return i.Post("/主诉/识别", { symptomDescription: t }).send();
   }
@@ -19,5 +22,5 @@ class a extends s {
   }
 }
 export {
-  a as AlovaInquiriesAlgorithm
+  p as AlovaInquiriesAlgorithm
 };

package/dist/src/api/algorithm/alova/implement/inspectionsAlgorithm.js

@@ -1,18 +1,21 @@
-import "../../index.js";
-import { InspectionsAlgorithm as o } from "../../inspectionsAlgorithm.js";
-import { inspectionAlgorithmService as e } from "../index.js";
-class m extends o {
+import "../../comprehensiveAlgorithm.js";
+import "../../inquiriesAlgorithm.js";
+import { InspectionsAlgorithm as e } from "../../inspectionsAlgorithm.js";
+import "../../lisemsAlgorithm.js";
+import "../../pulsationsAlgorithm.js";
+import { inspectionAlgorithmService as o } from "../index.js";
+class a extends e {
   static tongueAnalyze(t) {
-    return e.Post("/舌象", t, {
+    return o.Post("/舌象", t, {
       timeout: 3e4
     }).send();
   }
   static faceAnalyze(t) {
-    return e.Post("/面象", t, {
+    return o.Post("/面象", t, {
       timeout: 3e4
     }).send();
   }
 }
 export {
-  m as AlovaInspectionsAlgorithm
+  a as AlovaInspectionsAlgorithm
 };

package/dist/src/api/algorithm/alova/implement/lisemsAlgorithm.js

@@ -1,7 +1,10 @@
-import "../../index.js";
-import { LisemsAlgorithm as i } from "../../lisemsAlgorithm.js";
+import "../../comprehensiveAlgorithm.js";
+import "../../inquiriesAlgorithm.js";
+import "../../inspectionsAlgorithm.js";
+import { LisemsAlgorithm as o } from "../../lisemsAlgorithm.js";
+import "../../pulsationsAlgorithm.js";
 import { lisemsAlgorithmService as s } from "../index.js";
-class c extends i {
+class g extends o {
   static analysisLisems(r) {
     return s.Post("/特征参数", r, {
       transform(t) {
@@ -12,12 +15,12 @@ class c extends i {
   static getFrequencyDomainDiagram(r) {
     return s.Post("/频域图", JSON.stringify(r), {
       async transform(t) {
-        const e = await t.blob();
-        return URL.createObjectURL(e);
+        const i = await t.blob();
+        return URL.createObjectURL(i);
       }
     }).send();
   }
 }
 export {
-  c as AlovaLisemsAlgorithm
+  g as AlovaLisemsAlgorithm
 };

package/dist/src/api/algorithm/alova/implement/pulsationsAlgorithm.js

@@ -1,16 +1,19 @@
-import "../../index.js";
-import { PulsationsAlgorithm as o } from "../../pulsationsAlgorithm.js";
-import { pulsationsAlgorithmService as s } from "../index.js";
-class l extends o {
+import "../../comprehensiveAlgorithm.js";
+import "../../inquiriesAlgorithm.js";
+import "../../inspectionsAlgorithm.js";
+import "../../lisemsAlgorithm.js";
+import { PulsationsAlgorithm as s } from "../../pulsationsAlgorithm.js";
+import { pulsationsAlgorithmService as o } from "../index.js";
+class a extends s {
   static pulsationPreprocessing(t) {
-    return s.Post("/预处理", t, {}).send();
+    return o.Post("/预处理", t, {}).send();
   }
   static pulsationAnalysis(t) {
-    return s.Post("/特征参数", t, {
+    return o.Post("/特征参数", t, {
       timeout: 3e4
     }).send();
   }
 }
 export {
-  l as AlovaPulsationsAlgorithm
+  a as AlovaPulsationsAlgorithm
 };

package/dist/src/api/algorithm/alova/index.d.ts

@@ -3,4 +3,3 @@ export declare const inspectionAlgorithmService: import('alova').Alova<import('a
 export declare const inquiriesAlgorithmService: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>>;
 export declare const lisemsAlgorithmService: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>>;
 export declare const pulsationsAlgorithmService: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>>;
-export declare const comprehensiveAlgorithmService: import('alova').Alova<import('alova').AlovaGenerics<any, any, import('alova/fetch').FetchRequestInit, Response, Headers, import('alova').AlovaDefaultCacheAdapter, import('alova').AlovaDefaultCacheAdapter, import('alova').StatesExport<any>>>;

package/dist/src/api/algorithm/alova/index.js

@@ -1,43 +1,43 @@
 import { createAlova as e } from "../../../../node_modules/alova/dist/alova.esm.js";
-import { getServiceEndpoint as t, ServiceType as r } from "../../config/index.js";
+import { getServiceEndpoint as r, ServiceType as t } from "../../config/index.js";
 import o from "../../../../node_modules/alova/dist/adapter/fetch.esm.js";
-import "./implement/index.js";
+import { AlovaComprehensiveAlgorithm as f, comprehensiveAlgorithmService as F } from "./implement/comprehensiveAlgorithm.js";
+import "../comprehensiveAlgorithm.js";
+import "../inquiriesAlgorithm.js";
+import "../inspectionsAlgorithm.js";
+import "../lisemsAlgorithm.js";
+import "../pulsationsAlgorithm.js";
 import { responded as i } from "../../config/alova/index.js";
-const a = e({
-  baseURL: t(r.InspectionsAlgorithm),
+const A = e({
+  baseURL: r(t.InspectionsAlgorithm),
   timeout: 3e4,
   cacheFor: null,
   requestAdapter: o(),
   responded: i
-}), p = e({
-  baseURL: t(r.InquiriesAlgorithm),
+}), g = e({
+  baseURL: r(t.InquiriesAlgorithm),
   timeout: 3e4,
   cacheFor: null,
   requestAdapter: o(),
   responded: i
-}), u = e({
-  baseURL: t(r.LisemsAlgorithm),
+}), v = e({
+  baseURL: r(t.LisemsAlgorithm),
   timeout: 3e4,
   cacheFor: null,
   requestAdapter: o(),
   responded: i
-}), h = e({
-  baseURL: t(r.PulsationsAlgorithm),
-  timeout: 3e4,
-  cacheFor: null,
-  requestAdapter: o(),
-  responded: i
-}), A = e({
-  baseURL: t(r.ComprehensiveAlgorithm),
+}), d = e({
+  baseURL: r(t.PulsationsAlgorithm),
   timeout: 3e4,
   cacheFor: null,
   requestAdapter: o(),
   responded: i
 });
 export {
-  A as comprehensiveAlgorithmService,
-  p as inquiriesAlgorithmService,
-  a as inspectionAlgorithmService,
-  u as lisemsAlgorithmService,
-  h as pulsationsAlgorithmService
+  f as AlovaComprehensiveAlgorithm,
+  F as comprehensiveAlgorithmService,
+  g as inquiriesAlgorithmService,
+  A as inspectionAlgorithmService,
+  v as lisemsAlgorithmService,
+  d as pulsationsAlgorithmService
 };

package/dist/src/api/algorithm/comprehensiveAlgorithm.d.ts

@@ -2,7 +2,7 @@ import { BaseObject } from '../patient';
 import { IBuilder } from 'builder-pattern';
 export declare abstract class ComprehensiveAlgorithm extends BaseObject {
     static _default: typeof ComprehensiveAlgorithm;
-    static builder(): IBuilder<unknown>;
+    static builder(): IBuilder<ComprehensiveAlgorithm>;
     static default(): typeof ComprehensiveAlgorithm;
     static comprehensiveQwenAlgorithm(data: object): Promise<Response>;
     static comprehensiveDeepSeekV3Algorithm(data: object): Promise<Response>;

package/dist/src/api/algorithm/comprehensiveAlgorithm.js

@@ -1,13 +1,14 @@
-import "../patient/index.js";
-import { Builder as r } from "../../../node_modules/builder-pattern/dist/index.js";
-import { BaseObject as i } from "../core/core.js";
-class t extends i {
+import { BaseObject as r } from "../core/core.js";
+import { Builder as i } from "../../../node_modules/builder-pattern/dist/index.js";
+import "../../../node_modules/pinyin/lib/esm/pinyin.js";
+import "../patient/alova/index.js";
+class t extends r {
   static _default = t;
   static builder() {
-    return r(this._default);
+    return i(this._default);
   }
   static default() {
-    return t;
+    return this._default;
   }
   static comprehensiveQwenAlgorithm(e) {
     return this.default().comprehensiveQwenAlgorithm(e);

package/dist/src/api/algorithm/index.d.ts

@@ -1,6 +1,6 @@
-export * from './alova';
 export * from './comprehensiveAlgorithm';
 export * from './inquiriesAlgorithm';
 export * from './inspectionsAlgorithm';
 export * from './lisemsAlgorithm';
 export * from './pulsationsAlgorithm';
+export * from './alova';

package/dist/src/api/algorithm/index.js

@@ -1,28 +1,28 @@
-import { comprehensiveAlgorithmService as i, inquiriesAlgorithmService as e, inspectionAlgorithmService as m, lisemsAlgorithmService as t, pulsationsAlgorithmService as l } from "./alova/index.js";
-import { ComprehensiveAlgorithm as A } from "./comprehensiveAlgorithm.js";
-import { InquiriesAlgorithm as p } from "./inquiriesAlgorithm.js";
-import { InspectionsAlgorithm as n } from "./inspectionsAlgorithm.js";
-import { LisemsAlgorithm as f } from "./lisemsAlgorithm.js";
-import { PulsationsAlgorithm as c } from "./pulsationsAlgorithm.js";
-import { AlovaComprehensiveAlgorithm as u } from "./alova/implement/comprehensiveAlgorithm.js";
+import { ComprehensiveAlgorithm as i } from "./comprehensiveAlgorithm.js";
+import { InquiriesAlgorithm as m } from "./inquiriesAlgorithm.js";
+import { InspectionsAlgorithm as l } from "./inspectionsAlgorithm.js";
+import { LisemsAlgorithm as A } from "./lisemsAlgorithm.js";
+import { PulsationsAlgorithm as p } from "./pulsationsAlgorithm.js";
+import { inquiriesAlgorithmService as n, inspectionAlgorithmService as v, lisemsAlgorithmService as f, pulsationsAlgorithmService as x } from "./alova/index.js";
+import { AlovaComprehensiveAlgorithm as a, comprehensiveAlgorithmService as u } from "./alova/implement/comprehensiveAlgorithm.js";
 import { AlovaInquiriesAlgorithm as I } from "./alova/implement/inquiriesAlgorithm.js";
 import { AlovaInspectionsAlgorithm as C } from "./alova/implement/inspectionsAlgorithm.js";
 import { AlovaLisemsAlgorithm as P } from "./alova/implement/lisemsAlgorithm.js";
 import { AlovaPulsationsAlgorithm as d } from "./alova/implement/pulsationsAlgorithm.js";
 export {
-  u as AlovaComprehensiveAlgorithm,
+  a as AlovaComprehensiveAlgorithm,
   I as AlovaInquiriesAlgorithm,
   C as AlovaInspectionsAlgorithm,
   P as AlovaLisemsAlgorithm,
   d as AlovaPulsationsAlgorithm,
-  A as ComprehensiveAlgorithm,
-  p as InquiriesAlgorithm,
-  n as InspectionsAlgorithm,
-  f as LisemsAlgorithm,
-  c as PulsationsAlgorithm,
-  i as comprehensiveAlgorithmService,
-  e as inquiriesAlgorithmService,
-  m as inspectionAlgorithmService,
-  t as lisemsAlgorithmService,
-  l as pulsationsAlgorithmService
+  i as ComprehensiveAlgorithm,
+  m as InquiriesAlgorithm,
+  l as InspectionsAlgorithm,
+  A as LisemsAlgorithm,
+  p as PulsationsAlgorithm,
+  u as comprehensiveAlgorithmService,
+  n as inquiriesAlgorithmService,
+  v as inspectionAlgorithmService,
+  f as lisemsAlgorithmService,
+  x as pulsationsAlgorithmService
 };

package/dist/src/api/algorithm/lisemsAlgorithm.js

@@ -6,7 +6,7 @@ class e extends a {
     return i(this._default);
   }
   static default() {
-    return e;
+    return this._default;
   }
   static analysisLisems(t) {
     return this.default().analysisLisems(t);

package/dist/src/api/authorization/alova/createApis.js

@@ -31,7 +31,13 @@ const l = /* @__PURE__ */ Object.create(null), d = (e, a, p) => {
             n.append(r, t[r]), t[r] instanceof Blob && (c = !0);
         t = c ? n : t;
       }
-      return new g(P.toUpperCase(), a, A, s, t);
+      return new g(
+        P.toUpperCase(),
+        a,
+        A,
+        s,
+        t
+      );
     }
   });
   return l[o] = i, i;

package/dist/src/api/authorization/alova/index.js

@@ -1,20 +1,18 @@
 import { createAlova as e } from "../../../../node_modules/alova/dist/alova.esm.js";
 import o from "../../../../node_modules/alova/dist/adapter/fetch.esm.js";
-import { withConfigType as t, createApis as r, mountApis as i } from "./createApis.js";
+import { createApis as t, mountApis as r, withConfigType as i } from "./createApis.js";
 import { responded as p, onAuthRequired as a } from "../../config/alova/index.js";
-import { getServiceEndpoint as n, ServiceType as m } from "../../config/index.js";
-import "./implement/index.js";
-import "./globals.js";
-const s = e({
-  baseURL: n(m.Authorization),
+import { getServiceEndpoint as n, ServiceType as s } from "../../config/index.js";
+const c = e({
+  baseURL: n(s.Authorization),
   requestAdapter: o(),
   beforeRequest: a(),
   cacheFor: null,
   responded: p
-}), c = t({}), f = r(s, c);
-i(f);
+}), m = i({}), f = t(c, m);
+r(f);
 export {
-  c as $$userConfigMap,
-  s as alovaInstance,
+  m as $$userConfigMap,
+  c as alovaInstance,
   f as default
 };

package/dist/src/api/check/alova/createApis.js

@@ -31,7 +31,13 @@ const l = /* @__PURE__ */ Object.create(null), d = (e, a, p) => {
             n.append(r, t[r]), t[r] instanceof Blob && (i = !0);
         t = i ? n : t;
       }
-      return new g(P.toUpperCase(), a, A, s, t);
+      return new g(
+        P.toUpperCase(),
+        a,
+        A,
+        s,
+        t
+      );
     }
   });
   return l[o] = c, c;

package/dist/src/api/check/alova/index.js

@@ -1,18 +1,19 @@
 import { createAlova as e } from "../../../../node_modules/alova/dist/alova.esm.js";
 import o from "../../../../node_modules/alova/dist/adapter/fetch.esm.js";
-import { withConfigType as r, createApis as t, mountApis as p } from "./createApis.js";
+import { createApis as r, mountApis as t, withConfigType as p } from "./createApis.js";
 import { responded as i, onAuthRequired as a } from "../../config/alova/index.js";
 import { getServiceEndpoint as m, ServiceType as n } from "../../config/index.js";
-import "./implement/index.js";
-import "./globals.js";
+import "../../core/core.js";
+import "../../../../node_modules/pinyin/lib/esm/pinyin.js";
+import "../../prescription/alova/index.js";
 const s = e({
   baseURL: m(n.Check),
   requestAdapter: o(),
   beforeRequest: a(),
   cacheFor: null,
   responded: i
-}), c = r({}), f = t(s, c);
-p(f);
+}), c = p({}), f = r(s, c);
+t(f);
 export {
   c as $$userConfigMap,
   s as alovaInstance,

package/dist/src/api/check/check.js

@@ -4,9 +4,9 @@ import { Metas as m } from "../patient/meta.js";
 import { Prescription as s } from "../prescription/prescription.js";
 import { extractPlainText as c } from "../../util/RichTextUtil.js";
 import { Doctor as f } from "../doctor/doctor.js";
-import "../prescription/index.js";
-import { Builder as S } from "../../../node_modules/builder-pattern/dist/index.js";
 import { Herbal as g } from "../prescription/herbal.js";
+import "../prescription/alova/index.js";
+import { Builder as S } from "../../../node_modules/builder-pattern/dist/index.js";
 class n extends l {
   static builder() {
     return S(this._default);

package/dist/src/api/doctor/alova/createApis.js

@@ -31,7 +31,13 @@ const l = /* @__PURE__ */ Object.create(null), d = (e, a, p) => {
             n.append(r, t[r]), t[r] instanceof Blob && (i = !0);
         t = i ? n : t;
       }
-      return new g(P.toUpperCase(), a, A, c, t);
+      return new g(
+        P.toUpperCase(),
+        a,
+        A,
+        c,
+        t
+      );
     }
   });
   return l[o] = s, s;

package/dist/src/api/doctor/alova/index.js

@@ -1,21 +1,20 @@
 import { createAlova as e } from "../../../../node_modules/alova/dist/alova.esm.js";
 import o from "../../../../node_modules/alova/dist/adapter/fetch.esm.js";
-import { withConfigType as r, createApis as t, mountApis as p } from "./createApis.js";
+import { createApis as r, mountApis as t, withConfigType as p } from "./createApis.js";
 import { responded as i, onAuthRequired as a } from "../../config/alova/index.js";
-import { getServiceEndpoint as m, ServiceType as n } from "../../config/index.js";
-import "./implement/index.js";
-import "./globals.js";
-const s = e({
-  baseURL: m(n.Doctor),
+import { getServiceEndpoint as n, ServiceType as s } from "../../config/index.js";
+import "../../core/core.js";
+const c = e({
+  baseURL: n(s.Doctor),
   requestAdapter: o(),
   beforeRequest: a(() => {
   }),
   cacheFor: null,
   responded: i
-}), c = r({}), f = t(s, c);
-p(f);
+}), m = p({}), f = r(c, m);
+t(f);
 export {
-  c as $$userConfigMap,
-  s as alovaInstance,
+  m as $$userConfigMap,
+  c as alovaInstance,
   f as default
 };

package/dist/src/api/metric/index.js

@@ -1,7 +1,6 @@
-import "./alova/index.js";
-import { Metric as e } from "./metric.js";
-import { AlovaMetric as m } from "./alova/implement/metric.js";
+import { AlovaMetric as e } from "./alova/implement/metric.js";
+import { Metric as c } from "./metric.js";
 export {
-  m as AlovaMetric,
-  e as Metric
+  e as AlovaMetric,
+  c as Metric
 };

package/dist/src/api/oauth/alova/createApis.js

@@ -31,7 +31,13 @@ const l = /* @__PURE__ */ Object.create(null), d = (e, a, p) => {
             n.append(r, t[r]), t[r] instanceof Blob && (c = !0);
         t = c ? n : t;
       }
-      return new g(P.toUpperCase(), a, A, i, t);
+      return new g(
+        P.toUpperCase(),
+        a,
+        A,
+        i,
+        t
+      );
     }
   });
   return l[o] = s, s;