@pyreon/charts 0.6.0 → 0.7.0

package/lib/types/manual.d.ts

@@ -1,279 +1,2238 @@
-import { effect, signal } from "@pyreon/reactivity";
-import { onUnmount } from "@pyreon/core";
+import { Props, VNodeChild } from "@pyreon/core";
+import { EChartsOption, EChartsOption as EChartsOption$1 } from "echarts";
+import { Signal } from "@pyreon/reactivity";
 
-//#region src/loader.ts
-
-/**
-* Lazily load echarts/core. Cached after first call.
+//#region ../../node_modules/.bun/echarts@6.0.0/node_modules/echarts/types/dist/shared.d.ts
+interface GradientObject {
+  id?: number;
+  type: string;
+  colorStops: GradientColorStop[];
+  global?: boolean;
+}
+interface GradientColorStop {
+  offset: number;
+  color: string;
+}
+interface RadialGradientObject extends GradientObject {
+  type: 'radial';
+  x: number;
+  y: number;
+  r: number;
+}
+interface LinearGradientObject extends GradientObject {
+  type: 'linear';
+  x: number;
+  y: number;
+  x2: number;
+  y2: number;
+}
+declare type Dictionary<T> = {
+  [key: string]: T;
+};
+declare type NullUndefined = null | undefined;
+declare type ImageLike = HTMLImageElement | HTMLCanvasElement | HTMLVideoElement;
+declare type TextVerticalAlign = 'top' | 'middle' | 'bottom';
+declare type TextAlign = 'left' | 'center' | 'right';
+declare type FontWeight = 'normal' | 'bold' | 'bolder' | 'lighter' | number;
+declare type FontStyle = 'normal' | 'italic' | 'oblique';
+declare type BuiltinTextPosition = 'left' | 'right' | 'top' | 'bottom' | 'inside' | 'insideLeft' | 'insideRight' | 'insideTop' | 'insideBottom' | 'insideTopLeft' | 'insideTopRight' | 'insideBottomLeft' | 'insideBottomRight';
+declare type ZREventProperties = {
+  zrX: number;
+  zrY: number;
+  zrDelta: number;
+  zrEventControl: 'no_globalout' | 'only_globalout';
+  zrByTouch: boolean;
+};
+declare type ZRRawMouseEvent = MouseEvent & ZREventProperties;
+declare type ZRRawTouchEvent = TouchEvent & ZREventProperties;
+declare type ZRRawPointerEvent = TouchEvent & ZREventProperties;
+declare type ZRRawEvent = ZRRawMouseEvent | ZRRawTouchEvent | ZRRawPointerEvent;
+declare type ElementEventName = 'click' | 'dblclick' | 'mousewheel' | 'mouseout' | 'mouseover' | 'mouseup' | 'mousedown' | 'mousemove' | 'contextmenu' | 'drag' | 'dragstart' | 'dragend' | 'dragenter' | 'dragleave' | 'dragover' | 'drop' | 'globalout';
+declare type PropType<TObj, TProp extends keyof TObj> = TObj[TProp];
+declare type MapToType<T extends Dictionary<any>, S> = { [P in keyof T]: T[P] extends Dictionary<any> ? MapToType<T[P], S> : S };
+declare type WithThisType<Func extends (...args: any) => any, This> = (this: This, ...args: Parameters<Func>) => ReturnType<Func>;
+declare type SVGVNodeAttrs = Record<string, string | number | undefined | boolean>;
+interface SVGVNode {
+  tag: string;
+  attrs: SVGVNodeAttrs;
+  children?: SVGVNode[];
+  text?: string;
+  elm?: Node;
+  key: string;
+}
+declare type ImagePatternRepeat = 'repeat' | 'repeat-x' | 'repeat-y' | 'no-repeat';
+interface PatternObjectBase {
+  id?: number;
+  type?: 'pattern';
+  x?: number;
+  y?: number;
+  rotation?: number;
+  scaleX?: number;
+  scaleY?: number;
+}
+interface ImagePatternObject extends PatternObjectBase {
+  image: ImageLike | string;
+  repeat?: ImagePatternRepeat;
+  imageWidth?: number;
+  imageHeight?: number;
+}
+interface SVGPatternObject extends PatternObjectBase {
+  svgElement?: SVGVNode;
+  svgWidth?: number;
+  svgHeight?: number;
+}
+declare type PatternObject = ImagePatternObject | SVGPatternObject;
+declare type EventCallbackSingleParam<EvtParam = any> = EvtParam extends any ? (params: EvtParam) => boolean | void : never;
+declare type EventCallback<EvtParams = any[]> = EvtParams extends any[] ? (...args: EvtParams) => boolean | void : never;
+declare type EventQuery = string | Object;
+declare type CbThis<Ctx, Impl> = unknown extends Ctx ? Impl : Ctx;
+declare type DefaultEventDefinition = Dictionary<EventCallback<any[]>>;
+interface EventProcessor<EvtDef = DefaultEventDefinition> {
+  normalizeQuery?: (query: EventQuery) => EventQuery;
+  filter?: (eventType: keyof EvtDef, query: EventQuery) => boolean;
+  afterTrigger?: (eventType: keyof EvtDef) => void;
+}
+declare class Eventful<EvtDef extends DefaultEventDefinition = DefaultEventDefinition> {
+  private _$handlers;
+  protected _$eventProcessor: EventProcessor<EvtDef>;
+  constructor(eventProcessors?: EventProcessor<EvtDef>);
+  on<Ctx, EvtNm extends keyof EvtDef>(event: EvtNm, handler: WithThisType<EvtDef[EvtNm], CbThis<Ctx, this>>, context?: Ctx): this;
+  on<Ctx, EvtNm extends keyof EvtDef>(event: EvtNm, query: EventQuery, handler: WithThisType<EvtDef[EvtNm], CbThis<Ctx, this>>, context?: Ctx): this;
+  isSilent(eventName: keyof EvtDef): boolean;
+  off(eventType?: keyof EvtDef, handler?: Function): this;
+  trigger<EvtNm extends keyof EvtDef>(eventType: EvtNm, ...args: Parameters<EvtDef[EvtNm]>): this;
+  triggerWithContext(type: keyof EvtDef, ...args: any[]): this;
+}
+declare type VectorArray = number[];
+declare type MatrixArray = number[];
+interface PointLike {
+  x: number;
+  y: number;
+}
+declare class Point {
+  x: number;
+  y: number;
+  constructor(x?: number, y?: number);
+  copy(other: PointLike): this;
+  clone(): Point;
+  set(x: number, y: number): this;
+  equal(other: PointLike): boolean;
+  add(other: PointLike): this;
+  scale(scalar: number): void;
+  scaleAndAdd(other: PointLike, scalar: number): void;
+  sub(other: PointLike): this;
+  dot(other: PointLike): number;
+  len(): number;
+  lenSquare(): number;
+  normalize(): this;
+  distance(other: PointLike): number;
+  distanceSquare(other: Point): number;
+  negate(): this;
+  transform(m: MatrixArray): this;
+  toArray(out: number[]): number[];
+  fromArray(input: number[]): void;
+  static set(p: PointLike, x: number, y: number): void;
+  static copy(p: PointLike, p2: PointLike): void;
+  static len(p: PointLike): number;
+  static lenSquare(p: PointLike): number;
+  static dot(p0: PointLike, p1: PointLike): number;
+  static add(out: PointLike, p0: PointLike, p1: PointLike): void;
+  static sub(out: PointLike, p0: PointLike, p1: PointLike): void;
+  static scale(out: PointLike, p0: PointLike, scalar: number): void;
+  static scaleAndAdd(out: PointLike, p0: PointLike, p1: PointLike, scalar: number): void;
+  static lerp(out: PointLike, p0: PointLike, p1: PointLike, t: number): void;
+}
+declare class BoundingRect {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+  constructor(x: number, y: number, width: number, height: number);
+  static set<TTarget extends RectLike>(target: TTarget, x: number, y: number, width: number, height: number): TTarget;
+  union(other: BoundingRect): void;
+  applyTransform(m: MatrixArray): void;
+  calculateTransform(b: RectLike): MatrixArray;
+  intersect(b: RectLike, mtv?: PointLike, opt?: BoundingRectIntersectOpt): boolean;
+  static intersect(a: RectLike, b: RectLike, mtv?: PointLike, opt?: BoundingRectIntersectOpt): boolean;
+  static contain(rect: RectLike, x: number, y: number): boolean;
+  contain(x: number, y: number): boolean;
+  clone(): BoundingRect;
+  copy(other: RectLike): void;
+  plain(): RectLike;
+  isFinite(): boolean;
+  isZero(): boolean;
+  static create(rect: RectLike): BoundingRect;
+  static copy<TTarget extends RectLike>(target: TTarget, source: RectLike): TTarget;
+  static applyTransform(target: RectLike, source: RectLike, m: MatrixArray): void;
+}
+declare type RectLike = {
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+};
+interface BoundingRectIntersectOpt {
+  direction?: number;
+  bidirectional?: boolean;
+  touchThreshold?: number;
+  outIntersectRect?: RectLike;
+  clamp?: boolean;
+}
+interface ExtendedCanvasRenderingContext2D extends CanvasRenderingContext2D {
+  dpr?: number;
+}
+declare class PathProxy {
+  dpr: number;
+  data: number[] | Float32Array;
+  private _version;
+  private _saveData;
+  private _pendingPtX;
+  private _pendingPtY;
+  private _pendingPtDist;
+  private _ctx;
+  private _xi;
+  private _yi;
+  private _x0;
+  private _y0;
+  private _len;
+  private _pathSegLen;
+  private _pathLen;
+  private _ux;
+  private _uy;
+  static CMD: {
+    M: number;
+    L: number;
+    C: number;
+    Q: number;
+    A: number;
+    Z: number;
+    R: number;
+  };
+  constructor(notSaveData?: boolean);
+  increaseVersion(): void;
+  getVersion(): number;
+  setScale(sx: number, sy: number, segmentIgnoreThreshold?: number): void;
+  setDPR(dpr: number): void;
+  setContext(ctx: ExtendedCanvasRenderingContext2D): void;
+  getContext(): ExtendedCanvasRenderingContext2D;
+  beginPath(): this;
+  reset(): void;
+  moveTo(x: number, y: number): this;
+  lineTo(x: number, y: number): this;
+  bezierCurveTo(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): this;
+  quadraticCurveTo(x1: number, y1: number, x2: number, y2: number): this;
+  arc(cx: number, cy: number, r: number, startAngle: number, endAngle: number, anticlockwise?: boolean): this;
+  arcTo(x1: number, y1: number, x2: number, y2: number, radius: number): this;
+  rect(x: number, y: number, w: number, h: number): this;
+  closePath(): this;
+  fill(ctx: CanvasRenderingContext2D): void;
+  stroke(ctx: CanvasRenderingContext2D): void;
+  len(): number;
+  setData(data: Float32Array | number[]): void;
+  appendPath(path: PathProxy | PathProxy[]): void;
+  addData(cmd: number, a?: number, b?: number, c?: number, d?: number, e?: number, f?: number, g?: number, h?: number): void;
+  private _drawPendingPt;
+  private _expandData;
+  toStatic(): void;
+  getBoundingRect(): BoundingRect;
+  private _calculateLength;
+  rebuildPath(ctx: PathRebuilder, percent: number): void;
+  clone(): PathProxy;
+  canSave(): boolean;
+  private static initDefaultProps;
+}
+interface PathRebuilder {
+  moveTo(x: number, y: number): void;
+  lineTo(x: number, y: number): void;
+  bezierCurveTo(x: number, y: number, x2: number, y2: number, x3: number, y3: number): void;
+  quadraticCurveTo(x: number, y: number, x2: number, y2: number): void;
+  arc(cx: number, cy: number, r: number, startAngle: number, endAngle: number, anticlockwise: boolean): void;
+  ellipse(cx: number, cy: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise: boolean): void;
+  rect(x: number, y: number, width: number, height: number): void;
+  closePath(): void;
+}
+declare type easingFunc = (percent: number) => number;
+declare type AnimationEasing = keyof typeof easingFuncs | easingFunc;
+declare const easingFuncs: {
+  linear(k: number): number;
+  quadraticIn(k: number): number;
+  quadraticOut(k: number): number;
+  quadraticInOut(k: number): number;
+  cubicIn(k: number): number;
+  cubicOut(k: number): number;
+  cubicInOut(k: number): number;
+  quarticIn(k: number): number;
+  quarticOut(k: number): number;
+  quarticInOut(k: number): number;
+  quinticIn(k: number): number;
+  quinticOut(k: number): number;
+  quinticInOut(k: number): number;
+  sinusoidalIn(k: number): number;
+  sinusoidalOut(k: number): number;
+  sinusoidalInOut(k: number): number;
+  exponentialIn(k: number): number;
+  exponentialOut(k: number): number;
+  exponentialInOut(k: number): number;
+  circularIn(k: number): number;
+  circularOut(k: number): number;
+  circularInOut(k: number): number;
+  elasticIn(k: number): number;
+  elasticOut(k: number): number;
+  elasticInOut(k: number): number;
+  backIn(k: number): number;
+  backOut(k: number): number;
+  backInOut(k: number): number;
+  bounceIn(k: number): number;
+  bounceOut(k: number): number;
+  bounceInOut(k: number): number;
+};
+interface Stage {
+  update?: () => void;
+}
+interface AnimationOption {
+  stage?: Stage;
+}
+declare class Animation extends Eventful {
+  stage: Stage;
+  private _head;
+  private _tail;
+  private _running;
+  private _time;
+  private _pausedTime;
+  private _pauseStart;
+  private _paused;
+  constructor(opts?: AnimationOption);
+  addClip(clip: Clip): void;
+  addAnimator(animator: Animator<any>): void;
+  removeClip(clip: Clip): void;
+  removeAnimator(animator: Animator<any>): void;
+  update(notTriggerFrameAndStageUpdate?: boolean): void;
+  _startLoop(): void;
+  start(): void;
+  stop(): void;
+  pause(): void;
+  resume(): void;
+  clear(): void;
+  isFinished(): boolean;
+  animate<T>(target: T, options: {
+    loop?: boolean;
+  }): Animator<T>;
+}
+declare type OnframeCallback = (percent: number) => void;
+declare type ondestroyCallback = () => void;
+declare type onrestartCallback = () => void;
+interface ClipProps {
+  life?: number;
+  delay?: number;
+  loop?: boolean;
+  easing?: AnimationEasing;
+  onframe?: OnframeCallback;
+  ondestroy?: ondestroyCallback;
+  onrestart?: onrestartCallback;
+}
+declare class Clip {
+  private _life;
+  private _delay;
+  private _inited;
+  private _startTime;
+  private _pausedTime;
+  private _paused;
+  animation: Animation;
+  loop: boolean;
+  easing: AnimationEasing;
+  easingFunc: (p: number) => number;
+  next: Clip;
+  prev: Clip;
+  onframe: OnframeCallback;
+  ondestroy: ondestroyCallback;
+  onrestart: onrestartCallback;
+  constructor(opts: ClipProps);
+  step(globalTime: number, deltaTime: number): boolean;
+  pause(): void;
+  resume(): void;
+  setEasing(easing: AnimationEasing): void;
+}
+declare type ValueType = 0 | 1 | 2 | 3 | 4 | 5 | 6;
+declare type Keyframe = {
+  time: number;
+  value: unknown;
+  percent: number;
+  rawValue: unknown;
+  easing?: AnimationEasing;
+  easingFunc?: (percent: number) => number;
+  additiveValue?: unknown;
+};
+declare class Track {
+  keyframes: Keyframe[];
+  propName: string;
+  valType: ValueType;
+  discrete: boolean;
+  _invalid: boolean;
+  private _finished;
+  private _needsSort;
+  private _additiveTrack;
+  private _additiveValue;
+  private _lastFr;
+  private _lastFrP;
+  constructor(propName: string);
+  isFinished(): boolean;
+  setFinished(): void;
+  needsAnimate(): boolean;
+  getAdditiveTrack(): Track;
+  addKeyframe(time: number, rawValue: unknown, easing?: AnimationEasing): Keyframe;
+  prepare(maxTime: number, additiveTrack?: Track): void;
+  step(target: any, percent: number): void;
+  private _addToTarget;
+}
+declare type DoneCallback = () => void;
+declare type AbortCallback = () => void;
+declare type OnframeCallback$1<T> = (target: T, percent: number) => void;
+declare class Animator<T> {
+  animation?: Animation;
+  targetName?: string;
+  scope?: string;
+  __fromStateTransition?: string;
+  private _tracks;
+  private _trackKeys;
+  private _target;
+  private _loop;
+  private _delay;
+  private _maxTime;
+  private _force;
+  private _paused;
+  private _started;
+  private _allowDiscrete;
+  private _additiveAnimators;
+  private _doneCbs;
+  private _onframeCbs;
+  private _abortedCbs;
+  private _clip;
+  constructor(target: T, loop: boolean, allowDiscreteAnimation?: boolean, additiveTo?: Animator<any>[]);
+  getMaxTime(): number;
+  getDelay(): number;
+  getLoop(): boolean;
+  getTarget(): T;
+  changeTarget(target: T): void;
+  when(time: number, props: Dictionary<any>, easing?: AnimationEasing): this;
+  whenWithKeys(time: number, props: Dictionary<any>, propNames: string[], easing?: AnimationEasing): this;
+  pause(): void;
+  resume(): void;
+  isPaused(): boolean;
+  duration(duration: number): this;
+  private _doneCallback;
+  private _abortedCallback;
+  private _setTracksFinished;
+  private _getAdditiveTrack;
+  start(easing?: AnimationEasing): this;
+  stop(forwardToLast?: boolean): void;
+  delay(time: number): this;
+  during(cb: OnframeCallback$1<T>): this;
+  done(cb: DoneCallback): this;
+  aborted(cb: AbortCallback): this;
+  getClip(): Clip;
+  getTrack(propName: string): Track;
+  getTracks(): Track[];
+  stopTracks(propNames: string[], forwardToLast?: boolean): boolean;
+  saveTo(target: T, trackKeys?: readonly string[], firstOrLast?: boolean): void;
+  __changeFinalValue(finalProps: Dictionary<any>, trackKeys?: readonly string[]): void;
+}
+interface PathStyleProps extends CommonStyleProps {
+  fill?: string | PatternObject | LinearGradientObject | RadialGradientObject;
+  stroke?: string | PatternObject | LinearGradientObject | RadialGradientObject;
+  decal?: PatternObject;
+  strokePercent?: number;
+  strokeNoScale?: boolean;
+  fillOpacity?: number;
+  strokeOpacity?: number;
+  lineDash?: false | number[] | 'solid' | 'dashed' | 'dotted';
+  lineDashOffset?: number;
+  lineWidth?: number;
+  lineCap?: CanvasLineCap;
+  lineJoin?: CanvasLineJoin;
+  miterLimit?: number;
+  strokeFirst?: boolean;
+}
+interface PathProps extends DisplayableProps {
+  strokeContainThreshold?: number;
+  segmentIgnoreThreshold?: number;
+  subPixelOptimize?: boolean;
+  style?: PathStyleProps;
+  shape?: Dictionary<any>;
+  autoBatch?: boolean;
+  __value?: (string | number)[] | (string | number);
+  buildPath?: (ctx: PathProxy | CanvasRenderingContext2D, shapeCfg: Dictionary<any>, inBatch?: boolean) => void;
+}
+declare type PathKey = keyof PathProps;
+declare type PathPropertyType = PropType<PathProps, PathKey>;
+declare type PathStatePropNames = DisplayableStatePropNames | 'shape';
+declare type PathState = Pick<PathProps, PathStatePropNames> & {
+  hoverLayer?: boolean;
+};
+interface Path<Props extends PathProps = PathProps> {
+  animate(key?: '', loop?: boolean): Animator<this>;
+  animate(key: 'style', loop?: boolean): Animator<this['style']>;
+  animate(key: 'shape', loop?: boolean): Animator<this['shape']>;
+  getState(stateName: string): PathState;
+  ensureState(stateName: string): PathState;
+  states: Dictionary<PathState>;
+  stateProxy: (stateName: string) => PathState;
+}
+declare class Path<Props extends PathProps = PathProps> extends Displayable<Props> {
+  path: PathProxy;
+  strokeContainThreshold: number;
+  segmentIgnoreThreshold: number;
+  subPixelOptimize: boolean;
+  style: PathStyleProps;
+  autoBatch: boolean;
+  private _rectStroke;
+  protected _normalState: PathState;
+  protected _decalEl: Path;
+  shape: Dictionary<any>;
+  constructor(opts?: Props);
+  update(): void;
+  getDecalElement(): Path<PathProps>;
+  protected _init(props?: Props): void;
+  protected getDefaultStyle(): Props['style'];
+  protected getDefaultShape(): {};
+  protected canBeInsideText(): boolean;
+  protected getInsideTextFill(): "#333" | "#ccc" | "#eee";
+  protected getInsideTextStroke(textFill?: string): string;
+  buildPath(ctx: PathProxy | CanvasRenderingContext2D, shapeCfg: Dictionary<any>, inBatch?: boolean): void;
+  pathUpdated(): void;
+  getUpdatedPathProxy(inBatch?: boolean): PathProxy;
+  createPathProxy(): void;
+  hasStroke(): boolean;
+  hasFill(): boolean;
+  getBoundingRect(): BoundingRect;
+  contain(x: number, y: number): boolean;
+  dirtyShape(): void;
+  dirty(): void;
+  animateShape(loop: boolean): Animator<this["shape"]>;
+  updateDuringAnimation(targetKey: string): void;
+  attrKV(key: PathKey, value: PathPropertyType): void;
+  setShape(obj: Props['shape']): this;
+  setShape<T extends keyof Props['shape']>(obj: T, value: Props['shape'][T]): this;
+  shapeChanged(): boolean;
+  createStyle(obj?: Props['style']): Props["style"];
+  protected _innerSaveToNormal(toState: PathState): void;
+  protected _applyStateObj(stateName: string, state: PathState, normalState: PathState, keepCurrentStates: boolean, transition: boolean, animationCfg: ElementAnimateConfig): void;
+  protected _mergeStates(states: PathState[]): PathState;
+  getAnimationStyleProps(): MapToType<PathProps, boolean>;
+  isZeroArea(): boolean;
+  static extend<Shape extends Dictionary<any>>(defaultProps: {
+    type?: string;
+    shape?: Shape;
+    style?: PathStyleProps;
+    beforeBrush?: Displayable['beforeBrush'];
+    afterBrush?: Displayable['afterBrush'];
+    getBoundingRect?: Displayable['getBoundingRect'];
+    calculateTextPosition?: Element$1['calculateTextPosition'];
+    buildPath(this: Path, ctx: CanvasRenderingContext2D | PathProxy, shape: Shape, inBatch?: boolean): void;
+    init?(this: Path, opts: PathProps): void;
+  }): {
+    new (opts?: PathProps & {
+      shape: Shape;
+    }): Path;
+  };
+  protected static initDefaultProps: void;
+}
+declare class Transformable {
+  parent: Transformable;
+  x: number;
+  y: number;
+  scaleX: number;
+  scaleY: number;
+  skewX: number;
+  skewY: number;
+  rotation: number;
+  anchorX: number;
+  anchorY: number;
+  originX: number;
+  originY: number;
+  globalScaleRatio: number;
+  transform: MatrixArray;
+  invTransform: MatrixArray;
+  getLocalTransform(m?: MatrixArray): MatrixArray;
+  setPosition(arr: number[]): void;
+  setScale(arr: number[]): void;
+  setSkew(arr: number[]): void;
+  setOrigin(arr: number[]): void;
+  needLocalTransform(): boolean;
+  updateTransform(): void;
+  private _resolveGlobalScaleRatio;
+  getComputedTransform(): MatrixArray;
+  setLocalTransform(m: VectorArray): void;
+  decomposeTransform(): void;
+  getGlobalScale(out?: VectorArray): VectorArray;
+  transformCoordToLocal(x: number, y: number): number[];
+  transformCoordToGlobal(x: number, y: number): number[];
+  getLineScale(): number;
+  copyTransform(source: Transformable): void;
+  static getLocalTransform(target: Transformable, m?: MatrixArray): MatrixArray;
+  private static initDefaultProps;
+}
+declare const TRANSFORMABLE_PROPS: readonly ["x", "y", "originX", "originY", "anchorX", "anchorY", "rotation", "scaleX", "scaleY", "skewX", "skewY"];
+declare type TransformProp = (typeof TRANSFORMABLE_PROPS)[number];
+interface TSpanStyleProps extends PathStyleProps {
+  x?: number;
+  y?: number;
+  text?: string;
+  font?: string;
+  fontSize?: number;
+  fontWeight?: FontWeight;
+  fontStyle?: FontStyle;
+  fontFamily?: string;
+  textAlign?: CanvasTextAlign;
+  textBaseline?: CanvasTextBaseline;
+}
+interface TSpanProps extends DisplayableProps {
+  style?: TSpanStyleProps;
+}
+declare class TSpan extends Displayable<TSpanProps> {
+  style: TSpanStyleProps;
+  hasStroke(): boolean;
+  hasFill(): boolean;
+  createStyle(obj?: TSpanStyleProps): TSpanStyleProps;
+  setBoundingRect(rect: BoundingRect): void;
+  getBoundingRect(): BoundingRect;
+  protected static initDefaultProps: void;
+}
+interface ImageStyleProps extends CommonStyleProps {
+  image?: string | ImageLike;
+  x?: number;
+  y?: number;
+  width?: number;
+  height?: number;
+  sx?: number;
+  sy?: number;
+  sWidth?: number;
+  sHeight?: number;
+}
+interface ImageProps extends DisplayableProps {
+  style?: ImageStyleProps;
+  onload?: (image: ImageLike) => void;
+}
+declare class ZRImage extends Displayable<ImageProps> {
+  style: ImageStyleProps;
+  __image: ImageLike;
+  __imageSrc: string;
+  onload: (image: ImageLike) => void;
+  createStyle(obj?: ImageStyleProps): ImageStyleProps;
+  private _getSize;
+  getWidth(): number;
+  getHeight(): number;
+  getAnimationStyleProps(): MapToType<ImageProps, boolean>;
+  getBoundingRect(): BoundingRect;
+}
+declare class RectShape {
+  r?: number | number[];
+  x: number;
+  y: number;
+  width: number;
+  height: number;
+}
+interface RectProps extends PathProps {
+  shape?: Partial<RectShape>;
+}
+declare class Rect extends Path<RectProps> {
+  shape: RectShape;
+  constructor(opts?: RectProps);
+  getDefaultShape(): RectShape;
+  buildPath(ctx: CanvasRenderingContext2D, shape: RectShape): void;
+  isZeroArea(): boolean;
+}
+interface GroupProps extends ElementProps {}
+declare class Group extends Element$1<GroupProps> {
+  readonly isGroup = true;
+  private _children;
+  constructor(opts?: GroupProps);
+  childrenRef(): Element$1<ElementProps>[];
+  children(): Element$1<ElementProps>[];
+  childAt(idx: number): Element$1;
+  childOfName(name: string): Element$1;
+  childCount(): number;
+  add(child: Element$1): Group;
+  addBefore(child: Element$1, nextSibling: Element$1): this;
+  replace(oldChild: Element$1, newChild: Element$1): this;
+  replaceAt(child: Element$1, index: number): this;
+  _doAdd(child: Element$1): void;
+  remove(child: Element$1): this;
+  removeAll(): this;
+  eachChild<Context>(cb: (this: Context, el: Element$1, index?: number) => void, context?: Context): this;
+  traverse<T>(cb: (this: T, el: Element$1) => boolean | void, context?: T): this;
+  addSelfToZr(zr: ZRenderType): void;
+  removeSelfFromZr(zr: ZRenderType): void;
+  getBoundingRect(includeChildren?: Element$1[]): BoundingRect;
+}
+interface GroupLike extends Element$1 {
+  childrenRef(): Element$1[];
+}
+interface TextStylePropsPart {
+  text?: string;
+  fill?: string;
+  stroke?: string;
+  strokeNoScale?: boolean;
+  opacity?: number;
+  fillOpacity?: number;
+  strokeOpacity?: number;
+  lineWidth?: number;
+  lineDash?: false | number[];
+  lineDashOffset?: number;
+  borderDash?: false | number[];
+  borderDashOffset?: number;
+  font?: string;
+  textFont?: string;
+  fontStyle?: FontStyle;
+  fontWeight?: FontWeight;
+  fontFamily?: string;
+  fontSize?: number | string;
+  align?: TextAlign;
+  verticalAlign?: TextVerticalAlign;
+  lineHeight?: number;
+  width?: number | string;
+  height?: number;
+  tag?: string;
+  textShadowColor?: string;
+  textShadowBlur?: number;
+  textShadowOffsetX?: number;
+  textShadowOffsetY?: number;
+  backgroundColor?: string | {
+    image: ImageLike | string;
+  };
+  padding?: number | number[];
+  margin?: number | number[];
+  borderColor?: string;
+  borderWidth?: number;
+  borderRadius?: number | number[];
+  shadowColor?: string;
+  shadowBlur?: number;
+  shadowOffsetX?: number;
+  shadowOffsetY?: number;
+}
+interface TextStyleProps extends TextStylePropsPart {
+  text?: string;
+  x?: number;
+  y?: number;
+  width?: number;
+  rich?: Dictionary<TextStylePropsPart>;
+  overflow?: 'break' | 'breakAll' | 'truncate' | 'none';
+  lineOverflow?: 'truncate';
+  ellipsis?: string;
+  placeholder?: string;
+  truncateMinChar?: number;
+}
+interface TextProps extends DisplayableProps {
+  style?: TextStyleProps;
+  zlevel?: number;
+  z?: number;
+  z2?: number;
+  culling?: boolean;
+  cursor?: string;
+}
+declare type TextState = Pick<TextProps, DisplayableStatePropNames> & ElementCommonState;
+declare type DefaultTextStyle = Pick<TextStyleProps, 'fill' | 'stroke' | 'align' | 'verticalAlign'> & {
+  autoStroke?: boolean;
+  overflowRect?: BoundingRect | NullUndefined;
+};
+interface ZRText {
+  animate(key?: '', loop?: boolean): Animator<this>;
+  animate(key: 'style', loop?: boolean): Animator<this['style']>;
+  getState(stateName: string): TextState;
+  ensureState(stateName: string): TextState;
+  states: Dictionary<TextState>;
+  stateProxy: (stateName: string) => TextState;
+}
+declare class ZRText extends Displayable<TextProps> implements GroupLike {
+  type: string;
+  style: TextStyleProps;
+  overlap: 'hidden' | 'show' | 'blur';
+  innerTransformable: Transformable;
+  isTruncated: boolean;
+  private _children;
+  private _childCursor;
+  private _defaultStyle;
+  constructor(opts?: TextProps);
+  childrenRef(): (ZRImage | Rect | TSpan)[];
+  update(): void;
+  updateTransform(): void;
+  getLocalTransform(m?: MatrixArray): MatrixArray;
+  getComputedTransform(): MatrixArray;
+  private _updateSubTexts;
+  addSelfToZr(zr: ZRenderType): void;
+  removeSelfFromZr(zr: ZRenderType): void;
+  getBoundingRect(): BoundingRect;
+  setDefaultTextStyle(defaultTextStyle: DefaultTextStyle): void;
+  setTextContent(textContent: never): void;
+  protected _mergeStyle(targetStyle: TextStyleProps, sourceStyle: TextStyleProps): TextStyleProps;
+  private _mergeRich;
+  getAnimationStyleProps(): MapToType<TextProps, boolean>;
+  private _getOrCreateChild;
+  private _updatePlainTexts;
+  private _updateRichTexts;
+  private _placeToken;
+  private _renderBackground;
+  static makeFont(style: TextStylePropsPart): string;
+}
+interface TextPositionCalculationResult {
+  x: number;
+  y: number;
+  align: TextAlign;
+  verticalAlign: TextVerticalAlign;
+}
+declare class PolylineShape {
+  points: VectorArray[];
+  percent?: number;
+  smooth?: number;
+  smoothConstraint?: VectorArray[];
+}
+interface PolylineProps extends PathProps {
+  shape?: Partial<PolylineShape>;
+}
+declare class Polyline extends Path<PolylineProps> {
+  shape: PolylineShape;
+  constructor(opts?: PolylineProps);
+  getDefaultStyle(): {
+    stroke: string;
+    fill: string;
+  };
+  getDefaultShape(): PolylineShape;
+  buildPath(ctx: CanvasRenderingContext2D, shape: PolylineShape): void;
+}
+interface ElementAnimateConfig {
+  duration?: number;
+  delay?: number;
+  easing?: AnimationEasing;
+  during?: (percent: number) => void;
+  done?: Function;
+  aborted?: Function;
+  scope?: string;
+  force?: boolean;
+  additive?: boolean;
+  setToFinal?: boolean;
+}
+interface ElementTextConfig {
+  position?: BuiltinTextPosition | (number | string)[];
+  rotation?: number;
+  layoutRect?: RectLike;
+  offset?: number[];
+  origin?: (number | string)[] | 'center';
+  distance?: number;
+  local?: boolean;
+  insideFill?: string;
+  insideStroke?: string;
+  outsideFill?: string;
+  outsideStroke?: string;
+  inside?: boolean;
+  autoOverflowArea?: boolean;
+}
+interface ElementTextGuideLineConfig {
+  anchor?: Point;
+  showAbove?: boolean;
+  candidates?: ('left' | 'top' | 'right' | 'bottom')[];
+}
+interface ElementEvent {
+  type: ElementEventName;
+  event: ZRRawEvent;
+  target: Element$1;
+  topTarget: Element$1;
+  cancelBubble: boolean;
+  offsetX: number;
+  offsetY: number;
+  gestureEvent: string;
+  pinchX: number;
+  pinchY: number;
+  pinchScale: number;
+  wheelDelta: number;
+  zrByTouch: boolean;
+  which: number;
+  stop: (this: ElementEvent) => void;
+}
+declare type ElementEventCallback<Ctx, Impl> = (this: CbThis$1<Ctx, Impl>, e: ElementEvent) => boolean | void;
+declare type CbThis$1<Ctx, Impl> = unknown extends Ctx ? Impl : Ctx;
+interface ElementEventHandlerProps {
+  onclick: ElementEventCallback<unknown, unknown>;
+  ondblclick: ElementEventCallback<unknown, unknown>;
+  onmouseover: ElementEventCallback<unknown, unknown>;
+  onmouseout: ElementEventCallback<unknown, unknown>;
+  onmousemove: ElementEventCallback<unknown, unknown>;
+  onmousewheel: ElementEventCallback<unknown, unknown>;
+  onmousedown: ElementEventCallback<unknown, unknown>;
+  onmouseup: ElementEventCallback<unknown, unknown>;
+  oncontextmenu: ElementEventCallback<unknown, unknown>;
+  ondrag: ElementEventCallback<unknown, unknown>;
+  ondragstart: ElementEventCallback<unknown, unknown>;
+  ondragend: ElementEventCallback<unknown, unknown>;
+  ondragenter: ElementEventCallback<unknown, unknown>;
+  ondragleave: ElementEventCallback<unknown, unknown>;
+  ondragover: ElementEventCallback<unknown, unknown>;
+  ondrop: ElementEventCallback<unknown, unknown>;
+}
+interface ElementProps extends Partial<ElementEventHandlerProps>, Partial<Pick<Transformable, TransformProp>> {
+  name?: string;
+  ignore?: boolean;
+  isGroup?: boolean;
+  draggable?: boolean | 'horizontal' | 'vertical';
+  silent?: boolean;
+  ignoreHostSilent?: boolean;
+  ignoreClip?: boolean;
+  globalScaleRatio?: number;
+  textConfig?: ElementTextConfig;
+  textContent?: ZRText;
+  clipPath?: Path;
+  drift?: Element$1['drift'];
+  extra?: Dictionary<unknown>;
+  anid?: string;
+}
+declare const PRIMARY_STATES_KEYS: ["x" | "y" | "originX" | "originY" | "anchorX" | "anchorY" | "rotation" | "scaleX" | "scaleY" | "skewX" | "skewY", "ignore"];
+declare type ElementStatePropNames = (typeof PRIMARY_STATES_KEYS)[number] | 'textConfig';
+declare type ElementState = Pick<ElementProps, ElementStatePropNames> & ElementCommonState;
+declare type ElementCommonState = {
+  hoverLayer?: boolean;
+};
+declare type ElementCalculateTextPosition = (out: TextPositionCalculationResult, style: ElementTextConfig, rect: RectLike) => TextPositionCalculationResult;
+interface Element$1<Props extends ElementProps = ElementProps> extends Transformable, Eventful<{ [key in ElementEventName]: (e: ElementEvent) => void | boolean } & { [key in string]: (...args: any) => void | boolean }>, ElementEventHandlerProps {}
+declare class Element$1<Props extends ElementProps = ElementProps> {
+  id: number;
+  type: string;
+  name: string;
+  ignore: boolean;
+  silent: boolean;
+  ignoreHostSilent: boolean;
+  isGroup: boolean;
+  draggable: boolean | 'horizontal' | 'vertical';
+  dragging: boolean;
+  parent: Group;
+  animators: Animator<any>[];
+  ignoreClip: boolean;
+  __hostTarget: Element$1;
+  __zr: ZRenderType;
+  __dirty: number;
+  __isRendered: boolean;
+  __inHover: boolean;
+  __clipPaths?: Path[];
+  private _clipPath?;
+  private _textContent?;
+  private _textGuide?;
+  textConfig?: ElementTextConfig;
+  textGuideLineConfig?: ElementTextGuideLineConfig;
+  anid: string;
+  extra: Dictionary<unknown>;
+  currentStates?: string[];
+  prevStates?: string[];
+  states: Dictionary<ElementState>;
+  stateTransition: ElementAnimateConfig;
+  stateProxy?: (stateName: string, targetStates?: string[]) => ElementState;
+  protected _normalState: ElementState;
+  private _innerTextDefaultStyle;
+  constructor(props?: Props);
+  protected _init(props?: Props): void;
+  drift(dx: number, dy: number, e?: ElementEvent): void;
+  beforeUpdate(): void;
+  afterUpdate(): void;
+  update(): void;
+  updateInnerText(forceUpdate?: boolean): void;
+  protected canBeInsideText(): boolean;
+  protected getInsideTextFill(): string | undefined;
+  protected getInsideTextStroke(textFill: string): string | undefined;
+  protected getOutsideFill(): string | undefined;
+  protected getOutsideStroke(textFill: string): string;
+  traverse<Context>(cb: (this: Context, el: Element$1<Props>) => void, context?: Context): void;
+  protected attrKV(key: string, value: unknown): void;
+  hide(): void;
+  show(): void;
+  attr(keyOrObj: Props): this;
+  attr<T extends keyof Props>(keyOrObj: T, value: Props[T]): this;
+  saveCurrentToNormalState(toState: ElementState): void;
+  protected _innerSaveToNormal(toState: ElementState): void;
+  protected _savePrimaryToNormal(toState: Dictionary<any>, normalState: Dictionary<any>, primaryKeys: readonly string[]): void;
+  hasState(): boolean;
+  getState(name: string): ElementState;
+  ensureState(name: string): ElementState;
+  clearStates(noAnimation?: boolean): void;
+  useState(stateName: string, keepCurrentStates?: boolean, noAnimation?: boolean, forceUseHoverLayer?: boolean): ElementState;
+  useStates(states: string[], noAnimation?: boolean, forceUseHoverLayer?: boolean): void;
+  isSilent(): boolean;
+  private _updateAnimationTargets;
+  removeState(state: string): void;
+  replaceState(oldState: string, newState: string, forceAdd: boolean): void;
+  toggleState(state: string, enable: boolean): void;
+  protected _mergeStates(states: ElementState[]): ElementState;
+  protected _applyStateObj(stateName: string, state: ElementState, normalState: ElementState, keepCurrentStates: boolean, transition: boolean, animationCfg: ElementAnimateConfig): void;
+  private _attachComponent;
+  private _detachComponent;
+  getClipPath(): Path<PathProps>;
+  setClipPath(clipPath: Path): void;
+  removeClipPath(): void;
+  getTextContent(): ZRText;
+  setTextContent(textEl: ZRText): void;
+  setTextConfig(cfg: ElementTextConfig): void;
+  removeTextConfig(): void;
+  removeTextContent(): void;
+  getTextGuideLine(): Polyline;
+  setTextGuideLine(guideLine: Polyline): void;
+  removeTextGuideLine(): void;
+  markRedraw(): void;
+  dirty(): void;
+  private _toggleHoverLayerFlag;
+  addSelfToZr(zr: ZRenderType): void;
+  removeSelfFromZr(zr: ZRenderType): void;
+  animate(key?: string, loop?: boolean, allowDiscreteAnimation?: boolean): Animator<any>;
+  addAnimator(animator: Animator<any>, key: string): void;
+  updateDuringAnimation(key: string): void;
+  stopAnimation(scope?: string, forwardToLast?: boolean): this;
+  animateTo(target: Props, cfg?: ElementAnimateConfig, animationProps?: MapToType<Props, boolean>): void;
+  animateFrom(target: Props, cfg: ElementAnimateConfig, animationProps?: MapToType<Props, boolean>): void;
+  protected _transitionState(stateName: string, target: Props, cfg?: ElementAnimateConfig, animationProps?: MapToType<Props, boolean>): void;
+  getBoundingRect(): BoundingRect;
+  getPaintRect(): BoundingRect;
+  calculateTextPosition: ElementCalculateTextPosition;
+  protected static initDefaultProps: void;
+}
+interface CommonStyleProps {
+  shadowBlur?: number;
+  shadowOffsetX?: number;
+  shadowOffsetY?: number;
+  shadowColor?: string;
+  opacity?: number;
+  blend?: string;
+}
+interface DisplayableProps extends ElementProps {
+  style?: Dictionary<any>;
+  zlevel?: number;
+  z?: number;
+  z2?: number;
+  culling?: boolean;
+  cursor?: string;
+  rectHover?: boolean;
+  progressive?: boolean;
+  incremental?: boolean;
+  ignoreCoarsePointer?: boolean;
+  batch?: boolean;
+  invisible?: boolean;
+}
+declare type DisplayableKey = keyof DisplayableProps;
+declare type DisplayablePropertyType = PropType<DisplayableProps, DisplayableKey>;
+declare type DisplayableStatePropNames = ElementStatePropNames | 'style' | 'z' | 'z2' | 'invisible';
+declare type DisplayableState = Pick<DisplayableProps, DisplayableStatePropNames> & ElementCommonState;
+interface Displayable<Props extends DisplayableProps = DisplayableProps> {
+  animate(key?: '', loop?: boolean): Animator<this>;
+  animate(key: 'style', loop?: boolean): Animator<this['style']>;
+  getState(stateName: string): DisplayableState;
+  ensureState(stateName: string): DisplayableState;
+  states: Dictionary<DisplayableState>;
+  stateProxy: (stateName: string) => DisplayableState;
+}
+declare class Displayable<Props extends DisplayableProps = DisplayableProps> extends Element$1<Props> {
+  invisible: boolean;
+  z: number;
+  z2: number;
+  zlevel: number;
+  culling: boolean;
+  cursor: string;
+  rectHover: boolean;
+  incremental: boolean;
+  ignoreCoarsePointer?: boolean;
+  style: Dictionary<any>;
+  protected _normalState: DisplayableState;
+  protected _rect: BoundingRect;
+  protected _paintRect: BoundingRect;
+  protected _prevPaintRect: BoundingRect;
+  dirtyRectTolerance: number;
+  useHoverLayer?: boolean;
+  __hoverStyle?: CommonStyleProps;
+  __clipPaths?: Path[];
+  __canvasFillGradient: CanvasGradient;
+  __canvasStrokeGradient: CanvasGradient;
+  __canvasFillPattern: CanvasPattern;
+  __canvasStrokePattern: CanvasPattern;
+  __svgEl: SVGElement;
+  constructor(props?: Props);
+  protected _init(props?: Props): void;
+  beforeBrush(): void;
+  afterBrush(): void;
+  innerBeforeBrush(): void;
+  innerAfterBrush(): void;
+  shouldBePainted(viewWidth: number, viewHeight: number, considerClipPath: boolean, considerAncestors: boolean): boolean;
+  contain(x: number, y: number): boolean;
+  traverse<Context>(cb: (this: Context, el: this) => void, context?: Context): void;
+  rectContain(x: number, y: number): boolean;
+  getPaintRect(): BoundingRect;
+  setPrevPaintRect(paintRect: BoundingRect): void;
+  getPrevPaintRect(): BoundingRect;
+  animateStyle(loop: boolean): Animator<this["style"]>;
+  updateDuringAnimation(targetKey: string): void;
+  attrKV(key: DisplayableKey, value: DisplayablePropertyType): void;
+  setStyle(obj: Props['style']): this;
+  setStyle<T extends keyof Props['style']>(obj: T, value: Props['style'][T]): this;
+  dirtyStyle(notRedraw?: boolean): void;
+  dirty(): void;
+  styleChanged(): boolean;
+  styleUpdated(): void;
+  createStyle(obj?: Props['style']): Props["style"];
+  useStyle(obj: Props['style']): void;
+  isStyleObject(obj: Props['style']): any;
+  protected _innerSaveToNormal(toState: DisplayableState): void;
+  protected _applyStateObj(stateName: string, state: DisplayableState, normalState: DisplayableState, keepCurrentStates: boolean, transition: boolean, animationCfg: ElementAnimateConfig): void;
+  protected _mergeStates(states: DisplayableState[]): DisplayableState;
+  protected _mergeStyle(targetStyle: CommonStyleProps, sourceStyle: CommonStyleProps): CommonStyleProps;
+  getAnimationStyleProps(): MapToType<DisplayableProps, boolean>;
+  protected static initDefaultProps: void;
+}
+interface PainterBase {
+  type: string;
+  root?: HTMLElement;
+  ssrOnly?: boolean;
+  resize(width?: number | string, height?: number | string): void;
+  refresh(): void;
+  clear(): void;
+  renderToString?(): string;
+  getType: () => string;
+  getWidth(): number;
+  getHeight(): number;
+  dispose(): void;
+  getViewportRoot: () => HTMLElement;
+  getViewportRootOffset: () => {
+    offsetLeft: number;
+    offsetTop: number;
+  };
+  refreshHover(): void;
+  configLayer(zlevel: number, config: Dictionary<any>): void;
+  setBackgroundColor(backgroundColor: string | GradientObject | PatternObject): void;
+}
+interface HandlerProxyInterface extends Eventful {
+  handler: Handler;
+  dispose: () => void;
+  setCursor: (cursorStyle?: string) => void;
+}
+declare function shapeCompareFunc(a: Displayable, b: Displayable): number;
+declare class Storage {
+  private _roots;
+  private _displayList;
+  private _displayListLen;
+  traverse<T>(cb: (this: T, el: Element$1) => void, context?: T): void;
+  getDisplayList(update?: boolean, includeIgnore?: boolean): Displayable[];
+  updateDisplayList(includeIgnore?: boolean): void;
+  private _updateAndAddDisplayable;
+  addRoot(el: Element$1): void;
+  delRoot(el: Element$1 | Element$1[]): void;
+  delAllRoots(): void;
+  getRoots(): Element$1<ElementProps>[];
+  dispose(): void;
+  displayableSortFunc: typeof shapeCompareFunc;
+}
+declare class HoveredResult {
+  x: number;
+  y: number;
+  target: Displayable;
+  topTarget: Displayable;
+  constructor(x?: number, y?: number);
+}
+declare type HandlerName = 'click' | 'dblclick' | 'mousewheel' | 'mouseout' | 'mouseup' | 'mousedown' | 'mousemove' | 'contextmenu';
+declare class Handler extends Eventful {
+  storage: Storage;
+  painter: PainterBase;
+  painterRoot: HTMLElement;
+  proxy: HandlerProxyInterface;
+  private _hovered;
+  private _gestureMgr;
+  private _draggingMgr;
+  private _pointerSize;
+  _downEl: Element$1;
+  _upEl: Element$1;
+  _downPoint: [number, number];
+  constructor(storage: Storage, painter: PainterBase, proxy: HandlerProxyInterface, painterRoot: HTMLElement, pointerSize: number);
+  setHandlerProxy(proxy: HandlerProxyInterface): void;
+  mousemove(event: ZRRawEvent): void;
+  mouseout(event: ZRRawEvent): void;
+  resize(): void;
+  dispatch(eventName: HandlerName, eventArgs?: any): void;
+  dispose(): void;
+  setCursorStyle(cursorStyle: string): void;
+  dispatchToElement(targetInfo: {
+    target?: Element$1;
+    topTarget?: Element$1;
+  }, eventName: ElementEventName, event: ZRRawEvent): void;
+  findHover(x: number, y: number, exclude?: Displayable): HoveredResult;
+  processGesture(event: ZRRawEvent, stage?: 'start' | 'end' | 'change'): void;
+  click: (event: ZRRawEvent) => void;
+  mousedown: (event: ZRRawEvent) => void;
+  mouseup: (event: ZRRawEvent) => void;
+  mousewheel: (event: ZRRawEvent) => void;
+  dblclick: (event: ZRRawEvent) => void;
+  contextmenu: (event: ZRRawEvent) => void;
+}
+interface LayerConfig {
+  clearColor?: string | GradientObject | ImagePatternObject;
+  motionBlur?: boolean;
+  lastFrameAlpha?: number;
+}
+/*!
+* ZRender, a high performance 2d drawing library.
+*
+* Copyright (c) 2013, Baidu Inc.
+* All rights reserved.
+*
+* LICENSE
+* https://github.com/ecomfe/zrender/blob/master/LICENSE.txt
 */
-async function getCore() {
-  if (coreModule) return coreModule;
-  if (!corePromise) corePromise = import("./core.d.ts").then(m => {
-    coreModule = m;
-    return m;
-  });
-  return corePromise;
+declare class ZRender {
+  dom?: HTMLElement;
+  id: number;
+  storage: Storage;
+  painter: PainterBase;
+  handler: Handler;
+  animation: Animation;
+  private _sleepAfterStill;
+  private _stillFrameAccum;
+  private _needsRefresh;
+  private _needsRefreshHover;
+  private _disposed;
+  private _darkMode;
+  private _backgroundColor;
+  constructor(id: number, dom?: HTMLElement, opts?: ZRenderInitOpt);
+  add(el: Element$1): void;
+  remove(el: Element$1): void;
+  configLayer(zLevel: number, config: LayerConfig): void;
+  setBackgroundColor(backgroundColor: string | GradientObject | PatternObject): void;
+  getBackgroundColor(): string | GradientObject | PatternObject;
+  setDarkMode(darkMode: boolean): void;
+  isDarkMode(): boolean;
+  refreshImmediately(fromInside?: boolean): void;
+  refresh(): void;
+  flush(): void;
+  private _flush;
+  setSleepAfterStill(stillFramesCount: number): void;
+  wakeUp(): void;
+  refreshHover(): void;
+  refreshHoverImmediately(): void;
+  resize(opts?: {
+    width?: number | string;
+    height?: number | string;
+  }): void;
+  clearAnimation(): void;
+  getWidth(): number | undefined;
+  getHeight(): number | undefined;
+  setCursorStyle(cursorStyle: string): void;
+  findHover(x: number, y: number): {
+    target: Displayable;
+    topTarget: Displayable;
+  } | undefined;
+  on<Ctx>(eventName: ElementEventName, eventHandler: ElementEventCallback<Ctx, ZRenderType>, context?: Ctx): this;
+  on<Ctx>(eventName: string, eventHandler: WithThisType<EventCallback<any[]>, unknown extends Ctx ? ZRenderType : Ctx>, context?: Ctx): this;
+  off(eventName?: string, eventHandler?: EventCallback): void;
+  trigger(eventName: string, event?: unknown): void;
+  clear(): void;
+  dispose(): void;
+}
+interface ZRenderInitOpt {
+  renderer?: string;
+  devicePixelRatio?: number;
+  width?: number | string;
+  height?: number | string;
+  useDirtyRect?: boolean;
+  useCoarsePointer?: 'auto' | boolean;
+  pointerSize?: number;
+  ssr?: boolean;
 }
+interface ZRenderType extends ZRender {}
+declare const _default: {
+  time: {
+    month: string[];
+    monthAbbr: string[];
+    dayOfWeek: string[];
+    dayOfWeekAbbr: string[];
+  };
+  legend: {
+    selector: {
+      all: string;
+      inverse: string;
+    };
+  };
+  toolbox: {
+    brush: {
+      title: {
+        rect: string;
+        polygon: string;
+        lineX: string;
+        lineY: string;
+        keep: string;
+        clear: string;
+      };
+    };
+    dataView: {
+      title: string;
+      lang: string[];
+    };
+    dataZoom: {
+      title: {
+        zoom: string;
+        back: string;
+      };
+    };
+    magicType: {
+      title: {
+        line: string;
+        bar: string;
+        stack: string;
+        tiled: string;
+      };
+    };
+    restore: {
+      title: string;
+    };
+    saveAsImage: {
+      title: string;
+      lang: string[];
+    };
+  };
+  series: {
+    typeNames: {
+      pie: string;
+      bar: string;
+      line: string;
+      scatter: string;
+      effectScatter: string;
+      radar: string;
+      tree: string;
+      treemap: string;
+      boxplot: string;
+      candlestick: string;
+      k: string;
+      heatmap: string;
+      map: string;
+      parallel: string;
+      lines: string;
+      graph: string;
+      sankey: string;
+      funnel: string;
+      gauge: string;
+      pictorialBar: string;
+      themeRiver: string;
+      sunburst: string;
+      custom: string;
+      chart: string;
+    };
+  };
+  aria: {
+    general: {
+      withTitle: string;
+      withoutTitle: string;
+    };
+    series: {
+      single: {
+        prefix: string;
+        withName: string;
+        withoutName: string;
+      };
+      multiple: {
+        prefix: string;
+        withName: string;
+        withoutName: string;
+        separator: {
+          middle: string;
+          end: string;
+        };
+      };
+    };
+    data: {
+      allData: string;
+      partialData: string;
+      withName: string;
+      withoutName: string;
+      separator: {
+        middle: string;
+        end: string;
+      };
+    };
+  };
+};
+declare type LocaleOption = typeof _default;
+declare type DimensionUserOuputEncode = {
+  [coordOrVisualDimName: string]: DimensionIndex[];
+};
 /**
-* Get the cached core module (null if not yet loaded).
-*/
-function getCoreSync() {
-  return coreModule;
-}
-async function loadAndRegister(core, key, loader) {
-  if (registered.has(key)) return;
-  if (inflight.has(key)) return inflight.get(key);
-  const promise = loader().then(mod => {
-    core.use(mod);
-    registered.add(key);
-    inflight.delete(key);
-  });
-  inflight.set(key, promise);
-  return promise;
+ * If string, e.g., 'geo', means {geoIndex: 0}.
+ * If Object, could contain some of these properties below:
+ * {
+ *     seriesIndex, seriesId, seriesName,
+ *     geoIndex, geoId, geoName,
+ *     bmapIndex, bmapId, bmapName,
+ *     xAxisIndex, xAxisId, xAxisName,
+ *     yAxisIndex, yAxisId, yAxisName,
+ *     gridIndex, gridId, gridName,
+ *     ... (can be extended)
+ * }
+ * Each properties can be number|string|Array.<number>|Array.<string>
+ * For example, a finder could be
+ * {
+ *     seriesIndex: 3,
+ *     geoId: ['aa', 'cc'],
+ *     gridName: ['xx', 'rr']
+ * }
+ * xxxIndex can be set as 'all' (means all xxx) or 'none' (means not specify)
+ * If nothing or null/undefined specified, return nothing.
+ * If both `abcIndex`, `abcId`, `abcName` specified, only one work.
+ * The priority is: index > id > name, the same with `ecModel.queryComponents`.
+ */
+declare type ModelFinderIndexQuery = number | number[] | 'all' | 'none' | false;
+declare type ModelFinderIdQuery = OptionId | OptionId[];
+declare type ModelFinderNameQuery = OptionId | OptionId[];
+declare type ModelFinder = string | ModelFinderObject;
+declare type ModelFinderObject = {
+  seriesIndex?: ModelFinderIndexQuery;
+  seriesId?: ModelFinderIdQuery;
+  seriesName?: ModelFinderNameQuery;
+  geoIndex?: ModelFinderIndexQuery;
+  geoId?: ModelFinderIdQuery;
+  geoName?: ModelFinderNameQuery;
+  bmapIndex?: ModelFinderIndexQuery;
+  bmapId?: ModelFinderIdQuery;
+  bmapName?: ModelFinderNameQuery;
+  xAxisIndex?: ModelFinderIndexQuery;
+  xAxisId?: ModelFinderIdQuery;
+  xAxisName?: ModelFinderNameQuery;
+  yAxisIndex?: ModelFinderIndexQuery;
+  yAxisId?: ModelFinderIdQuery;
+  yAxisName?: ModelFinderNameQuery;
+  gridIndex?: ModelFinderIndexQuery;
+  gridId?: ModelFinderIdQuery;
+  gridName?: ModelFinderNameQuery;
+  matrixIndex?: ModelFinderIndexQuery;
+  matrixId?: ModelFinderIdQuery;
+  matrixName?: ModelFinderNameQuery;
+  dataIndex?: number;
+  dataIndexInside?: number;
+};
+/**
+ * {
+ *     seriesModels: [seriesModel1, seriesModel2],
+ *     seriesModel: seriesModel1, // The first model
+ *     geoModels: [geoModel1, geoModel2],
+ *     geoModel: geoModel1, // The first model
+ *     ...
+ * }
+ */
+interface RichTextTooltipMarker {
+  renderMode: TooltipRenderMode;
+  content: string;
+  style: Dictionary<unknown>;
 }
+declare type TooltipMarker = string | RichTextTooltipMarker;
 /**
-* Analyze an ECharts option object and dynamically import only the
-* required chart types, components, and renderer. All imports are
-* cached — subsequent calls with the same types are instant.
-*/
-async function ensureModules(option, renderer = "canvas") {
-  const core = await getCore();
-  const loads = [];
-  loads.push(loadAndRegister(core, `renderer:${renderer}`, RENDERERS[renderer]));
-  const rawSeries = option.series;
-  const seriesList = rawSeries ? Array.isArray(rawSeries) ? rawSeries : [rawSeries] : [];
-  for (const s of seriesList) {
-    const type = s.type;
-    if (type && CHARTS[type]) loads.push(loadAndRegister(core, `chart:${type}`, CHARTS[type]));
-  }
-  for (const key of Object.keys(option)) if (COMPONENTS[key]) loads.push(loadAndRegister(core, `component:${key}`, COMPONENTS[key]));
-  for (const s of seriesList) for (const key of Object.keys(s)) if (SERIES_FEATURES[key]) loads.push(loadAndRegister(core, `feature:${key}`, SERIES_FEATURES[key]));
-  await Promise.all(loads);
-  return core;
+ * [Notice]:
+ * Consider custom bundle on demand, chart specified
+ * or component specified types and constants should
+ * not put here. Only common types and constants can
+ * be put in this file.
+ */
+declare type RendererType = 'canvas' | 'svg';
+declare type NullUndefined$1 = null | undefined;
+declare type HorizontalAlign = 'left' | 'center' | 'right';
+declare type VerticalAlign = 'top' | 'middle' | 'bottom';
+declare type ColorString = string;
+declare type ZRColor = ColorString | LinearGradientObject | RadialGradientObject | PatternObject;
+declare type ZRLineType = 'solid' | 'dotted' | 'dashed' | number | number[];
+declare type ZRFontStyle = 'normal' | 'italic' | 'oblique';
+declare type ZRFontWeight = 'normal' | 'bold' | 'bolder' | 'lighter' | number;
+declare type ZRElementEventName = ElementEventName | 'globalout';
+declare type ComponentMainType = keyof ECUnitOption & string;
+interface PayloadItem {
+  excludeSeriesId?: OptionId | OptionId[];
+  animation?: PayloadAnimationPart;
+  [other: string]: any;
+}
+interface Payload extends PayloadItem {
+  type: string;
+  escapeConnect?: boolean;
+  batch?: PayloadItem[];
+}
+interface PayloadAnimationPart {
+  duration?: number;
+  easing?: AnimationEasing;
+  delay?: number;
+}
+interface ECElementEvent extends ECEventData, CallbackDataParams {
+  type: ZRElementEventName;
+  event?: ElementEvent;
 }
 /**
-* Manually register ECharts modules (for tree-shaking entry point).
-* Call this at app startup instead of relying on auto-detection.
-*
-* @example
-* ```ts
-* import { use } from '@pyreon/charts/manual'
-* import { BarChart } from 'echarts/charts'
-* import { GridComponent, TooltipComponent } from 'echarts/components'
-* import { CanvasRenderer } from 'echarts/renderers'
-*
-* use(BarChart, GridComponent, TooltipComponent, CanvasRenderer)
-* ```
-*/
-function manualUse(...modules) {
-  const core = getCoreSync();
-  if (core) core.use(modules);else getCore().then(c => c.use(modules));
+ * The echarts event type to user.
+ * Also known as packedEvent.
+ */
+interface ECActionEvent extends ECEventData {
+  type: string;
+  componentType?: string;
+  componentIndex?: number;
+  seriesIndex?: number;
+  escapeConnect?: boolean;
+  batch?: ECEventData[];
 }
-
-//#endregion
-//#region src/use-chart.ts
 /**
-* Reactive ECharts hook. Creates a chart instance bound to a container
-* element, with automatic module lazy-loading, signal tracking, resize
-* handling, error capture, and cleanup.
-*
-* Generic parameter `TOption` narrows the option type for exact autocomplete.
-* Use `ComposeOption<SeriesUnion>` from ECharts to restrict to specific chart types.
-*
-* @example
-* ```tsx
-* // Default — accepts any ECharts option
-* const chart = useChart(() => ({
-*   series: [{ type: 'bar', data: revenue() }],
-* }))
-*
-* // Strict — only bar + line allowed, full autocomplete
-* import type { ComposeOption, BarSeriesOption, LineSeriesOption } from '@pyreon/charts'
-* type MyChartOption = ComposeOption<BarSeriesOption | LineSeriesOption>
-*
-* const chart = useChart<MyChartOption>(() => ({
-*   series: [{ type: 'bar', data: revenue() }],  // ✓
-* }))
-* ```
-*/
-function useChart(optionsFn, config) {
-  const instance = signal(null);
-  const loading = signal(true);
-  const error = signal(null);
-  const container = signal(null);
-  const renderer = config?.renderer ?? "canvas";
-  let observer = null;
-  let initialized = false;
-  effect(() => {
-    const el = container();
-    if (!el || initialized) return;
-    initialized = true;
-    let opts;
-    try {
-      opts = optionsFn();
-    } catch (err) {
-      error.set(err instanceof Error ? err : new Error(String(err)));
-      loading.set(false);
-      return;
-    }
-    ensureModules(opts, renderer).then(core => {
-      if (!container.peek()) return;
-      try {
-        const chart = core.init(el, config?.theme, {
-          renderer,
-          locale: config?.locale,
-          devicePixelRatio: config?.devicePixelRatio,
-          width: config?.width,
-          height: config?.height
-        });
-        chart.setOption(opts);
-        instance.set(chart);
-        loading.set(false);
-        error.set(null);
-        config?.onInit?.(chart);
-        observer = new ResizeObserver(() => {
-          chart.resize();
-        });
-        observer.observe(el);
-      } catch (err) {
-        error.set(err instanceof Error ? err : new Error(String(err)));
-        loading.set(false);
-      }
-    }).catch(err => {
-      error.set(err instanceof Error ? err : new Error(String(err)));
-      loading.set(false);
-    });
-  });
-  effect(() => {
-    const chart = instance();
-    if (!chart) return;
-    try {
-      const opts = optionsFn();
-      chart.setOption(opts, {
-        notMerge: config?.notMerge ?? false,
-        lazyUpdate: config?.lazyUpdate ?? true
-      });
-      error.set(null);
-    } catch (err) {
-      error.set(err instanceof Error ? err : new Error(String(err)));
-    }
-  });
-  onUnmount(() => {
-    observer?.disconnect();
-    observer = null;
-    const chart = instance.peek();
-    if (chart) {
-      chart.dispose();
-      instance.set(null);
-    }
-    initialized = false;
-  });
-  return {
-    ref: el => container.set(el),
-    instance,
-    loading,
-    error,
-    resize: () => instance.peek()?.resize()
-  };
+ * TODO: not applicable in `ECEventProcessor` yet.
+ */
+interface ECEventData {
+  [key: string]: any;
 }
-
-//#endregion
-//#region ../../node_modules/.bun/@pyreon+core@0.6.0/node_modules/@pyreon/core/lib/jsx-runtime.js
 /**
-* Hyperscript function — the compiled output of JSX.
-* `<div class="x">hello</div>` → `h("div", { class: "x" }, "hello")`
-*
-* Generic on P so TypeScript validates props match the component's signature
-* at the call site, then stores the result in the loosely-typed VNode.
-*/
-/** Shared empty props sentinel — identity-checked in mountElement to skip applyProps. */
-
-function h(type, props, ...children) {
-  return {
-    type,
-    props: props ?? EMPTY_PROPS,
-    children: normalizeChildren(children),
-    key: props?.key ?? null
-  };
+ * 'html' is used for rendering tooltip in extra DOM form, and the result
+ * string is used as DOM HTML content.
+ * 'richText' is used for rendering tooltip in rich text form, for those where
+ * DOM operation is not supported.
+ */
+declare type TooltipRenderMode = 'html' | 'richText';
+declare type OrdinalRawValue = string | number;
+declare type OrdinalNumber = number;
+/**
+ * @usage For example,
+ * ```js
+ * { ordinalNumbers: [2, 5, 3, 4] }
+ * ```
+ * means that ordinal 2 should be displayed on tick 0,
+ * ordinal 5 should be displayed on tick 1, ...
+ */
+declare type ParsedValueNumeric = number | OrdinalNumber;
+/**
+ * `ScaleDataValue` represents the user input axis value in echarts API.
+ * (For example, used `axis.min`/`axis.max` in echarts option, `convertToPixel`).
+ * NOTICE:
+ *  `ScaleDataValue` is slightly different from `OptionDataValue` for historical reason.
+ *  `ScaleDataValue` should be parsed by `src/scale/Scale['parse']`.
+ *  `OptionDataValue` should be parsed by `src/data/helper/dataValueHelper.parseDataValue`.
+ * FIXME:
+ *  Make `ScaleDataValue` `OptionDataValue` consistent? Since numeric string (like `'123'`) is accepted
+ *  in `series.data` and is effectively accepted in some axis relevant option (e.g., `axis.min/max`),
+ *  `type ScaleDataValue` should also include it for consistency. But it might bring some breaking in
+ *  TS interface (user callback) and need comprehensive checks for all of the parsing of `ScaleDataValue`.
+ */
+declare type ScaleDataValue = ParsedValueNumeric | OrdinalRawValue | Date;
+/**
+ * - `ScaleDataValue`:
+ *   e.g. geo accept that primitive input, like `convertToPixel('some_place')`;
+ *   Some coord sys, such as 'cartesian2d', also supports that for only query only a single axis.
+ * - `ScaleDataValue[]`:
+ *   This is the most common case, each array item represent each data in
+ *   every dimension required by the coord sys. e.g., `[12, 98]` represents `[xData, yData]`.
+ * - `(ScaleDataValue[])[]`:
+ *   represents `[data_range_x, data_range_y]`. e.g., `dataToPoint([[5, 600], [8889, 9000]])`,
+ *   represents data range `[5, 600]` in x, and `[8889, 9000]` in y.
+ *   Can be also `[5, [8999, 9000]]`.
+ */
+declare type CoordinateSystemDataCoord = (ScaleDataValue | NullUndefined$1) | (ScaleDataValue | NullUndefined$1)[] | (ScaleDataValue | ScaleDataValue[] | NullUndefined$1)[];
+/**
+ * Return type of API `CoordinateSystem['dataToLayout']`, expose to users.
+ */
+interface CoordinateSystemDataLayout {
+  rect?: RectLike;
+  contentRect?: RectLike;
+  matrixXYLocatorRange?: number[][];
 }
-function normalizeChildren(children) {
-  for (let i = 0; i < children.length; i++) if (Array.isArray(children[i])) return flattenChildren(children);
-  return children;
+declare type DimensionIndex = number;
+declare type DimensionIndexLoose = DimensionIndex | string;
+declare type DimensionName = string;
+declare type DimensionLoose = DimensionName | DimensionIndexLoose;
+declare type SeriesDataType = 'main' | 'node' | 'edge';
+/**
+ * [ECUnitOption]:
+ * An object that contains definitions of components
+ * and other properties. For example:
+ *
+ * ```ts
+ * let option: ECUnitOption = {
+ *
+ *     // Single `title` component:
+ *     title: {...},
+ *
+ *     // Two `visualMap` components:
+ *     visualMap: [{...}, {...}],
+ *
+ *     // Two `series.bar` components
+ *     // and one `series.pie` component:
+ *     series: [
+ *         {type: 'bar', data: [...]},
+ *         {type: 'bar', data: [...]},
+ *         {type: 'pie', data: [...]}
+ *     ],
+ *
+ *     // A property:
+ *     backgroundColor: '#421ae4'
+ *
+ *     // A property object:
+ *     textStyle: {
+ *         color: 'red',
+ *         fontSize: 20
+ *     }
+ * };
+ * ```
+ */
+declare type ECUnitOption = {
+  baseOption?: unknown;
+  options?: unknown;
+  media?: unknown;
+  timeline?: ComponentOption | ComponentOption[];
+  backgroundColor?: ZRColor;
+  darkMode?: boolean | 'auto';
+  textStyle?: GlobalTextStyleOption;
+  useUTC?: boolean;
+  hoverLayerThreshold?: number;
+  legacyViewCoordSysCenterBase?: boolean;
+  [key: string]: ComponentOption | ComponentOption[] | Dictionary<unknown> | unknown;
+  stateAnimation?: AnimationOption$1;
+} & AnimationOptionMixin & ColorPaletteOptionMixin;
+/**
+ * [ECOption]:
+ * An object input to echarts.setOption(option).
+ * May be an 'option: ECUnitOption',
+ * or may be an object contains multi-options. For example:
+ *
+ * ```ts
+ * let option: ECOption = {
+ *     baseOption: {
+ *         title: {...},
+ *         legend: {...},
+ *         series: [
+ *             {data: [...]},
+ *             {data: [...]},
+ *             ...
+ *         ]
+ *     },
+ *     timeline: {...},
+ *     options: [
+ *         {title: {...}, series: {data: [...]}},
+ *         {title: {...}, series: {data: [...]}},
+ *         ...
+ *     ],
+ *     media: [
+ *         {
+ *             query: {maxWidth: 320},
+ *             option: {series: {x: 20}, visualMap: {show: false}}
+ *         },
+ *         {
+ *             query: {minWidth: 320, maxWidth: 720},
+ *             option: {series: {x: 500}, visualMap: {show: true}}
+ *         },
+ *         {
+ *             option: {series: {x: 1200}, visualMap: {show: true}}
+ *         }
+ *     ]
+ * };
+ * ```
+ */
+interface ECBasicOption extends ECUnitOption {
+  baseOption?: ECUnitOption;
+  timeline?: ComponentOption | ComponentOption[];
+  options?: ECUnitOption[];
+  media?: MediaUnit[];
 }
-function flattenChildren(children) {
-  const result = [];
-  for (const child of children) if (Array.isArray(child)) result.push(...flattenChildren(child));else result.push(child);
-  return result;
+declare type OptionDataItem = OptionDataValue | Dictionary<OptionDataValue> | OptionDataValue[] | OptionDataItemObject<OptionDataValue>;
+declare type OptionDataItemObject<T> = {
+  id?: OptionId;
+  name?: OptionName;
+  groupId?: OptionId;
+  childGroupId?: OptionId;
+  value?: T[] | T;
+  selected?: boolean;
+};
+declare type OptionId = string | number;
+declare type OptionName = string | number;
+declare type OptionDataValue = string | number | Date | null | undefined;
+declare type ThemeOption = Dictionary<any>;
+declare type DisplayState = 'normal' | 'emphasis' | 'blur' | 'select';
+interface CallbackDataParams {
+  componentType: string;
+  componentSubType: string;
+  componentIndex: number;
+  seriesType?: string;
+  seriesIndex?: number;
+  seriesId?: string;
+  seriesName?: string;
+  name: string;
+  dataIndex: number;
+  data: OptionDataItem;
+  dataType?: SeriesDataType;
+  value: OptionDataItem | OptionDataValue;
+  color?: ZRColor;
+  borderColor?: string;
+  dimensionNames?: DimensionName[];
+  encode?: DimensionUserOuputEncode;
+  marker?: TooltipMarker;
+  status?: DisplayState;
+  dimensionIndex?: number;
+  percent?: number;
+  $vars: string[];
+}
+interface MediaQuery {
+  minWidth?: number;
+  maxWidth?: number;
+  minHeight?: number;
+  maxHeight?: number;
+  minAspectRatio?: number;
+  maxAspectRatio?: number;
+}
+declare type MediaUnit = {
+  query?: MediaQuery;
+  option: ECUnitOption;
+};
+interface ColorPaletteOptionMixin {
+  color?: ZRColor | ZRColor[];
+  colorLayer?: ZRColor[][];
 }
 /**
-* JSX automatic runtime.
-*
-* When tsconfig has `"jsxImportSource": "@pyreon/core"`, the TS/bundler compiler
-* rewrites JSX to imports from this file automatically:
-*   <div class="x" />  →  jsx("div", { class: "x" })
-*/
-function jsx(type, props, key) {
-  const {
-    children,
-    ...rest
-  } = props;
-  const propsWithKey = key != null ? {
-    ...rest,
-    key
-  } : rest;
-  if (typeof type === "function") return h(type, children !== void 0 ? {
-    ...propsWithKey,
-    children
-  } : propsWithKey);
-  return h(type, propsWithKey, ...(children === void 0 ? [] : Array.isArray(children) ? children : [children]));
+ * Mixin of option set to control the box layout of each component.
+ */
+interface ShadowOptionMixin {
+  shadowBlur?: number;
+  shadowColor?: ColorString;
+  shadowOffsetX?: number;
+  shadowOffsetY?: number;
 }
-
+declare type AnimationDelayCallbackParam = {
+  count: number;
+  index: number;
+};
+declare type AnimationDurationCallback = (idx: number) => number;
+declare type AnimationDelayCallback = (idx: number, params?: AnimationDelayCallbackParam) => number;
+interface AnimationOption$1 {
+  duration?: number;
+  easing?: AnimationEasing;
+  delay?: number;
+}
+/**
+ * Mixin of option set to control the animation of series.
+ */
+interface AnimationOptionMixin {
+  /**
+   * If enable animation
+   */
+  animation?: boolean;
+  /**
+   * Disable animation when the number of elements exceeds the threshold
+   */
+  animationThreshold?: number;
+  /**
+   * Duration of initialize animation.
+   * Can be a callback to specify duration of each element
+   */
+  animationDuration?: number | AnimationDurationCallback;
+  /**
+   * Easing of initialize animation
+   */
+  animationEasing?: AnimationEasing;
+  /**
+   * Delay of initialize animation
+   * Can be a callback to specify duration of each element
+   */
+  animationDelay?: number | AnimationDelayCallback;
+  /**
+   * Delay of data update animation.
+   * Can be a callback to specify duration of each element
+   */
+  animationDurationUpdate?: number | AnimationDurationCallback;
+  /**
+   * Easing of data update animation.
+   */
+  animationEasingUpdate?: AnimationEasing;
+  /**
+   * Delay of data update animation.
+   * Can be a callback to specify duration of each element
+   */
+  animationDelayUpdate?: number | AnimationDelayCallback;
+}
+declare type TextCommonOptionNuanceBase = Record<string, unknown>;
+declare type TextCommonOptionNuanceDefault = {};
+declare type LabelStyleColorString = ColorString | 'inherit' | 'auto';
+interface TextCommonOption<TNuance extends TextCommonOptionNuanceBase = TextCommonOptionNuanceDefault> extends ShadowOptionMixin {
+  color?: 'color' extends keyof TNuance ? (TNuance['color'] | LabelStyleColorString) : LabelStyleColorString;
+  fontStyle?: ZRFontStyle;
+  fontWeight?: ZRFontWeight;
+  fontFamily?: string;
+  fontSize?: number | string;
+  align?: HorizontalAlign;
+  verticalAlign?: VerticalAlign;
+  baseline?: VerticalAlign;
+  opacity?: number;
+  lineHeight?: number;
+  backgroundColor?: ColorString | {
+    image: ImageLike | string;
+  };
+  borderColor?: string;
+  borderWidth?: number;
+  borderType?: ZRLineType;
+  borderDashOffset?: number;
+  borderRadius?: number | number[];
+  padding?: number | number[];
+  /**
+   * Currently margin related options are not declared here. They are not supported in rich text.
+   * @see {LabelCommonOption}
+   */
+  width?: number | string;
+  height?: number;
+  textBorderColor?: string;
+  textBorderWidth?: number;
+  textBorderType?: ZRLineType;
+  textBorderDashOffset?: number;
+  textShadowBlur?: number;
+  textShadowColor?: string;
+  textShadowOffsetX?: number;
+  textShadowOffsetY?: number;
+  tag?: string;
+}
+declare type GlobalTextStyleOption = Pick<TextCommonOption, 'color' | 'opacity' | 'fontStyle' | 'fontWeight' | 'fontSize' | 'fontFamily' | 'textShadowColor' | 'textShadowBlur' | 'textShadowOffsetX' | 'textShadowOffsetY' | 'textBorderColor' | 'textBorderWidth' | 'textBorderType' | 'textBorderDashOffset'>;
+interface ComponentOption {
+  mainType?: string;
+  type?: string;
+  id?: OptionId;
+  name?: OptionName;
+  z?: number;
+  zlevel?: number;
+  coordinateSystem?: string;
+  coordinateSystemUsage?: CoordinateSystemUsageOption;
+  coord?: CoordinateSystemDataCoord;
+}
+/**
+ * - "data": Use it as "dataCoordSys", each data item is laid out based on a coord sys.
+ * - "box": Use it as "boxCoordSys", the overall bounding rect or anchor point is calculated based on a coord sys.
+ *   e.g.,
+ *      grid rect (cartesian rect) is calculate based on matrix/calendar coord sys;
+ *      pie center is calculated based on calendar/cartesian;
+ *
+ * The default value (if not declared in option `coordinateSystemUsage`):
+ *  For series, be "data", since this is the most case and backward compatible.
+ *  For non-series components, be "box", since "data" is not applicable.
+ */
+declare type CoordinateSystemUsageOption = 'data' | 'box';
+/**
+ * Caution: If the mechanism should be changed some day, these cases
+ * should be considered:
+ *
+ * (1) In `merge option` mode, if using the same option to call `setOption`
+ * many times, the result should be the same (try our best to ensure that).
+ * (2) In `merge option` mode, if a component has no id/name specified, it
+ * will be merged by index, and the result sequence of the components is
+ * consistent to the original sequence.
+ * (3) In `replaceMerge` mode, keep the result sequence of the components is
+ * consistent to the original sequence, even though there might result in "hole".
+ * (4) `reset` feature (in toolbox). Find detailed info in comments about
+ * `mergeOption` in module:echarts/model/OptionManager.
+ */
+interface GlobalModelSetOptionOpts {
+  replaceMerge: ComponentMainType | ComponentMainType[];
+}
+interface UpdateLifecycleTransitionSeriesFinder {
+  seriesIndex?: ModelFinderIndexQuery;
+  seriesId?: ModelFinderIdQuery;
+  dimension: DimensionLoose;
+}
+interface UpdateLifecycleTransitionItem {
+  from?: UpdateLifecycleTransitionSeriesFinder | UpdateLifecycleTransitionSeriesFinder[];
+  to: UpdateLifecycleTransitionSeriesFinder | UpdateLifecycleTransitionSeriesFinder[];
+}
+declare type UpdateLifecycleTransitionOpt = UpdateLifecycleTransitionItem | UpdateLifecycleTransitionItem[];
+declare type ModelFinder$1 = ModelFinder;
+declare const IN_MAIN_PROCESS_KEY: "__flagInMainProcess";
+declare const MAIN_PROCESS_VERSION_KEY: "__mainProcessVersion";
+declare const PENDING_UPDATE: "__pendingUpdate";
+declare const STATUS_NEEDS_UPDATE_KEY: "__needsUpdateStatus";
+declare const CONNECT_STATUS_KEY: "__connectUpdateStatus";
+declare type SetOptionTransitionOpt = UpdateLifecycleTransitionOpt;
+interface SetOptionOpts$1 {
+  notMerge?: boolean;
+  lazyUpdate?: boolean;
+  silent?: boolean;
+  replaceMerge?: GlobalModelSetOptionOpts['replaceMerge'];
+  transition?: SetOptionTransitionOpt;
+}
+interface ResizeOpts {
+  width?: number | 'auto';
+  height?: number | 'auto';
+  animation?: AnimationOption$1;
+  silent?: boolean;
+}
+interface SetThemeOpts {
+  silent?: boolean;
+}
+declare type RenderedEventParam = {
+  elapsedTime: number;
+};
+declare type ECEventDefinition = { [key in ZRElementEventName]: EventCallbackSingleParam<ECElementEvent> } & {
+  rendered: EventCallbackSingleParam<RenderedEventParam>;
+  finished: () => void | boolean;
+} & {
+  [key: string]: (...args: unknown[]) => void | boolean;
+};
+declare type EChartsInitOpts = {
+  locale?: string | LocaleOption;
+  renderer?: RendererType;
+  devicePixelRatio?: number;
+  useDirtyRect?: boolean;
+  useCoarsePointer?: boolean;
+  pointerSize?: number;
+  ssr?: boolean;
+  width?: number | string;
+  height?: number | string;
+};
+declare class ECharts extends Eventful<ECEventDefinition> {
+  /**
+   * @readonly
+   */
+  id: string;
+  /**
+   * Group id
+   * @readonly
+   */
+  group: string;
+  private _ssr;
+  private _zr;
+  private _dom;
+  private _model;
+  private _throttledZrFlush;
+  private _theme;
+  private _locale;
+  private _chartsViews;
+  private _chartsMap;
+  private _componentsViews;
+  private _componentsMap;
+  private _coordSysMgr;
+  private _api;
+  private _scheduler;
+  private _messageCenter;
+  private _pendingActions;
+  protected _$eventProcessor: never;
+  private _disposed;
+  private _loadingFX;
+  private [PENDING_UPDATE];
+  private [IN_MAIN_PROCESS_KEY];
+  private [MAIN_PROCESS_VERSION_KEY];
+  private [CONNECT_STATUS_KEY];
+  private [STATUS_NEEDS_UPDATE_KEY];
+  constructor(dom: HTMLElement, theme?: string | ThemeOption, opts?: EChartsInitOpts);
+  private _onframe;
+  getDom(): HTMLElement;
+  getId(): string;
+  getZr(): ZRenderType;
+  isSSR(): boolean;
+  /**
+   * Usage:
+   * chart.setOption(option, notMerge, lazyUpdate);
+   * chart.setOption(option, {
+   *     notMerge: ...,
+   *     lazyUpdate: ...,
+   *     silent: ...
+   * });
+   *
+   * @param opts opts or notMerge.
+   * @param opts.notMerge Default `false`.
+   * @param opts.lazyUpdate Default `false`. Useful when setOption frequently.
+   * @param opts.silent Default `false`.
+   * @param opts.replaceMerge Default undefined.
+   */
+  setOption<Opt extends ECBasicOption>(option: Opt, notMerge?: boolean, lazyUpdate?: boolean): void;
+  setOption<Opt extends ECBasicOption>(option: Opt, opts?: SetOptionOpts$1): void;
+  /**
+   * Update theme with name or theme option and repaint the chart.
+   * @param theme Theme name or theme option.
+   * @param opts Optional settings
+   */
+  setTheme(theme: string | ThemeOption, opts?: SetThemeOpts): void;
+  private _updateTheme;
+  private getModel;
+  getOption(): ECBasicOption;
+  getWidth(): number;
+  getHeight(): number;
+  getDevicePixelRatio(): number;
+  /**
+   * Get canvas which has all thing rendered
+   * @deprecated Use renderToCanvas instead.
+   */
+  getRenderedCanvas(opts?: any): HTMLCanvasElement;
+  renderToCanvas(opts?: {
+    backgroundColor?: ZRColor;
+    pixelRatio?: number;
+  }): HTMLCanvasElement;
+  renderToSVGString(opts?: {
+    useViewBox?: boolean;
+  }): string;
+  /**
+   * Get svg data url
+   */
+  getSvgDataURL(): string;
+  getDataURL(opts?: {
+    type?: 'png' | 'jpeg' | 'svg';
+    pixelRatio?: number;
+    backgroundColor?: ZRColor;
+    excludeComponents?: ComponentMainType[];
+  }): string;
+  getConnectedDataURL(opts?: {
+    type?: 'png' | 'jpeg' | 'svg';
+    pixelRatio?: number;
+    backgroundColor?: ZRColor;
+    connectedBackgroundColor?: ZRColor;
+    excludeComponents?: string[];
+  }): string;
+  /**
+   * Convert from logical coordinate system to pixel coordinate system.
+   * See CoordinateSystem#convertToPixel.
+   *
+   * TODO / PENDING:
+   *  currently `convertToPixel` `convertFromPixel` `convertToLayout` may not be suitable
+   *  for some extremely performance-sensitive scenarios (such as, handling massive amounts of data),
+   *  since it performce "find component" every time.
+   *  And it is not friendly to the nuances between different coordinate systems.
+   *  @see https://github.com/apache/echarts/issues/20985 for details
+   *
+   * @see CoordinateSystem['dataToPoint'] for parameters and return.
+   * @see CoordinateSystemDataCoord
+   */
+  convertToPixel(finder: ModelFinder$1, value: ScaleDataValue): number;
+  convertToPixel(finder: ModelFinder$1, value: ScaleDataValue[]): number[];
+  convertToPixel(finder: ModelFinder$1, value: ScaleDataValue | ScaleDataValue[]): number | number[];
+  convertToPixel(finder: ModelFinder$1, value: (ScaleDataValue | ScaleDataValue[] | NullUndefined$1)[]): number | number[];
+  /**
+   * Convert from logical coordinate system to pixel coordinate system.
+   * See CoordinateSystem#convertToPixel.
+   *
+   * @see CoordinateSystem['dataToLayout'] for parameters and return.
+   * @see CoordinateSystemDataCoord
+   */
+  convertToLayout(finder: ModelFinder$1, value: (ScaleDataValue | NullUndefined$1) | (ScaleDataValue | ScaleDataValue[] | NullUndefined$1)[], opt?: unknown): CoordinateSystemDataLayout;
+  /**
+   * Convert from pixel coordinate system to logical coordinate system.
+   * See CoordinateSystem#convertFromPixel.
+   *
+   * @see CoordinateSystem['pointToData'] for parameters and return.
+   */
+  convertFromPixel(finder: ModelFinder$1, value: number): number;
+  convertFromPixel(finder: ModelFinder$1, value: number[]): number[];
+  convertFromPixel(finder: ModelFinder$1, value: number | number[]): number | number[];
+  /**
+   * Is the specified coordinate systems or components contain the given pixel point.
+   * @param {Array|number} value
+   * @return {boolean} result
+   */
+  containPixel(finder: ModelFinder$1, value: number[]): boolean;
+  /**
+   * Get visual from series or data.
+   * @param finder
+   *        If string, e.g., 'series', means {seriesIndex: 0}.
+   *        If Object, could contain some of these properties below:
+   *        {
+   *            seriesIndex / seriesId / seriesName,
+   *            dataIndex / dataIndexInside
+   *        }
+   *        If dataIndex is not specified, series visual will be fetched,
+   *        but not data item visual.
+   *        If all of seriesIndex, seriesId, seriesName are not specified,
+   *        visual will be fetched from first series.
+   * @param visualType 'color', 'symbol', 'symbolSize'
+   */
+  getVisual(finder: ModelFinder$1, visualType: string): string | number | number[] | PatternObject | LinearGradientObject | RadialGradientObject;
+  /**
+   * Get view of corresponding component model
+   */
+  private getViewOfComponentModel;
+  /**
+   * Get view of corresponding series model
+   */
+  private getViewOfSeriesModel;
+  private _initEvents;
+  isDisposed(): boolean;
+  clear(): void;
+  dispose(): void;
+  /**
+   * Resize the chart
+   */
+  resize(opts?: ResizeOpts): void;
+  /**
+   * Show loading effect
+   * @param name 'default' by default
+   * @param cfg cfg of registered loading effect
+   */
+  showLoading(cfg?: object): void;
+  showLoading(name?: string, cfg?: object): void;
+  /**
+   * Hide loading effect
+   */
+  hideLoading(): void;
+  makeActionFromEvent(eventObj: ECActionEvent): Payload;
+  /**
+   * @param opt If pass boolean, means opt.silent
+   * @param opt.silent Default `false`. Whether trigger events.
+   * @param opt.flush Default `undefined`.
+   *        true: Flush immediately, and then pixel in canvas can be fetched
+   *            immediately. Caution: it might affect performance.
+   *        false: Not flush.
+   *        undefined: Auto decide whether perform flush.
+   */
+  dispatchAction(payload: Payload, opt?: boolean | {
+    silent?: boolean;
+    flush?: boolean | undefined;
+  }): void;
+  updateLabelLayout(): void;
+  appendData(params: {
+    seriesIndex: number;
+    data: any;
+  }): void;
+  private static internalField;
+}
+/**
+ * @param opts.devicePixelRatio Use window.devicePixelRatio by default
+ * @param opts.renderer Can choose 'canvas' or 'svg' to render the chart.
+ * @param opts.width Use clientWidth of the input `dom` by default.
+ *        Can be 'auto' (the same as null/undefined)
+ * @param opts.height Use clientHeight of the input `dom` by default.
+ *        Can be 'auto' (the same as null/undefined)
+ * @param opts.locale Specify the locale.
+ * @param opts.useDirtyRect Enable dirty rectangle rendering or not.
+ */
+interface EChartsType extends ECharts {}
 //#endregion
-//#region src/chart-component.tsx
+//#region src/types.d.ts
+/** Chart event params — duck-typed to work across echarts entry points */
+interface ChartEventParams {
+  componentType?: string;
+  seriesType?: string;
+  seriesIndex?: number;
+  seriesName?: string;
+  name?: string;
+  dataIndex?: number;
+  data?: unknown;
+  dataType?: string;
+  value?: unknown;
+  color?: string;
+  event?: Event;
+  [key: string]: unknown;
+}
 /**
-* Reactive chart component. Wraps useChart in a div with automatic
-* event binding.
-*
-* @example
-* ```tsx
-* // Default — any chart type
-* <Chart
-*   options={() => ({
-*     series: [{ type: 'bar', data: revenue() }],
-*     tooltip: {},
-*   })}
-*   style="height: 400px"
-* />
-*
-* // Strict — only specific chart types
-* import type { ComposeOption, BarSeriesOption } from '@pyreon/charts'
-* <Chart<ComposeOption<BarSeriesOption>>
-*   options={() => ({
-*     series: [{ type: 'bar', data: revenue() }],
-*   })}
-*   style="height: 400px"
-* />
-* ```
-*/
-function Chart(props) {
-  const chart = useChart(props.options, {
-    theme: props.theme,
-    renderer: props.renderer
-  });
-  effect(() => {
-    const inst = chart.instance();
-    if (!inst) return;
-    if (props.onClick) inst.on("click", props.onClick);
-    if (props.onMouseover) inst.on("mouseover", props.onMouseover);
-    if (props.onMouseout) inst.on("mouseout", props.onMouseout);
-  });
-  return () => /* @__PURE__ */jsx("div", {
-    ref: chart.ref,
-    style: props.style,
-    class: props.class
-  });
+ * Configuration for useChart.
+ */
+interface UseChartConfig {
+  /** ECharts theme — 'dark', a registered theme name, or a theme object */
+  theme?: string | Record<string, unknown>;
+  /** Renderer — 'canvas' (default, best performance) or 'svg' */
+  renderer?: 'canvas' | 'svg';
+  /** ECharts locale — 'EN' (default), 'ZH', etc. */
+  locale?: string;
+  /** Whether to replace all options instead of merging — default: false */
+  notMerge?: boolean;
+  /** Whether to batch updates — default: true */
+  lazyUpdate?: boolean;
+  /** Device pixel ratio — default: window.devicePixelRatio */
+  devicePixelRatio?: number;
+  /** Width override — default: container width */
+  width?: number;
+  /** Height override — default: container height */
+  height?: number;
+  /** Called when chart instance is created */
+  onInit?: (instance: EChartsType) => void;
 }
-
+/**
+ * Return type of useChart.
+ */
+interface UseChartResult {
+  /** Bind to container element via ref */
+  ref: (el: Element | null) => void;
+  /** The ECharts instance — null until mounted and modules loaded */
+  instance: Signal<EChartsType | null>;
+  /** True while ECharts modules are being dynamically imported */
+  loading: Signal<boolean>;
+  /** Error signal — set if chart init or setOption throws */
+  error: Signal<Error | null>;
+  /** Manually trigger resize */
+  resize: () => void;
+}
+/**
+ * Props for the <Chart /> component.
+ * Generic parameter narrows the option type for exact autocomplete.
+ */
+interface ChartProps<TOption extends EChartsOption = EChartsOption> extends Props {
+  /** Reactive ECharts option config — fully typed */
+  options: () => TOption;
+  /** ECharts theme */
+  theme?: string | Record<string, unknown>;
+  /** Renderer — 'canvas' (default) or 'svg' */
+  renderer?: 'canvas' | 'svg';
+  /** CSS style for the container div */
+  style?: string;
+  /** CSS class for the container div */
+  class?: string;
+  /** Click event handler */
+  onClick?: (params: ChartEventParams) => void;
+  /** Mouseover event handler */
+  onMouseover?: (params: ChartEventParams) => void;
+  /** Mouseout event handler */
+  onMouseout?: (params: ChartEventParams) => void;
+}
+//#endregion
+//#region src/chart-component.d.ts
+/**
+ * Reactive chart component. Wraps useChart in a div with automatic
+ * event binding.
+ *
+ * @example
+ * ```tsx
+ * // Default — any chart type
+ * <Chart
+ *   options={() => ({
+ *     series: [{ type: 'bar', data: revenue() }],
+ *     tooltip: {},
+ *   })}
+ *   style="height: 400px"
+ * />
+ *
+ * // Strict — only specific chart types
+ * import type { ComposeOption, BarSeriesOption } from '@pyreon/charts'
+ * <Chart<ComposeOption<BarSeriesOption>>
+ *   options={() => ({
+ *     series: [{ type: 'bar', data: revenue() }],
+ *   })}
+ *   style="height: 400px"
+ * />
+ * ```
+ */
+declare function Chart<TOption extends EChartsOption$1 = EChartsOption$1>(props: ChartProps<TOption>): VNodeChild;
+//#endregion
+//#region src/loader.d.ts
+/**
+ * Manually register ECharts modules (for tree-shaking entry point).
+ * Call this at app startup instead of relying on auto-detection.
+ *
+ * @example
+ * ```ts
+ * import { use } from '@pyreon/charts/manual'
+ * import { BarChart } from 'echarts/charts'
+ * import { GridComponent, TooltipComponent } from 'echarts/components'
+ * import { CanvasRenderer } from 'echarts/renderers'
+ *
+ * use(BarChart, GridComponent, TooltipComponent, CanvasRenderer)
+ * ```
+ */
+declare function manualUse(...modules: unknown[]): void;
+//#endregion
+//#region src/use-chart.d.ts
+/**
+ * Reactive ECharts hook. Creates a chart instance bound to a container
+ * element, with automatic module lazy-loading, signal tracking, resize
+ * handling, error capture, and cleanup.
+ *
+ * Generic parameter `TOption` narrows the option type for exact autocomplete.
+ * Use `ComposeOption<SeriesUnion>` from ECharts to restrict to specific chart types.
+ *
+ * @example
+ * ```tsx
+ * // Default — accepts any ECharts option
+ * const chart = useChart(() => ({
+ *   series: [{ type: 'bar', data: revenue() }],
+ * }))
+ *
+ * // Strict — only bar + line allowed, full autocomplete
+ * import type { ComposeOption, BarSeriesOption, LineSeriesOption } from '@pyreon/charts'
+ * type MyChartOption = ComposeOption<BarSeriesOption | LineSeriesOption>
+ *
+ * const chart = useChart<MyChartOption>(() => ({
+ *   series: [{ type: 'bar', data: revenue() }],  // ✓
+ * }))
+ * ```
+ */
+declare function useChart<TOption extends EChartsOption$1 = EChartsOption$1>(optionsFn: () => TOption, config?: UseChartConfig): UseChartResult;
 //#endregion
-export { Chart, manualUse as use, useChart };
-//# sourceMappingURL=manual.d.ts.map
+export { Chart, type ChartProps, type EChartsOption, type UseChartConfig, type UseChartResult, manualUse as use, useChart };
+//# sourceMappingURL=manual2.d.ts.map