@visactor/vchart 2.1.3-alpha.2 → 2.1.3-alpha.4

package/build/index.js

@@ -11730,7 +11730,17 @@
     });
 
     class Application {}
-    const application = new Application();
+    const APPLICATION_STATE_SYMBOL = Symbol.for("@visactor/vrender-core/application-state");
+    function createApplicationState() {
+      return {
+        application: new Application()
+      };
+    }
+    function getApplicationState() {
+      const scope = globalThis;
+      return scope[APPLICATION_STATE_SYMBOL] || (scope[APPLICATION_STATE_SYMBOL] = createApplicationState()), scope[APPLICATION_STATE_SYMBOL];
+    }
+    const application = getApplicationState().application;
 
     class ResourceLoader {
       static GetImage(url, mark) {
@@ -19046,7 +19056,6 @@
         }
       };
     }
-    const sharedGraphicFactory = new GraphicFactory();
     class GraphicCreator {
       constructor() {
         this.store = new Map();
@@ -19061,13 +19070,25 @@
         return this.store.has(name) ? createGraphic$1(name, attributes) : null;
       }
     }
-    const graphicCreator$1 = new GraphicCreator();
+    const GRAPHIC_REGISTRY_SYMBOL = Symbol.for("@visactor/vrender-core/graphic-registry");
+    function createGraphicRegistryState() {
+      return {
+        graphicCreator: new GraphicCreator(),
+        graphicFactory: new GraphicFactory()
+      };
+    }
+    function getGraphicRegistryState() {
+      const scope = globalThis;
+      return scope[GRAPHIC_REGISTRY_SYMBOL] || (scope[GRAPHIC_REGISTRY_SYMBOL] = createGraphicRegistryState()), scope[GRAPHIC_REGISTRY_SYMBOL];
+    }
+    const sharedGraphicRegistry = getGraphicRegistryState();
+    const graphicCreator$1 = sharedGraphicRegistry.graphicCreator;
     function registerGraphic(name, creator) {
       if (!name) throw new Error("Graphic registration requires a non-empty graphic type");
-      graphicCreator$1.registerStore(name, creator), sharedGraphicFactory.register(name, createGraphicCtor(creator));
+      graphicCreator$1.registerStore(name, creator), sharedGraphicRegistry.graphicFactory.register(name, createGraphicCtor(creator));
     }
     function createGraphic$1(name, attributes) {
-      return sharedGraphicFactory.create(name, attributes);
+      return sharedGraphicRegistry.graphicFactory.create(name, attributes);
     }
 
     class Hook {
@@ -19776,6 +19797,17 @@
       }
     }
 
+    const FACTORY_STATE_SYMBOL = Symbol.for("@visactor/vrender-core/factory-state");
+    function createFactoryState() {
+      return {
+        pluginClasses: {}
+      };
+    }
+    function getFactoryState() {
+      const scope = globalThis;
+      return scope[FACTORY_STATE_SYMBOL] || (scope[FACTORY_STATE_SYMBOL] = createFactoryState()), scope[FACTORY_STATE_SYMBOL];
+    }
+
     class DefaultGlobalPickerService {
       constructor() {
         this.global = application.global, this.global.hooks.onSetEnv.tap("global-picker-service", (lastEnv, env, global) => {
@@ -21637,7 +21669,7 @@
         return Factory._pluginClasses[pluginKey];
       }
     };
-    Factory$1._pluginClasses = {};
+    Factory$1._pluginClasses = getFactoryState().pluginClasses;
 
     function defaultLayerHandlerFactory(layerMode) {
       const handlerFactory = application.layerHandlerFactory;
@@ -21717,6 +21749,17 @@
     const DynamicLayerHandlerContribution = Symbol.for("DynamicLayerHandlerContribution");
     const VirtualLayerHandlerContribution = Symbol.for("VirtualLayerHandlerContribution");
 
+    const CONTRIBUTION_STORE_STATE_SYMBOL = Symbol.for("@visactor/vrender-core/contribution-store-state");
+    function createContributionStoreState() {
+      return {
+        store: new Map()
+      };
+    }
+    function getContributionStoreState() {
+      const scope = globalThis;
+      return scope[CONTRIBUTION_STORE_STATE_SYMBOL] || (scope[CONTRIBUTION_STORE_STATE_SYMBOL] = createContributionStoreState()), scope[CONTRIBUTION_STORE_STATE_SYMBOL];
+    }
+
     const ContributionProvider = Symbol("ContributionProvider");
     class ContributionProviderCache {
       constructor(serviceIdentifier, container) {
@@ -21759,7 +21802,7 @@
         });
       }
     }
-    ContributionStore.store = new Map();
+    ContributionStore.store = getContributionStoreState().store;
 
     class ATextMeasure {
       constructor() {
@@ -24076,13 +24119,26 @@
       return new LegacyBindingContext();
     }
 
-    const legacyBindingContext = createLegacyBindingContext();
+    const LEGACY_BOOTSTRAP_STATE_SYMBOL = Symbol.for("@visactor/vrender-core/legacy-bootstrap-state");
+    function createLegacyBootstrapState() {
+      return {
+        legacyBindingContext: createLegacyBindingContext(),
+        preloaded: !1
+      };
+    }
+    function getLegacyBootstrapState() {
+      const scope = globalThis;
+      return scope[LEGACY_BOOTSTRAP_STATE_SYMBOL] || (scope[LEGACY_BOOTSTRAP_STATE_SYMBOL] = createLegacyBootstrapState()), scope[LEGACY_BOOTSTRAP_STATE_SYMBOL];
+    }
+
+    const legacyBootstrapState = getLegacyBootstrapState(),
+      legacyBindingContext = legacyBootstrapState.legacyBindingContext;
     function getLegacyTarget(resolver) {
       let target;
       return () => (void 0 === target && (target = resolver()), target);
     }
     function preLoadAllModule() {
-      preLoadAllModule.__loaded || (preLoadAllModule.__loaded = !0, bindCoreModules({
+      legacyBootstrapState.preloaded || (legacyBootstrapState.preloaded = !0, bindCoreModules({
         bind: legacyBindingContext.bind
       }), bindGraphicModules({
         bind: legacyBindingContext.bind
@@ -24095,7 +24151,6 @@
         bind: legacyBindingContext.bind
       }), load$1(legacyBindingContext), load(legacyBindingContext));
     }
-    preLoadAllModule.__loaded = !1;
     function getLegacyBindingContext() {
       return legacyBindingContext;
     }
@@ -28357,126 +28412,7 @@
     }
     const textModule = bindTextRenderModule;
 
-    class DirectionalLight {
-      constructor(dir, color, ambient = .8) {
-        this.dir = dir, this.color = color, this.colorRgb = ColorStore.Get(color, ColorType.Color1), this.ambient = ambient;
-        const length = sqrt$3(dir[0] * dir[0] + dir[1] * dir[1] + dir[2] * dir[2]);
-        this.formatedDir = [dir[0] / length, dir[1] / length, dir[2] / length];
-      }
-      computeColor(normal, color) {
-        const lightDir = this.formatedDir,
-          brightness = min$1(max$1((normal[0] * lightDir[0] + normal[1] * lightDir[1] + normal[2] * lightDir[2]) * (1 - this.ambient / 2), 0) + this.ambient, 1);
-        let colorArray;
-        colorArray = isString$1(color) ? ColorStore.Get(color, ColorType.Color1) : color;
-        const lightColorArray = this.colorRgb;
-        return `rgb(${lightColorArray[0] * colorArray[0] * brightness}, ${lightColorArray[1] * colorArray[1] * brightness}, ${lightColorArray[2] * colorArray[2] * brightness})`;
-      }
-    }
-    const registerDirectionalLight = () => {
-      Factory$1.registerPlugin("DirectionalLight", DirectionalLight);
-    };
-
-    class OrthoCamera {
-      set params(params) {
-        this._params = Object.assign({}, params), this._projectionMatrixCached = this.forceGetProjectionMatrix(), this._viewMatrixCached = this.forceGetViewMatrix();
-      }
-      get params() {
-        return Object.assign({}, this._params);
-      }
-      constructor(params) {
-        this.params = params;
-      }
-      getViewMatrix() {
-        return this._viewMatrixCached || (this._viewMatrixCached = mat4Allocate.allocate()), this._viewMatrixCached;
-      }
-      forceGetViewMatrix() {
-        this._viewMatrixCached || (this._viewMatrixCached = mat4Allocate.allocate());
-        const {
-          pos: pos,
-          center: center,
-          up: up
-        } = this.params.viewParams;
-        return lookAt(this._viewMatrixCached, pos, center, up), this._vp || (this._vp = mat4Allocate.allocate()), this._vp = multiplyMat4Mat4(this._vp, this.getProjectionMatrix(), this.getViewMatrix()), this._viewMatrixCached;
-      }
-      getProjectionMatrix() {
-        return this._projectionMatrixCached || (this._projectionMatrixCached = mat4Allocate.allocate()), this._projectionMatrixCached;
-      }
-      forceGetProjectionMatrix() {
-        this._projectionMatrixCached || (this._projectionMatrixCached = mat4Allocate.allocate());
-        const {
-          left: left,
-          top: top,
-          right: right,
-          bottom: bottom
-        } = this._params;
-        return ortho(this._projectionMatrixCached, left, right, bottom, top, 0, -2e6), this._vp || (this._vp = mat4Allocate.allocate()), this._vp = multiplyMat4Mat4(this._vp, this.getProjectionMatrix(), this.getViewMatrix()), this._projectionMatrixCached;
-      }
-      getField() {
-        const {
-          fieldRatio = .8,
-          fieldDepth: fieldDepth,
-          left: left,
-          right: right
-        } = this._params;
-        return (null != fieldDepth ? fieldDepth : right - left) * fieldRatio;
-      }
-      getProjectionScale(z) {
-        const field = this.getField();
-        return field / (field + z);
-      }
-      view(x, y, z) {
-        const outP = [0, 0, 0];
-        return transformMat4(outP, [x, y, z], this._viewMatrixCached), outP;
-      }
-      vp(x, y, z) {
-        const outP = [0, 0, 0],
-          {
-            pos: pos
-          } = this._params.viewParams;
-        transformMat4(outP, [x, y, z], this._viewMatrixCached), x = outP[0], y = outP[1], z = outP[2];
-        const sizeProjection = this.getProjectionScale(z);
-        return {
-          x: x * sizeProjection + pos[0],
-          y: y * sizeProjection + pos[1]
-        };
-      }
-    }
-    const registerOrthoCamera = () => {
-      Factory$1.registerPlugin("OrthoCamera", OrthoCamera);
-    };
-
-    class ViewTransform3dPlugin {
-      constructor() {
-        this.name = "ViewTransform3dPlugin", this.activeEvent = "onRegister", this._uid = Generator.GenAutoIncrementId(), this.key = this.name + this._uid, this.onMouseDown = e => {
-          this.option3d || (this.option3d = this.pluginService.stage.option3d), this.option3d && (this.mousedown = !0, this.pageX = e.page.x, this.pageY = e.page.y);
-        }, this.onMouseUp = e => {
-          this.option3d || (this.option3d = this.pluginService.stage.option3d), this.option3d && (this.mousedown = !1);
-        }, this.onMouseMove = e => {
-          var _a, _b;
-          const stage = this.pluginService.stage;
-          if (this.option3d || (this.option3d = stage.option3d), this.option3d && this.mousedown) if (this.pageX && this.pageY) {
-            const deltaX = e.page.x - this.pageX,
-              deltaY = e.page.y - this.pageY;
-            this.pageX = e.page.x, this.pageY = e.page.y;
-            const angle1 = deltaX / 100,
-              angle2 = deltaY / 100;
-            this.option3d.alpha = (null !== (_a = this.option3d.alpha) && void 0 !== _a ? _a : 0) + angle1, this.option3d.beta = (null !== (_b = this.option3d.beta) && void 0 !== _b ? _b : 0) + angle2, stage.set3dOptions(this.option3d), stage.renderNextFrame();
-          } else this.pageX = e.page.x, this.pageY = e.page.y;
-        };
-      }
-      activate(context) {
-        this.pluginService = context;
-        const stage = context.stage;
-        this.option3d = stage.option3d, stage.addEventListener("mousedown", this.onMouseDown), stage.addEventListener("mouseup", this.onMouseUp), stage.addEventListener("mousemove", this.onMouseMove);
-      }
-      deactivate(context) {
-        const stage = context.stage;
-        stage.removeEventListener("mousedown", this.onMouseDown), stage.removeEventListener("mouseup", this.onMouseUp), stage.removeEventListener("mousemove", this.onMouseMove);
-      }
-    }
-    const registerViewTransform3dPlugin = () => {
-      Factory$1.registerPlugin("ViewTransform3dPlugin", ViewTransform3dPlugin);
-    };
+    const browser = isBrowserEnv();
 
     function resolveContainerBinding(container, serviceIdentifier) {
       const [instance] = container.getAll(serviceIdentifier);
@@ -28684,6 +28620,94 @@
       }
     }
 
+    class DirectionalLight {
+      constructor(dir, color, ambient = .8) {
+        this.dir = dir, this.color = color, this.colorRgb = ColorStore.Get(color, ColorType.Color1), this.ambient = ambient;
+        const length = sqrt$3(dir[0] * dir[0] + dir[1] * dir[1] + dir[2] * dir[2]);
+        this.formatedDir = [dir[0] / length, dir[1] / length, dir[2] / length];
+      }
+      computeColor(normal, color) {
+        const lightDir = this.formatedDir,
+          brightness = min$1(max$1((normal[0] * lightDir[0] + normal[1] * lightDir[1] + normal[2] * lightDir[2]) * (1 - this.ambient / 2), 0) + this.ambient, 1);
+        let colorArray;
+        colorArray = isString$1(color) ? ColorStore.Get(color, ColorType.Color1) : color;
+        const lightColorArray = this.colorRgb;
+        return `rgb(${lightColorArray[0] * colorArray[0] * brightness}, ${lightColorArray[1] * colorArray[1] * brightness}, ${lightColorArray[2] * colorArray[2] * brightness})`;
+      }
+    }
+    const registerDirectionalLight = () => {
+      Factory$1.registerPlugin("DirectionalLight", DirectionalLight);
+    };
+
+    class OrthoCamera {
+      set params(params) {
+        this._params = Object.assign({}, params), this._projectionMatrixCached = this.forceGetProjectionMatrix(), this._viewMatrixCached = this.forceGetViewMatrix();
+      }
+      get params() {
+        return Object.assign({}, this._params);
+      }
+      constructor(params) {
+        this.params = params;
+      }
+      getViewMatrix() {
+        return this._viewMatrixCached || (this._viewMatrixCached = mat4Allocate.allocate()), this._viewMatrixCached;
+      }
+      forceGetViewMatrix() {
+        this._viewMatrixCached || (this._viewMatrixCached = mat4Allocate.allocate());
+        const {
+          pos: pos,
+          center: center,
+          up: up
+        } = this.params.viewParams;
+        return lookAt(this._viewMatrixCached, pos, center, up), this._vp || (this._vp = mat4Allocate.allocate()), this._vp = multiplyMat4Mat4(this._vp, this.getProjectionMatrix(), this.getViewMatrix()), this._viewMatrixCached;
+      }
+      getProjectionMatrix() {
+        return this._projectionMatrixCached || (this._projectionMatrixCached = mat4Allocate.allocate()), this._projectionMatrixCached;
+      }
+      forceGetProjectionMatrix() {
+        this._projectionMatrixCached || (this._projectionMatrixCached = mat4Allocate.allocate());
+        const {
+          left: left,
+          top: top,
+          right: right,
+          bottom: bottom
+        } = this._params;
+        return ortho(this._projectionMatrixCached, left, right, bottom, top, 0, -2e6), this._vp || (this._vp = mat4Allocate.allocate()), this._vp = multiplyMat4Mat4(this._vp, this.getProjectionMatrix(), this.getViewMatrix()), this._projectionMatrixCached;
+      }
+      getField() {
+        const {
+          fieldRatio = .8,
+          fieldDepth: fieldDepth,
+          left: left,
+          right: right
+        } = this._params;
+        return (null != fieldDepth ? fieldDepth : right - left) * fieldRatio;
+      }
+      getProjectionScale(z) {
+        const field = this.getField();
+        return field / (field + z);
+      }
+      view(x, y, z) {
+        const outP = [0, 0, 0];
+        return transformMat4(outP, [x, y, z], this._viewMatrixCached), outP;
+      }
+      vp(x, y, z) {
+        const outP = [0, 0, 0],
+          {
+            pos: pos
+          } = this._params.viewParams;
+        transformMat4(outP, [x, y, z], this._viewMatrixCached), x = outP[0], y = outP[1], z = outP[2];
+        const sizeProjection = this.getProjectionScale(z);
+        return {
+          x: x * sizeProjection + pos[0],
+          y: y * sizeProjection + pos[1]
+        };
+      }
+    }
+    const registerOrthoCamera = () => {
+      Factory$1.registerPlugin("OrthoCamera", OrthoCamera);
+    };
+
     const EMPTY_PICK_ITEM_INTERCEPTOR_PROVIDER = {
         getContributions: () => []
       },
@@ -28986,18 +29010,32 @@
       }
     }
 
-    const runtimeInstallerContext = createLegacyBindingContext();
-    let runtimeGlobal,
-      runtimeInstallerPreloaded = !1;
-    const RUNTIME_RENDERER_NAMESPACE = "vrender:runtime-renderer",
+    const RUNTIME_INSTALLER_STATE_SYMBOL = Symbol.for("@visactor/vrender-core/runtime-installer-state");
+    function createRuntimeInstallerState() {
+      return {
+        runtimeInstallerContext: createLegacyBindingContext(),
+        preloaded: !1,
+        runtimeEntryKeys: new WeakMap(),
+        runtimeDrawContributions: new WeakMap(),
+        loadedRuntimeContributionModules: new WeakMap()
+      };
+    }
+    function getRuntimeInstallerState() {
+      const scope = globalThis;
+      return scope[RUNTIME_INSTALLER_STATE_SYMBOL] || (scope[RUNTIME_INSTALLER_STATE_SYMBOL] = createRuntimeInstallerState()), scope[RUNTIME_INSTALLER_STATE_SYMBOL];
+    }
+
+    const runtimeInstallerState = getRuntimeInstallerState(),
+      runtimeInstallerContext = runtimeInstallerState.runtimeInstallerContext,
+      RUNTIME_RENDERER_NAMESPACE = "vrender:runtime-renderer",
       RUNTIME_PICKER_NAMESPACE = "vrender:runtime-picker",
-      runtimeEntryKeys = new WeakMap(),
-      runtimeDrawContributions = new WeakMap(),
-      loadedRuntimeContributionModules = new WeakMap(),
+      runtimeEntryKeys = runtimeInstallerState.runtimeEntryKeys,
+      runtimeDrawContributions = runtimeInstallerState.runtimeDrawContributions,
+      loadedRuntimeContributionModules = runtimeInstallerState.loadedRuntimeContributionModules,
       DEFAULT_RUNTIME_CONTRIBUTION_TARGETS = ["graphic-renderer"],
       noopUnbindRuntimeContributionService = () => {};
     function ensureRuntimeInstallerPreloaded() {
-      runtimeInstallerPreloaded || (runtimeInstallerPreloaded = !0, bindCoreModules({
+      runtimeInstallerState.preloaded || (runtimeInstallerState.preloaded = !0, bindCoreModules({
         bind: runtimeInstallerContext.bind
       }), bindGraphicModules({
         bind: runtimeInstallerContext.bind
@@ -29042,7 +29080,8 @@
       ContributionStore.refreshAllContributions();
     }
     function getRuntimeInstallerGlobal() {
-      return ensureRuntimeInstallerPreloaded(), null != runtimeGlobal || (runtimeGlobal = new DefaultGlobal(createContributionProvider$1(EnvContribution, runtimeInstallerContext))), runtimeGlobal;
+      var _a;
+      return ensureRuntimeInstallerPreloaded(), null !== (_a = runtimeInstallerState.runtimeGlobal) && void 0 !== _a || (runtimeInstallerState.runtimeGlobal = new DefaultGlobal(createContributionProvider$1(EnvContribution, runtimeInstallerContext))), runtimeInstallerState.runtimeGlobal;
     }
     function configureRuntimeApplicationForApp(app) {
       const bindingContext = getRuntimeInstallerBindingContext(),
@@ -29649,24 +29688,57 @@
       return res;
     };
 
-    const _tempBounds = new AABBBounds();
-    class FlexLayoutPlugin {
+    class ViewTransform3dPlugin {
       constructor() {
-        this.name = "FlexLayoutPlugin", this.activeEvent = "onRegister", this.id = Generator.GenAutoIncrementId(), this.key = this.name + this.id, this.tempBounds = new AABBBounds();
-      }
-      pauseLayout(p) {
-        this.pause = p;
-      }
-      tryLayoutChildren(graphic) {
-        graphic.firstChild && this.tryLayout(graphic.firstChild);
-      }
-      tryLayout(graphic, force = !0) {
-        if (this.pause) return;
-        const p = graphic.parent;
-        if (!(force || p && graphic.needUpdateLayout())) return;
-        const theme = getTheme$1(p).group,
-          {
-            display = theme.display
+        this.name = "ViewTransform3dPlugin", this.activeEvent = "onRegister", this._uid = Generator.GenAutoIncrementId(), this.key = this.name + this._uid, this.onMouseDown = e => {
+          this.option3d || (this.option3d = this.pluginService.stage.option3d), this.option3d && (this.mousedown = !0, this.pageX = e.page.x, this.pageY = e.page.y);
+        }, this.onMouseUp = e => {
+          this.option3d || (this.option3d = this.pluginService.stage.option3d), this.option3d && (this.mousedown = !1);
+        }, this.onMouseMove = e => {
+          var _a, _b;
+          const stage = this.pluginService.stage;
+          if (this.option3d || (this.option3d = stage.option3d), this.option3d && this.mousedown) if (this.pageX && this.pageY) {
+            const deltaX = e.page.x - this.pageX,
+              deltaY = e.page.y - this.pageY;
+            this.pageX = e.page.x, this.pageY = e.page.y;
+            const angle1 = deltaX / 100,
+              angle2 = deltaY / 100;
+            this.option3d.alpha = (null !== (_a = this.option3d.alpha) && void 0 !== _a ? _a : 0) + angle1, this.option3d.beta = (null !== (_b = this.option3d.beta) && void 0 !== _b ? _b : 0) + angle2, stage.set3dOptions(this.option3d), stage.renderNextFrame();
+          } else this.pageX = e.page.x, this.pageY = e.page.y;
+        };
+      }
+      activate(context) {
+        this.pluginService = context;
+        const stage = context.stage;
+        this.option3d = stage.option3d, stage.addEventListener("mousedown", this.onMouseDown), stage.addEventListener("mouseup", this.onMouseUp), stage.addEventListener("mousemove", this.onMouseMove);
+      }
+      deactivate(context) {
+        const stage = context.stage;
+        stage.removeEventListener("mousedown", this.onMouseDown), stage.removeEventListener("mouseup", this.onMouseUp), stage.removeEventListener("mousemove", this.onMouseMove);
+      }
+    }
+    const registerViewTransform3dPlugin = () => {
+      Factory$1.registerPlugin("ViewTransform3dPlugin", ViewTransform3dPlugin);
+    };
+
+    const _tempBounds = new AABBBounds();
+    class FlexLayoutPlugin {
+      constructor() {
+        this.name = "FlexLayoutPlugin", this.activeEvent = "onRegister", this.id = Generator.GenAutoIncrementId(), this.key = this.name + this.id, this.tempBounds = new AABBBounds();
+      }
+      pauseLayout(p) {
+        this.pause = p;
+      }
+      tryLayoutChildren(graphic) {
+        graphic.firstChild && this.tryLayout(graphic.firstChild);
+      }
+      tryLayout(graphic, force = !0) {
+        if (this.pause) return;
+        const p = graphic.parent;
+        if (!(force || p && graphic.needUpdateLayout())) return;
+        const theme = getTheme$1(p).group,
+          {
+            display = theme.display
           } = p.attribute;
         if ("flex" !== display) return;
         const {
@@ -29918,6 +29990,70 @@
       Factory$1.registerPlugin("FlexLayoutPlugin", FlexLayoutPlugin);
     };
 
+    class PickerBase {
+      contains(graphic, point, params) {
+        if (!graphic.AABBBounds.containsPoint(point)) return !1;
+        if ("imprecise" === graphic.attribute.pickMode) return !0;
+        if (!this.canvasRenderer) return !0;
+        const {
+          pickContext: pickContext
+        } = null != params ? params : {};
+        if (!pickContext) return !1;
+        const attribute = graphic.getGraphicTheme();
+        pickContext.highPerformanceSave();
+        let {
+          x = attribute.x,
+          y = attribute.y
+        } = graphic.attribute;
+        if (graphic.transMatrix.onlyTranslate()) {
+          const point = graphic.getOffsetXY(attribute);
+          x += point.x, y += point.y, pickContext.setTransformForCurrent();
+        } else x = 0, y = 0, pickContext.transformFromMatrix(graphic.transMatrix, !0);
+        let picked = !1,
+          _final = !1;
+        return this.canvasRenderer.drawShape(graphic, pickContext, x, y, {}, null, (context, arcAttribute, themeAttribute, final) => !(!picked && !_final) || (picked = context.isPointInPath(point.x, point.y), _final = final || _final, picked), (context, arcAttribute, themeAttribute, final) => {
+          if (picked || _final) return !0;
+          const lineWidth = arcAttribute.lineWidth || themeAttribute.lineWidth,
+            pickStrokeBuffer = arcAttribute.pickStrokeBuffer || themeAttribute.pickStrokeBuffer,
+            keepStrokeScale = arcAttribute.keepStrokeScale || themeAttribute.keepStrokeScale;
+          return pickContext.lineWidth = keepStrokeScale ? lineWidth + pickStrokeBuffer : getScaledStroke(pickContext, lineWidth + pickStrokeBuffer, pickContext.dpr), picked = context.isPointInStroke(point.x, point.y), _final = final || _final, picked;
+        }), pickContext.highPerformanceRestore(), picked;
+      }
+    }
+
+    class DefaultCanvasArcPicker extends PickerBase {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer, this.type = "arc", this.numberType = ARC_NUMBER_TYPE;
+      }
+    }
+
+    let loadArcPick$1 = !1;
+    function bindArcCanvasPickerContribution(container) {
+      loadArcPick$1 || (loadArcPick$1 = !0, container.bind(CanvasArcPicker).toDynamicValue(() => new DefaultCanvasArcPicker(resolveContainerBinding(container, ArcRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasArcPicker));
+    }
+
+    class DefaultMathArcPicker extends PickerBase {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer, this.type = "arc", this.numberType = ARC_NUMBER_TYPE;
+      }
+    }
+
+    let loadArcPick = !1;
+    function bindArcMathPickerContribution(container) {
+      loadArcPick || (loadArcPick = !0, container.bind(MathArcPicker).toDynamicValue(() => new DefaultMathArcPicker(resolveContainerBinding(container, ArcRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathArcPicker));
+    }
+
+    function _registerArc() {
+      if (_registerArc.__loaded) return;
+      _registerArc.__loaded = !0;
+      const legacyContext = getLegacyBindingContext();
+      registerArcGraphic(), arcModule({
+        bind: legacyContext.bind
+      }), browser ? bindArcCanvasPickerContribution(legacyContext) : bindArcMathPickerContribution(legacyContext);
+    }
+    _registerArc.__loaded = !1;
+    const registerArc = _registerArc;
+
     class Base3dPicker extends BaseRender {
       contains(graphic, point, params) {
         const {
@@ -29968,95 +30104,637 @@
     _registerArc3d.__loaded = !1;
     const registerArc3d = _registerArc3d;
 
-    class DefaultCanvasPyramid3dPicker extends Base3dPicker {
+    class DefaultCanvasAreaPicker extends PickerBase {
       constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "pyramid3d", this.numberType = PYRAMID3D_NUMBER_TYPE, this.themeType = "polygon";
+        super(), this.canvasRenderer = canvasRenderer, this.type = "area", this.numberType = AREA_NUMBER_TYPE;
       }
     }
 
-    let loadPyramid3dPick = !1;
-    function bindPyramid3dCanvasPickerContribution(container) {
-      var _a;
-      loadPyramid3dPick || (null === (_a = container.isBound) || void 0 === _a ? void 0 : _a.call(container, Pyramid3dRender)) && (loadPyramid3dPick = !0, container.bind(CanvasPyramid3dPicker).toDynamicValue(() => new DefaultCanvasPyramid3dPicker(resolveContainerBinding(container, Pyramid3dRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasPyramid3dPicker));
+    let loadAreaPick$1 = !1;
+    function bindAreaCanvasPickerContribution(container) {
+      loadAreaPick$1 || (loadAreaPick$1 = !0, container.bind(CanvasAreaPicker).toDynamicValue(() => new DefaultCanvasAreaPicker(resolveContainerBinding(container, AreaRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasAreaPicker));
     }
 
-    function _registerPyramid3d() {
-      if (_registerPyramid3d.__loaded) return;
-      _registerPyramid3d.__loaded = !0;
+    class DefaultMathAreaPicker extends PickerBase {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer, this.type = "area", this.numberType = AREA_NUMBER_TYPE;
+      }
+    }
+
+    let loadAreaPick = !1;
+    function bindAreaMathPickerContribution(container) {
+      loadAreaPick || (loadAreaPick = !0, container.bind(MathAreaPicker).toDynamicValue(() => new DefaultMathAreaPicker(resolveContainerBinding(container, AreaRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathAreaPicker));
+    }
+
+    function _registerArea() {
+      if (_registerArea.__loaded) return;
+      _registerArea.__loaded = !0;
       const legacyContext = getLegacyBindingContext();
-      registerPyramid3dGraphic(), registerDirectionalLight(), registerOrthoCamera(), pyramid3dModule({
+      registerAreaGraphic(), areaModule({
         bind: legacyContext.bind
-      }), bindPyramid3dCanvasPickerContribution(legacyContext);
+      }), browser ? bindAreaCanvasPickerContribution(legacyContext) : bindAreaMathPickerContribution(legacyContext);
     }
-    _registerPyramid3d.__loaded = !1;
-    const registerPyramid3d = _registerPyramid3d;
+    _registerArea.__loaded = !1;
+    const registerArea = _registerArea;
 
-    class DefaultCanvasRect3dPicker extends Base3dPicker {
+    class GlyphPickerBase {
+      constructor() {
+        this.type = "glyph", this.numberType = GLYPH_NUMBER_TYPE;
+      }
+      contains(glyph, point, params) {
+        if (!glyph.AABBBounds.containsPoint(point)) return !1;
+        if ("imprecise" === glyph.attribute.pickMode) return !0;
+        const {
+          pickContext: pickContext
+        } = null != params ? params : {};
+        if (!pickContext) return !1;
+        const pickerService = null == params ? void 0 : params.pickerService;
+        if (pickerService) {
+          let picked = !1;
+          return glyph.getSubGraphic().forEach(g => {
+            if (picked) return;
+            const data = pickerService.pickItem(g, point, null, params);
+            picked = !(!data || !data.graphic);
+          }), picked;
+        }
+        return !1;
+      }
+    }
+
+    class DefaultCanvasGlyphPicker extends GlyphPickerBase {
       constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "rect3d", this.numberType = RECT3D_NUMBER_TYPE, this.themeType = "rect";
+        super(), this.canvasRenderer = canvasRenderer;
       }
     }
 
-    let loadRect3dPick = !1;
-    function bindRect3dCanvasPickerContribution(container) {
-      var _a;
-      loadRect3dPick || (null === (_a = container.isBound) || void 0 === _a ? void 0 : _a.call(container, Rect3DRender)) && (loadRect3dPick = !0, container.bind(CanvasRect3dPicker).toDynamicValue(() => new DefaultCanvasRect3dPicker(resolveContainerBinding(container, Rect3DRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasRect3dPicker));
+    let loadGlyphPick$1 = !1;
+    function bindGlyphCanvasPickerContribution(container) {
+      loadGlyphPick$1 || (loadGlyphPick$1 = !0, container.bind(CanvasGlyphPicker).toDynamicValue(() => new DefaultCanvasGlyphPicker(resolveContainerBinding(container, GlyphRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasGlyphPicker));
     }
 
-    function _registerRect3d() {
-      if (_registerRect3d.__loaded) return;
-      _registerRect3d.__loaded = !0;
+    class DefaultMathGlyphPicker extends GlyphPickerBase {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer;
+      }
+    }
+
+    let loadGlyphPick = !1;
+    function bindGlyphMathPickerContribution(container) {
+      loadGlyphPick || (loadGlyphPick = !0, container.bind(MathGlyphPicker).toDynamicValue(() => new DefaultMathGlyphPicker(resolveContainerBinding(container, GlyphRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathGlyphPicker));
+    }
+
+    function _registerGlyph() {
+      if (_registerGlyph.__loaded) return;
+      _registerGlyph.__loaded = !0;
       const legacyContext = getLegacyBindingContext();
-      registerRect3dGraphic(), rect3dModule({
+      registerGlyphGraphic(), glyphModule({
         bind: legacyContext.bind
-      }), bindRect3dCanvasPickerContribution(legacyContext);
+      }), browser ? bindGlyphCanvasPickerContribution(legacyContext) : bindGlyphMathPickerContribution(legacyContext);
     }
-    _registerRect3d.__loaded = !1;
-    const registerRect3d = _registerRect3d;
+    _registerGlyph.__loaded = !1;
+    const registerGlyph = _registerGlyph;
 
-    const createArc3d = (attributes) => {
-        registerArc3d();
-        return createGraphic$1('arc3d', attributes);
-    };
-    const createPyramid3d = (attributes) => {
-        registerPyramid3d();
-        return createGraphic$1('pyramid3d', attributes);
-    };
-    const createRect3d = (attributes) => {
-        registerRect3d();
-        return createGraphic$1('rect3d', attributes);
-    };
-    const waitForAllSubLayers = (stage) => new Promise(resolve => {
-        vglobal.getRequestAnimationFrame()(() => {
-            resolve(null);
-        });
-    }).then(() => {
-        const promiseList = [];
-        const layers = stage.getChildren();
-        layers.forEach((layer) => {
-            var _a;
-            if (!((_a = layer.subLayers) === null || _a === void 0 ? void 0 : _a.size)) {
-                return;
-            }
-            layer.subLayers.forEach((subLayer) => {
-                const drawContribution = subLayer.drawContribution;
-                if ((drawContribution === null || drawContribution === void 0 ? void 0 : drawContribution.hooks) && drawContribution.rendering) {
-                    promiseList.push(new Promise(resolve => {
-                        drawContribution.hooks.completeDraw.tap('outWait', () => {
-                            drawContribution.hooks.completeDraw.taps = drawContribution.hooks.completeDraw.taps.filter((item) => item.name !== 'outWait');
-                            resolve(null);
-                        });
-                    }));
-                }
-            });
-        });
-        return Promise.all(promiseList);
-    });
+    function _registerGroup() {
+      _registerGroup.__loaded || (_registerGroup.__loaded = !0, registerGroupGraphic());
+    }
+    _registerGroup.__loaded = !1;
+    const registerGroup = _registerGroup;
 
-    function combineDomains(domains) {
-        const result = [];
-        for (let index = 0; index < domains.length; index++) {
-            const domain = domains[index];
+    class DefaultCanvasImagePicker extends PickerBase {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer, this.type = "image", this.numberType = IMAGE_NUMBER_TYPE;
+      }
+    }
+
+    let loadImagePick$1 = !1;
+    function bindImageCanvasPickerContribution(container) {
+      loadImagePick$1 || (loadImagePick$1 = !0, container.bind(CanvasImagePicker).toDynamicValue(() => new DefaultCanvasImagePicker(resolveContainerBinding(container, ImageRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasImagePicker));
+    }
+
+    class DefaultMathImagePicker {
+      constructor() {
+        this.type = "image", this.numberType = IMAGE_NUMBER_TYPE;
+      }
+      contains(image, point, params) {
+        const {
+          pickContext: pickContext
+        } = null != params ? params : {};
+        return !!pickContext && !!image.AABBBounds.containsPoint(point);
+      }
+    }
+
+    let loadImagePick = !1;
+    function bindImageMathPickerContribution(container) {
+      loadImagePick || (loadImagePick = !0, container.bind(MathImagePicker).toDynamicValue(() => new DefaultMathImagePicker()).inSingletonScope(), container.bind(MathPickerContribution).toService(MathImagePicker));
+    }
+
+    function _registerImage() {
+      if (_registerImage.__loaded) return;
+      _registerImage.__loaded = !0;
+      const legacyContext = getLegacyBindingContext();
+      registerImageGraphic(), imageModule({
+        bind: legacyContext.bind
+      }), browser ? bindImageCanvasPickerContribution(legacyContext) : bindImageMathPickerContribution(legacyContext);
+    }
+    _registerImage.__loaded = !1;
+    const registerImage = _registerImage;
+
+    class BaseLinePicker extends BaseRender {
+      contains(graphic, point, params) {
+        if (!graphic.AABBBounds.containsPoint(point)) return !1;
+        if ("imprecise" === graphic.attribute.pickMode) return !0;
+        const {
+          pickContext: pickContext
+        } = null != params ? params : {};
+        if (!pickContext) return !1;
+        pickContext.highPerformanceSave();
+        const lineAttribute = graphic.getGraphicTheme(),
+          data = this.transform(graphic, lineAttribute, pickContext),
+          {
+            x: x,
+            y: y,
+            z: z,
+            lastModelMatrix: lastModelMatrix
+          } = data;
+        let pickPoint = point;
+        if (pickContext.camera) {
+          pickPoint = point.clone();
+          const globalMatrix = graphic.parent.globalTransMatrix;
+          pickPoint.x = globalMatrix.a * point.x + globalMatrix.c * point.y + globalMatrix.e, pickPoint.y = globalMatrix.b * point.x + globalMatrix.d * point.y + globalMatrix.f;
+        }
+        this.canvasRenderer.z = z;
+        let picked = !1;
+        return this.canvasRenderer.drawShape(graphic, pickContext, x, y, {}, null, context => !!picked || (picked = context.isPointInPath(pickPoint.x, pickPoint.y), picked), (context, lineAttribute, themeAttribute) => {
+          if (picked) return !0;
+          const lineWidth = lineAttribute.lineWidth || themeAttribute.lineWidth,
+            pickStrokeBuffer = lineAttribute.pickStrokeBuffer || themeAttribute.pickStrokeBuffer,
+            keepStrokeScale = lineAttribute.keepStrokeScale || themeAttribute.keepStrokeScale;
+          return pickContext.lineWidth = keepStrokeScale ? lineWidth + pickStrokeBuffer : getScaledStroke(pickContext, lineWidth + pickStrokeBuffer, pickContext.dpr), picked = context.isPointInStroke(pickPoint.x, pickPoint.y), picked;
+        }), this.canvasRenderer.z = 0, pickContext.modelMatrix !== lastModelMatrix && mat4Allocate.free(pickContext.modelMatrix), pickContext.modelMatrix = lastModelMatrix, pickContext.highPerformanceRestore(), picked;
+      }
+    }
+
+    class DefaultCanvasLinePicker extends BaseLinePicker {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer, this.type = "line", this.numberType = LINE_NUMBER_TYPE;
+      }
+    }
+
+    let loadLinePick$1 = !1;
+    function bindLineCanvasPickerContribution(container) {
+      loadLinePick$1 || (loadLinePick$1 = !0, container.bind(CanvasLinePicker).toDynamicValue(() => new DefaultCanvasLinePicker(resolveContainerBinding(container, LineRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasLinePicker));
+    }
+
+    class DefaultMathLinePicker extends PickerBase {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer, this.type = "line", this.numberType = LINE_NUMBER_TYPE;
+      }
+    }
+
+    let loadLinePick = !1;
+    function bindLineMathPickerContribution(container) {
+      loadLinePick || (loadLinePick = !0, container.bind(MathLinePicker).toDynamicValue(() => new DefaultMathLinePicker(resolveContainerBinding(container, LineRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathLinePicker));
+    }
+
+    function _registerLine() {
+      if (_registerLine.__loaded) return;
+      _registerLine.__loaded = !0;
+      const legacyContext = getLegacyBindingContext();
+      registerLineGraphic(), lineModule({
+        bind: legacyContext.bind
+      }), browser ? bindLineCanvasPickerContribution(legacyContext) : bindLineMathPickerContribution(legacyContext);
+    }
+    _registerLine.__loaded = !1;
+    const registerLine = _registerLine;
+
+    class DefaultCanvasPathPicker extends BaseLinePicker {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer, this.type = "path", this.numberType = PATH_NUMBER_TYPE;
+      }
+    }
+
+    let loadPathPick$1 = !1;
+    function bindPathCanvasPickerContribution(container) {
+      loadPathPick$1 || (loadPathPick$1 = !0, container.bind(CanvasPathPicker).toDynamicValue(() => new DefaultCanvasPathPicker(resolveContainerBinding(container, PathRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasPathPicker));
+    }
+
+    class DefaultMathPathPicker extends PickerBase {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer, this.type = "path", this.numberType = PATH_NUMBER_TYPE;
+      }
+    }
+
+    let loadPathPick = !1;
+    function bindPathMathPickerContribution(container) {
+      loadPathPick || (loadPathPick = !0, container.bind(MathPathPicker).toDynamicValue(() => new DefaultMathPathPicker(resolveContainerBinding(container, PathRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathPathPicker));
+    }
+
+    function _registerPath() {
+      if (_registerPath.__loaded) return;
+      _registerPath.__loaded = !0;
+      const legacyContext = getLegacyBindingContext();
+      registerPathGraphic(), pathModule({
+        bind: legacyContext.bind
+      }), browser ? bindPathCanvasPickerContribution(legacyContext) : bindPathMathPickerContribution(legacyContext);
+    }
+    _registerPath.__loaded = !1;
+    const registerPath = _registerPath;
+
+    class DefaultCanvasPolygonPicker extends PickerBase {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer, this.type = "polygon", this.numberType = POLYGON_NUMBER_TYPE;
+      }
+    }
+
+    let loadPolygonPick$1 = !1;
+    function bindPolygonCanvasPickerContribution(container) {
+      loadPolygonPick$1 || (loadPolygonPick$1 = !0, container.bind(CanvasPolygonPicker).toDynamicValue(() => new DefaultCanvasPolygonPicker(resolveContainerBinding(container, PolygonRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasPolygonPicker));
+    }
+
+    class DefaultMathPolygonPicker extends PickerBase {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer, this.type = "polygon", this.numberType = POLYGON_NUMBER_TYPE;
+      }
+    }
+
+    let loadPolygonPick = !1;
+    function bindPolygonMathPickerContribution(container) {
+      loadPolygonPick || (loadPolygonPick = !0, container.bind(MathPolygonPicker).toDynamicValue(() => new DefaultMathPolygonPicker(resolveContainerBinding(container, PolygonRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathPolygonPicker));
+    }
+
+    function _registerPolygon() {
+      if (_registerPolygon.__loaded) return;
+      _registerPolygon.__loaded = !0;
+      const legacyContext = getLegacyBindingContext();
+      registerPolygonGraphic(), polygonModule({
+        bind: legacyContext.bind
+      }), browser ? bindPolygonCanvasPickerContribution(legacyContext) : bindPolygonMathPickerContribution(legacyContext);
+    }
+    _registerPolygon.__loaded = !1;
+    const registerPolygon = _registerPolygon;
+
+    class DefaultCanvasPyramid3dPicker extends Base3dPicker {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer, this.type = "pyramid3d", this.numberType = PYRAMID3D_NUMBER_TYPE, this.themeType = "polygon";
+      }
+    }
+
+    let loadPyramid3dPick = !1;
+    function bindPyramid3dCanvasPickerContribution(container) {
+      var _a;
+      loadPyramid3dPick || (null === (_a = container.isBound) || void 0 === _a ? void 0 : _a.call(container, Pyramid3dRender)) && (loadPyramid3dPick = !0, container.bind(CanvasPyramid3dPicker).toDynamicValue(() => new DefaultCanvasPyramid3dPicker(resolveContainerBinding(container, Pyramid3dRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasPyramid3dPicker));
+    }
+
+    function _registerPyramid3d() {
+      if (_registerPyramid3d.__loaded) return;
+      _registerPyramid3d.__loaded = !0;
+      const legacyContext = getLegacyBindingContext();
+      registerPyramid3dGraphic(), registerDirectionalLight(), registerOrthoCamera(), pyramid3dModule({
+        bind: legacyContext.bind
+      }), bindPyramid3dCanvasPickerContribution(legacyContext);
+    }
+    _registerPyramid3d.__loaded = !1;
+    const registerPyramid3d = _registerPyramid3d;
+
+    const _bounds = new AABBBounds();
+    class RectPickerBase {
+      constructor() {
+        this.type = "rect", this.numberType = RECT_NUMBER_TYPE;
+      }
+      contains(rect, point, params) {
+        if (!rect.AABBBounds.containsPoint(point)) return !1;
+        if ("imprecise" === rect.attribute.pickMode) return !0;
+        const {
+          pickContext: pickContext
+        } = null != params ? params : {};
+        if (!pickContext) return !1;
+        const rectAttribute = rect.getGraphicTheme(),
+          {
+            cornerRadius = rectAttribute.cornerRadius
+          } = rect.attribute;
+        let {
+          x = rectAttribute.x,
+          y = rectAttribute.y
+        } = rect.attribute;
+        pickContext.highPerformanceSave();
+        let onlyTranslate = !0;
+        if (rect.transMatrix.onlyTranslate()) {
+          const point = rect.getOffsetXY(rectAttribute);
+          x += point.x, y += point.y, pickContext.setTransformForCurrent();
+        } else x = 0, y = 0, onlyTranslate = !1, pickContext.transformFromMatrix(rect.transMatrix, !0);
+        let picked = !0;
+        if (!onlyTranslate || rect.shadowRoot || isNumber$1(cornerRadius, !0) && 0 !== cornerRadius || isArray$1(cornerRadius) && cornerRadius.some(num => 0 !== num)) picked = !1, this.canvasRenderer.drawShape(rect, pickContext, x, y, {}, null, (context, rectAttribute, themeAttribute) => !!picked || (picked = context.isPointInPath(point.x, point.y), picked), (context, rectAttribute, themeAttribute) => {
+          if (picked) return !0;
+          const lineWidth = rectAttribute.lineWidth || themeAttribute.lineWidth,
+            pickStrokeBuffer = rectAttribute.pickStrokeBuffer || themeAttribute.pickStrokeBuffer,
+            keepStrokeScale = rectAttribute.keepStrokeScale || themeAttribute.keepStrokeScale;
+          return pickContext.lineWidth = keepStrokeScale ? lineWidth + pickStrokeBuffer : getScaledStroke(pickContext, lineWidth + pickStrokeBuffer, pickContext.dpr), picked = context.isPointInStroke(point.x, point.y), picked;
+        });else {
+          const {
+            fill = rectAttribute.fill,
+            stroke = rectAttribute.stroke,
+            lineWidth = rectAttribute.lineWidth
+          } = rect.attribute;
+          if (fill) picked = !0;else if (stroke) {
+            const bounds = rect.AABBBounds;
+            _bounds.setValue(bounds.x1, bounds.y1, bounds.x2, bounds.y2), _bounds.expand(-lineWidth / 2), picked = !_bounds.containsPoint(point);
+          }
+        }
+        return pickContext.highPerformanceRestore(), picked;
+      }
+    }
+
+    class DefaultCanvasRectPicker extends RectPickerBase {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer;
+      }
+    }
+
+    let loadRectPick$1 = !1;
+    function bindRectCanvasPickerContribution(container) {
+      loadRectPick$1 || (loadRectPick$1 = !0, container.bind(CanvasRectPicker).toDynamicValue(() => new DefaultCanvasRectPicker(resolveContainerBinding(container, RectRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasRectPicker));
+    }
+
+    class DefaultMathRectPicker extends RectPickerBase {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer;
+      }
+    }
+
+    let loadRectPick = !1;
+    function bindRectMathPickerContribution(container) {
+      loadRectPick || (loadRectPick = !0, container.bind(MathRectPicker).toDynamicValue(() => new DefaultMathRectPicker(resolveContainerBinding(container, RectRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathRectPicker));
+    }
+
+    function _registerRect() {
+      if (_registerRect.__loaded) return;
+      _registerRect.__loaded = !0;
+      const legacyContext = getLegacyBindingContext();
+      registerRectGraphic(), rectModule({
+        bind: legacyContext.bind
+      }), browser ? bindRectCanvasPickerContribution(legacyContext) : bindRectMathPickerContribution(legacyContext);
+    }
+    _registerRect.__loaded = !1;
+    const registerRect = _registerRect;
+
+    class DefaultCanvasRect3dPicker extends Base3dPicker {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer, this.type = "rect3d", this.numberType = RECT3D_NUMBER_TYPE, this.themeType = "rect";
+      }
+    }
+
+    let loadRect3dPick = !1;
+    function bindRect3dCanvasPickerContribution(container) {
+      var _a;
+      loadRect3dPick || (null === (_a = container.isBound) || void 0 === _a ? void 0 : _a.call(container, Rect3DRender)) && (loadRect3dPick = !0, container.bind(CanvasRect3dPicker).toDynamicValue(() => new DefaultCanvasRect3dPicker(resolveContainerBinding(container, Rect3DRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasRect3dPicker));
+    }
+
+    function _registerRect3d() {
+      if (_registerRect3d.__loaded) return;
+      _registerRect3d.__loaded = !0;
+      const legacyContext = getLegacyBindingContext();
+      registerRect3dGraphic(), rect3dModule({
+        bind: legacyContext.bind
+      }), bindRect3dCanvasPickerContribution(legacyContext);
+    }
+    _registerRect3d.__loaded = !1;
+    const registerRect3d = _registerRect3d;
+
+    class DefaultCanvasRichTextPicker {
+      constructor(canvasRenderer) {
+        this.canvasRenderer = canvasRenderer, this.type = "richtext", this.numberType = RICHTEXT_NUMBER_TYPE;
+      }
+      contains(richtext, point, params) {
+        return !!richtext.AABBBounds.containsPoint(point);
+      }
+    }
+
+    let loadRichtextPick = !1;
+    function bindRichtextCanvasPickerContribution(container) {
+      loadRichtextPick || (loadRichtextPick = !0, container.bind(CanvasRichTextPicker).toDynamicValue(() => new DefaultCanvasRichTextPicker(resolveContainerBinding(container, RichTextRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasRichTextPicker));
+    }
+
+    class DefaultMathRichTextPicker {
+      constructor(canvasRenderer) {
+        this.canvasRenderer = canvasRenderer, this.type = "richtext", this.numberType = RICHTEXT_NUMBER_TYPE;
+      }
+      contains(richtext, point, params) {
+        return !!richtext.AABBBounds.containsPoint(point);
+      }
+    }
+
+    let loadRichTextPick = !1;
+    function bindRichTextMathPickerContribution(container) {
+      loadRichTextPick || (loadRichTextPick = !0, container.bind(MathRichTextPicker).toDynamicValue(() => new DefaultMathRichTextPicker(resolveContainerBinding(container, RichTextRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathRichTextPicker));
+    }
+
+    function _registerRichtext() {
+      if (_registerRichtext.__loaded) return;
+      _registerRichtext.__loaded = !0;
+      const legacyContext = getLegacyBindingContext();
+      registerRichtextGraphic(), richtextModule({
+        bind: legacyContext.bind
+      }), browser ? bindRichtextCanvasPickerContribution(legacyContext) : bindRichTextMathPickerContribution(legacyContext);
+    }
+    _registerRichtext.__loaded = !1;
+    const registerRichtext = _registerRichtext;
+
+    function _registerShadowRoot() {
+      _registerShadowRoot.__loaded || (_registerShadowRoot.__loaded = !0, registerShadowRootGraphic());
+    }
+    _registerShadowRoot.__loaded = !1;
+    const registerShadowRoot = _registerShadowRoot;
+
+    class DefaultCanvasSymbolPicker extends Base3dPicker {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer, this.type = "symbol", this.numberType = SYMBOL_NUMBER_TYPE;
+      }
+      contains(symbol, point, params) {
+        const {
+          pickContext: pickContext
+        } = null != params ? params : {};
+        if (!pickContext) return !1;
+        const parsedPath = symbol.getParsedPath();
+        if (!pickContext.camera) {
+          if (!symbol.AABBBounds.containsPoint(point)) return !1;
+          if (parsedPath.isSvg || "imprecise" === symbol.attribute.pickMode) return !0;
+        }
+        pickContext.highPerformanceSave();
+        const symbolAttribute = symbol.getGraphicTheme(),
+          data = this.transform(symbol, symbolAttribute, pickContext),
+          {
+            x: x,
+            y: y,
+            z: z,
+            lastModelMatrix: lastModelMatrix
+          } = data;
+        let pickPoint = point;
+        if (pickContext.camera) {
+          pickPoint = point.clone();
+          const globalMatrix = symbol.parent.globalTransMatrix;
+          pickPoint.x = globalMatrix.a * point.x + globalMatrix.c * point.y + globalMatrix.e, pickPoint.y = globalMatrix.b * point.x + globalMatrix.d * point.y + globalMatrix.f;
+        }
+        this.canvasRenderer.z = z;
+        let picked = !1;
+        return this.canvasRenderer.drawShape(symbol, pickContext, x, y, {}, null, (context, symbolAttribute, themeAttribute) => !!picked || (picked = context.isPointInPath(pickPoint.x, pickPoint.y), picked), (context, symbolAttribute, themeAttribute) => {
+          if (picked) return !0;
+          const lineWidth = symbolAttribute.lineWidth || themeAttribute.lineWidth,
+            pickStrokeBuffer = symbolAttribute.pickStrokeBuffer || themeAttribute.pickStrokeBuffer,
+            keepStrokeScale = symbolAttribute.keepStrokeScale || themeAttribute.keepStrokeScale;
+          return pickContext.lineWidth = keepStrokeScale ? lineWidth + pickStrokeBuffer : getScaledStroke(pickContext, lineWidth + pickStrokeBuffer, pickContext.dpr), picked = context.isPointInStroke(pickPoint.x, pickPoint.y), picked;
+        }), this.canvasRenderer.z = 0, pickContext.modelMatrix !== lastModelMatrix && mat4Allocate.free(pickContext.modelMatrix), pickContext.modelMatrix = lastModelMatrix, pickContext.highPerformanceRestore(), picked;
+      }
+    }
+
+    let loadSymbolPick$1 = !1;
+    function bindSymbolCanvasPickerContribution(container) {
+      loadSymbolPick$1 || (loadSymbolPick$1 = !0, container.bind(CanvasSymbolPicker).toDynamicValue(() => new DefaultCanvasSymbolPicker(resolveContainerBinding(container, SymbolRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasSymbolPicker));
+    }
+
+    class DefaultMathSymbolPicker extends PickerBase {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer, this.type = "symbol", this.numberType = SYMBOL_NUMBER_TYPE;
+      }
+    }
+
+    let loadSymbolPick = !1;
+    function bindSymbolMathPickerContribution(container) {
+      loadSymbolPick || (loadSymbolPick = !0, container.bind(MathSymbolPicker).toDynamicValue(() => new DefaultMathSymbolPicker(resolveContainerBinding(container, SymbolRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathSymbolPicker));
+    }
+
+    function _registerSymbol() {
+      if (_registerSymbol.__loaded) return;
+      _registerSymbol.__loaded = !0;
+      const legacyContext = getLegacyBindingContext();
+      registerSymbolGraphic(), symbolModule({
+        bind: legacyContext.bind
+      }), browser ? bindSymbolCanvasPickerContribution(legacyContext) : bindSymbolMathPickerContribution(legacyContext);
+    }
+    _registerSymbol.__loaded = !1;
+    const registerSymbol = _registerSymbol;
+
+    class DefaultCanvasTextPicker extends Base3dPicker {
+      constructor(canvasRenderer) {
+        super(), this.canvasRenderer = canvasRenderer, this.type = "text", this.numberType = TEXT_NUMBER_TYPE;
+      }
+      contains(text, point, params) {
+        const {
+          pickContext: pickContext
+        } = null != params ? params : {};
+        if (!pickContext) return !1;
+        const bounds = text.AABBBounds;
+        if (!pickContext.camera) return !!bounds.containsPoint(point);
+        pickContext.highPerformanceSave();
+        const textAttribute = text.getGraphicTheme(),
+          {
+            keepDirIn3d = textAttribute.keepDirIn3d
+          } = text.attribute,
+          computed3dMatrix = !keepDirIn3d,
+          data = this.transform(text, textAttribute, pickContext, computed3dMatrix),
+          {
+            x: x,
+            y: y,
+            z: z,
+            lastModelMatrix: lastModelMatrix
+          } = data;
+        this.canvasRenderer.z = z;
+        let pickPoint = point;
+        if (pickContext.camera) {
+          pickPoint = point.clone();
+          const globalMatrix = text.parent.globalTransMatrix;
+          pickPoint.x = globalMatrix.a * point.x + globalMatrix.c * point.y + globalMatrix.e, pickPoint.y = globalMatrix.b * point.x + globalMatrix.d * point.y + globalMatrix.f;
+        }
+        let picked = !1;
+        return this.canvasRenderer.drawShape(text, pickContext, x, y, {}, null, (context, symbolAttribute, themeAttribute) => {
+          if (picked) return !0;
+          const {
+              fontSize = textAttribute.fontSize,
+              textBaseline = textAttribute.textBaseline,
+              textAlign = textAttribute.textAlign
+            } = text.attribute,
+            bounds = text.AABBBounds,
+            height = bounds.height(),
+            width = bounds.width(),
+            offsetY = textLayoutOffsetY(textBaseline, height, fontSize),
+            offsetX = textDrawOffsetX(textAlign, width);
+          return context.rect(offsetX + x, offsetY + y, width, height, z), picked = context.isPointInPath(pickPoint.x, pickPoint.y), picked;
+        }, (context, symbolAttribute, themeAttribute) => picked), this.canvasRenderer.z = 0, pickContext.modelMatrix !== lastModelMatrix && mat4Allocate.free(pickContext.modelMatrix), pickContext.modelMatrix = lastModelMatrix, pickContext.highPerformanceRestore(), picked;
+      }
+    }
+
+    let loadTextPick$1 = !1;
+    function bindTextCanvasPickerContribution(container) {
+      loadTextPick$1 || (loadTextPick$1 = !0, container.bind(CanvasTextPicker).toDynamicValue(() => new DefaultCanvasTextPicker(resolveContainerBinding(container, TextRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasTextPicker));
+    }
+
+    class DefaultMathTextPicker {
+      constructor() {
+        this.type = "text", this.numberType = TEXT_NUMBER_TYPE;
+      }
+      contains(text, point, params) {
+        return !!text.AABBBounds.containsPoint(point);
+      }
+    }
+
+    let loadTextPick = !1;
+    function bindTextMathPickerContribution(container) {
+      loadTextPick || (loadTextPick = !0, container.bind(MathTextPicker).toDynamicValue(() => new DefaultMathTextPicker()).inSingletonScope(), container.bind(MathPickerContribution).toService(MathTextPicker));
+    }
+
+    function _registerText() {
+      if (_registerText.__loaded) return;
+      _registerText.__loaded = !0;
+      const legacyContext = getLegacyBindingContext();
+      registerTextGraphic(), textModule({
+        bind: legacyContext.bind
+      }), browser ? bindTextCanvasPickerContribution(legacyContext) : bindTextMathPickerContribution(legacyContext);
+    }
+    _registerText.__loaded = !1;
+    const registerText = _registerText;
+
+    const createArc3d = (attributes) => {
+        registerArc3d();
+        return createGraphic$1('arc3d', attributes);
+    };
+    const createPyramid3d = (attributes) => {
+        registerPyramid3d();
+        return createGraphic$1('pyramid3d', attributes);
+    };
+    const createRect3d = (attributes) => {
+        registerRect3d();
+        return createGraphic$1('rect3d', attributes);
+    };
+    const waitForAllSubLayers = (stage) => new Promise(resolve => {
+        vglobal.getRequestAnimationFrame()(() => {
+            resolve(null);
+        });
+    }).then(() => {
+        const promiseList = [];
+        const layers = stage.getChildren();
+        layers.forEach((layer) => {
+            var _a;
+            if (!((_a = layer.subLayers) === null || _a === void 0 ? void 0 : _a.size)) {
+                return;
+            }
+            layer.subLayers.forEach((subLayer) => {
+                const drawContribution = subLayer.drawContribution;
+                if ((drawContribution === null || drawContribution === void 0 ? void 0 : drawContribution.hooks) && drawContribution.rendering) {
+                    promiseList.push(new Promise(resolve => {
+                        drawContribution.hooks.completeDraw.tap('outWait', () => {
+                            drawContribution.hooks.completeDraw.taps = drawContribution.hooks.completeDraw.taps.filter((item) => item.name !== 'outWait');
+                            resolve(null);
+                        });
+                    }));
+                }
+            });
+        });
+        return Promise.all(promiseList);
+    });
+
+    function combineDomains(domains) {
+        const result = [];
+        for (let index = 0; index < domains.length; index++) {
+            const domain = domains[index];
             if (index === 0 || domain[0] !== result[result.length - 1]) {
                 result.push(domain[0]);
             }
@@ -35680,285 +36358,45 @@
           current = element.offsetParent;
         for (; null !== current;) actualTop += current.offsetTop, actualLeft += current.offsetLeft, current = current.offsetParent;
         return {
-          top: actualTop,
-          left: actualLeft
-        };
-      }
-      loadFont(font, source, descriptors) {
-        return __awaiter$1(this, void 0, void 0, function* () {
-          return new FontFace(font, isString$1(source) ? `url(${source})` : source, descriptors).load().then(function (loadedFont) {
-            return document.fonts.add(loadedFont), {
-              loadState: "success"
-            };
-          }).catch(function (error) {
-            return console.error("Failed to load font:", error), {
-              loadState: "fail"
-            };
-          });
-        });
-      }
-      isMacOS() {
-        if (void 0 === this._isMacOS) try {
-          this._isMacOS = navigator.platform.toUpperCase().indexOf("MAC") >= 0;
-        } catch (err) {
-          this._isMacOS = !1;
-        }
-        return this._isMacOS;
-      }
-      copyToClipBoard(text) {
-        return navigator.clipboard.writeText(text).then(() => {}).catch(err => {});
-      }
-    }
-
-    class PickerBase {
-      contains(graphic, point, params) {
-        if (!graphic.AABBBounds.containsPoint(point)) return !1;
-        if ("imprecise" === graphic.attribute.pickMode) return !0;
-        if (!this.canvasRenderer) return !0;
-        const {
-          pickContext: pickContext
-        } = null != params ? params : {};
-        if (!pickContext) return !1;
-        const attribute = graphic.getGraphicTheme();
-        pickContext.highPerformanceSave();
-        let {
-          x = attribute.x,
-          y = attribute.y
-        } = graphic.attribute;
-        if (graphic.transMatrix.onlyTranslate()) {
-          const point = graphic.getOffsetXY(attribute);
-          x += point.x, y += point.y, pickContext.setTransformForCurrent();
-        } else x = 0, y = 0, pickContext.transformFromMatrix(graphic.transMatrix, !0);
-        let picked = !1,
-          _final = !1;
-        return this.canvasRenderer.drawShape(graphic, pickContext, x, y, {}, null, (context, arcAttribute, themeAttribute, final) => !(!picked && !_final) || (picked = context.isPointInPath(point.x, point.y), _final = final || _final, picked), (context, arcAttribute, themeAttribute, final) => {
-          if (picked || _final) return !0;
-          const lineWidth = arcAttribute.lineWidth || themeAttribute.lineWidth,
-            pickStrokeBuffer = arcAttribute.pickStrokeBuffer || themeAttribute.pickStrokeBuffer,
-            keepStrokeScale = arcAttribute.keepStrokeScale || themeAttribute.keepStrokeScale;
-          return pickContext.lineWidth = keepStrokeScale ? lineWidth + pickStrokeBuffer : getScaledStroke(pickContext, lineWidth + pickStrokeBuffer, pickContext.dpr), picked = context.isPointInStroke(point.x, point.y), _final = final || _final, picked;
-        }), pickContext.highPerformanceRestore(), picked;
-      }
-    }
-
-    class DefaultCanvasArcPicker extends PickerBase {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "arc", this.numberType = ARC_NUMBER_TYPE;
-      }
-    }
-
-    let loadArcPick$1 = !1;
-    function bindArcCanvasPickerContribution(container) {
-      loadArcPick$1 || (loadArcPick$1 = !0, container.bind(CanvasArcPicker).toDynamicValue(() => new DefaultCanvasArcPicker(resolveContainerBinding(container, ArcRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasArcPicker));
-    }
-
-    class DefaultCanvasAreaPicker extends PickerBase {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "area", this.numberType = AREA_NUMBER_TYPE;
-      }
-    }
-
-    let loadAreaPick$1 = !1;
-    function bindAreaCanvasPickerContribution(container) {
-      loadAreaPick$1 || (loadAreaPick$1 = !0, container.bind(CanvasAreaPicker).toDynamicValue(() => new DefaultCanvasAreaPicker(resolveContainerBinding(container, AreaRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasAreaPicker));
-    }
-
-    class DefaultCanvasCirclePicker extends PickerBase {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "circle", this.numberType = CIRCLE_NUMBER_TYPE;
-      }
-    }
-
-    let loadCirclePick$1 = !1;
-    function bindCircleCanvasPickerContribution(container) {
-      loadCirclePick$1 || (loadCirclePick$1 = !0, container.bind(CanvasCirclePicker).toDynamicValue(() => new DefaultCanvasCirclePicker(resolveContainerBinding(container, CircleRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasCirclePicker));
-    }
-
-    class GlyphPickerBase {
-      constructor() {
-        this.type = "glyph", this.numberType = GLYPH_NUMBER_TYPE;
-      }
-      contains(glyph, point, params) {
-        if (!glyph.AABBBounds.containsPoint(point)) return !1;
-        if ("imprecise" === glyph.attribute.pickMode) return !0;
-        const {
-          pickContext: pickContext
-        } = null != params ? params : {};
-        if (!pickContext) return !1;
-        const pickerService = null == params ? void 0 : params.pickerService;
-        if (pickerService) {
-          let picked = !1;
-          return glyph.getSubGraphic().forEach(g => {
-            if (picked) return;
-            const data = pickerService.pickItem(g, point, null, params);
-            picked = !(!data || !data.graphic);
-          }), picked;
-        }
-        return !1;
-      }
-    }
-
-    class DefaultCanvasGlyphPicker extends GlyphPickerBase {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer;
-      }
-    }
-
-    let loadGlyphPick$1 = !1;
-    function bindGlyphCanvasPickerContribution(container) {
-      loadGlyphPick$1 || (loadGlyphPick$1 = !0, container.bind(CanvasGlyphPicker).toDynamicValue(() => new DefaultCanvasGlyphPicker(resolveContainerBinding(container, GlyphRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasGlyphPicker));
-    }
-
-    class DefaultCanvasImagePicker extends PickerBase {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "image", this.numberType = IMAGE_NUMBER_TYPE;
-      }
-    }
-
-    let loadImagePick$1 = !1;
-    function bindImageCanvasPickerContribution(container) {
-      loadImagePick$1 || (loadImagePick$1 = !0, container.bind(CanvasImagePicker).toDynamicValue(() => new DefaultCanvasImagePicker(resolveContainerBinding(container, ImageRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasImagePicker));
-    }
-
-    class BaseLinePicker extends BaseRender {
-      contains(graphic, point, params) {
-        if (!graphic.AABBBounds.containsPoint(point)) return !1;
-        if ("imprecise" === graphic.attribute.pickMode) return !0;
-        const {
-          pickContext: pickContext
-        } = null != params ? params : {};
-        if (!pickContext) return !1;
-        pickContext.highPerformanceSave();
-        const lineAttribute = graphic.getGraphicTheme(),
-          data = this.transform(graphic, lineAttribute, pickContext),
-          {
-            x: x,
-            y: y,
-            z: z,
-            lastModelMatrix: lastModelMatrix
-          } = data;
-        let pickPoint = point;
-        if (pickContext.camera) {
-          pickPoint = point.clone();
-          const globalMatrix = graphic.parent.globalTransMatrix;
-          pickPoint.x = globalMatrix.a * point.x + globalMatrix.c * point.y + globalMatrix.e, pickPoint.y = globalMatrix.b * point.x + globalMatrix.d * point.y + globalMatrix.f;
-        }
-        this.canvasRenderer.z = z;
-        let picked = !1;
-        return this.canvasRenderer.drawShape(graphic, pickContext, x, y, {}, null, context => !!picked || (picked = context.isPointInPath(pickPoint.x, pickPoint.y), picked), (context, lineAttribute, themeAttribute) => {
-          if (picked) return !0;
-          const lineWidth = lineAttribute.lineWidth || themeAttribute.lineWidth,
-            pickStrokeBuffer = lineAttribute.pickStrokeBuffer || themeAttribute.pickStrokeBuffer,
-            keepStrokeScale = lineAttribute.keepStrokeScale || themeAttribute.keepStrokeScale;
-          return pickContext.lineWidth = keepStrokeScale ? lineWidth + pickStrokeBuffer : getScaledStroke(pickContext, lineWidth + pickStrokeBuffer, pickContext.dpr), picked = context.isPointInStroke(pickPoint.x, pickPoint.y), picked;
-        }), this.canvasRenderer.z = 0, pickContext.modelMatrix !== lastModelMatrix && mat4Allocate.free(pickContext.modelMatrix), pickContext.modelMatrix = lastModelMatrix, pickContext.highPerformanceRestore(), picked;
-      }
-    }
-
-    class DefaultCanvasLinePicker extends BaseLinePicker {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "line", this.numberType = LINE_NUMBER_TYPE;
-      }
-    }
-
-    let loadLinePick$1 = !1;
-    function bindLineCanvasPickerContribution(container) {
-      loadLinePick$1 || (loadLinePick$1 = !0, container.bind(CanvasLinePicker).toDynamicValue(() => new DefaultCanvasLinePicker(resolveContainerBinding(container, LineRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasLinePicker));
-    }
-
-    class DefaultCanvasPathPicker extends BaseLinePicker {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "path", this.numberType = PATH_NUMBER_TYPE;
-      }
-    }
-
-    let loadPathPick$1 = !1;
-    function bindPathCanvasPickerContribution(container) {
-      loadPathPick$1 || (loadPathPick$1 = !0, container.bind(CanvasPathPicker).toDynamicValue(() => new DefaultCanvasPathPicker(resolveContainerBinding(container, PathRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasPathPicker));
-    }
-
-    class DefaultCanvasPolygonPicker extends PickerBase {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "polygon", this.numberType = POLYGON_NUMBER_TYPE;
+          top: actualTop,
+          left: actualLeft
+        };
       }
-    }
-
-    let loadPolygonPick$1 = !1;
-    function bindPolygonCanvasPickerContribution(container) {
-      loadPolygonPick$1 || (loadPolygonPick$1 = !0, container.bind(CanvasPolygonPicker).toDynamicValue(() => new DefaultCanvasPolygonPicker(resolveContainerBinding(container, PolygonRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasPolygonPicker));
-    }
-
-    const _bounds = new AABBBounds();
-    class RectPickerBase {
-      constructor() {
-        this.type = "rect", this.numberType = RECT_NUMBER_TYPE;
+      loadFont(font, source, descriptors) {
+        return __awaiter$1(this, void 0, void 0, function* () {
+          return new FontFace(font, isString$1(source) ? `url(${source})` : source, descriptors).load().then(function (loadedFont) {
+            return document.fonts.add(loadedFont), {
+              loadState: "success"
+            };
+          }).catch(function (error) {
+            return console.error("Failed to load font:", error), {
+              loadState: "fail"
+            };
+          });
+        });
       }
-      contains(rect, point, params) {
-        if (!rect.AABBBounds.containsPoint(point)) return !1;
-        if ("imprecise" === rect.attribute.pickMode) return !0;
-        const {
-          pickContext: pickContext
-        } = null != params ? params : {};
-        if (!pickContext) return !1;
-        const rectAttribute = rect.getGraphicTheme(),
-          {
-            cornerRadius = rectAttribute.cornerRadius
-          } = rect.attribute;
-        let {
-          x = rectAttribute.x,
-          y = rectAttribute.y
-        } = rect.attribute;
-        pickContext.highPerformanceSave();
-        let onlyTranslate = !0;
-        if (rect.transMatrix.onlyTranslate()) {
-          const point = rect.getOffsetXY(rectAttribute);
-          x += point.x, y += point.y, pickContext.setTransformForCurrent();
-        } else x = 0, y = 0, onlyTranslate = !1, pickContext.transformFromMatrix(rect.transMatrix, !0);
-        let picked = !0;
-        if (!onlyTranslate || rect.shadowRoot || isNumber$1(cornerRadius, !0) && 0 !== cornerRadius || isArray$1(cornerRadius) && cornerRadius.some(num => 0 !== num)) picked = !1, this.canvasRenderer.drawShape(rect, pickContext, x, y, {}, null, (context, rectAttribute, themeAttribute) => !!picked || (picked = context.isPointInPath(point.x, point.y), picked), (context, rectAttribute, themeAttribute) => {
-          if (picked) return !0;
-          const lineWidth = rectAttribute.lineWidth || themeAttribute.lineWidth,
-            pickStrokeBuffer = rectAttribute.pickStrokeBuffer || themeAttribute.pickStrokeBuffer,
-            keepStrokeScale = rectAttribute.keepStrokeScale || themeAttribute.keepStrokeScale;
-          return pickContext.lineWidth = keepStrokeScale ? lineWidth + pickStrokeBuffer : getScaledStroke(pickContext, lineWidth + pickStrokeBuffer, pickContext.dpr), picked = context.isPointInStroke(point.x, point.y), picked;
-        });else {
-          const {
-            fill = rectAttribute.fill,
-            stroke = rectAttribute.stroke,
-            lineWidth = rectAttribute.lineWidth
-          } = rect.attribute;
-          if (fill) picked = !0;else if (stroke) {
-            const bounds = rect.AABBBounds;
-            _bounds.setValue(bounds.x1, bounds.y1, bounds.x2, bounds.y2), _bounds.expand(-lineWidth / 2), picked = !_bounds.containsPoint(point);
-          }
+      isMacOS() {
+        if (void 0 === this._isMacOS) try {
+          this._isMacOS = navigator.platform.toUpperCase().indexOf("MAC") >= 0;
+        } catch (err) {
+          this._isMacOS = !1;
         }
-        return pickContext.highPerformanceRestore(), picked;
+        return this._isMacOS;
       }
-    }
-
-    class DefaultCanvasRectPicker extends RectPickerBase {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer;
+      copyToClipBoard(text) {
+        return navigator.clipboard.writeText(text).then(() => {}).catch(err => {});
       }
     }
 
-    let loadRectPick$1 = !1;
-    function bindRectCanvasPickerContribution(container) {
-      loadRectPick$1 || (loadRectPick$1 = !0, container.bind(CanvasRectPicker).toDynamicValue(() => new DefaultCanvasRectPicker(resolveContainerBinding(container, RectRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasRectPicker));
-    }
-
-    class DefaultCanvasRichTextPicker {
+    class DefaultCanvasCirclePicker extends PickerBase {
       constructor(canvasRenderer) {
-        this.canvasRenderer = canvasRenderer, this.type = "richtext", this.numberType = RICHTEXT_NUMBER_TYPE;
-      }
-      contains(richtext, point, params) {
-        return !!richtext.AABBBounds.containsPoint(point);
+        super(), this.canvasRenderer = canvasRenderer, this.type = "circle", this.numberType = CIRCLE_NUMBER_TYPE;
       }
     }
 
-    let loadRichtextPick = !1;
-    function bindRichtextCanvasPickerContribution(container) {
-      loadRichtextPick || (loadRichtextPick = !0, container.bind(CanvasRichTextPicker).toDynamicValue(() => new DefaultCanvasRichTextPicker(resolveContainerBinding(container, RichTextRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasRichTextPicker));
+    let loadCirclePick$1 = !1;
+    function bindCircleCanvasPickerContribution(container) {
+      loadCirclePick$1 || (loadCirclePick$1 = !0, container.bind(CanvasCirclePicker).toDynamicValue(() => new DefaultCanvasCirclePicker(resolveContainerBinding(container, CircleRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasCirclePicker));
     }
 
     class DefaultCanvasStarPicker extends PickerBase {
@@ -35973,106 +36411,6 @@
       loadStarPick || (null === (_a = container.isBound) || void 0 === _a ? void 0 : _a.call(container, StarRender)) && (loadStarPick = !0, container.bind(CanvasStarPicker).toDynamicValue(() => new DefaultCanvasStarPicker(resolveContainerBinding(container, StarRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasStarPicker));
     }
 
-    class DefaultCanvasSymbolPicker extends Base3dPicker {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "symbol", this.numberType = SYMBOL_NUMBER_TYPE;
-      }
-      contains(symbol, point, params) {
-        const {
-          pickContext: pickContext
-        } = null != params ? params : {};
-        if (!pickContext) return !1;
-        const parsedPath = symbol.getParsedPath();
-        if (!pickContext.camera) {
-          if (!symbol.AABBBounds.containsPoint(point)) return !1;
-          if (parsedPath.isSvg || "imprecise" === symbol.attribute.pickMode) return !0;
-        }
-        pickContext.highPerformanceSave();
-        const symbolAttribute = symbol.getGraphicTheme(),
-          data = this.transform(symbol, symbolAttribute, pickContext),
-          {
-            x: x,
-            y: y,
-            z: z,
-            lastModelMatrix: lastModelMatrix
-          } = data;
-        let pickPoint = point;
-        if (pickContext.camera) {
-          pickPoint = point.clone();
-          const globalMatrix = symbol.parent.globalTransMatrix;
-          pickPoint.x = globalMatrix.a * point.x + globalMatrix.c * point.y + globalMatrix.e, pickPoint.y = globalMatrix.b * point.x + globalMatrix.d * point.y + globalMatrix.f;
-        }
-        this.canvasRenderer.z = z;
-        let picked = !1;
-        return this.canvasRenderer.drawShape(symbol, pickContext, x, y, {}, null, (context, symbolAttribute, themeAttribute) => !!picked || (picked = context.isPointInPath(pickPoint.x, pickPoint.y), picked), (context, symbolAttribute, themeAttribute) => {
-          if (picked) return !0;
-          const lineWidth = symbolAttribute.lineWidth || themeAttribute.lineWidth,
-            pickStrokeBuffer = symbolAttribute.pickStrokeBuffer || themeAttribute.pickStrokeBuffer,
-            keepStrokeScale = symbolAttribute.keepStrokeScale || themeAttribute.keepStrokeScale;
-          return pickContext.lineWidth = keepStrokeScale ? lineWidth + pickStrokeBuffer : getScaledStroke(pickContext, lineWidth + pickStrokeBuffer, pickContext.dpr), picked = context.isPointInStroke(pickPoint.x, pickPoint.y), picked;
-        }), this.canvasRenderer.z = 0, pickContext.modelMatrix !== lastModelMatrix && mat4Allocate.free(pickContext.modelMatrix), pickContext.modelMatrix = lastModelMatrix, pickContext.highPerformanceRestore(), picked;
-      }
-    }
-
-    let loadSymbolPick$1 = !1;
-    function bindSymbolCanvasPickerContribution(container) {
-      loadSymbolPick$1 || (loadSymbolPick$1 = !0, container.bind(CanvasSymbolPicker).toDynamicValue(() => new DefaultCanvasSymbolPicker(resolveContainerBinding(container, SymbolRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasSymbolPicker));
-    }
-
-    class DefaultCanvasTextPicker extends Base3dPicker {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "text", this.numberType = TEXT_NUMBER_TYPE;
-      }
-      contains(text, point, params) {
-        const {
-          pickContext: pickContext
-        } = null != params ? params : {};
-        if (!pickContext) return !1;
-        const bounds = text.AABBBounds;
-        if (!pickContext.camera) return !!bounds.containsPoint(point);
-        pickContext.highPerformanceSave();
-        const textAttribute = text.getGraphicTheme(),
-          {
-            keepDirIn3d = textAttribute.keepDirIn3d
-          } = text.attribute,
-          computed3dMatrix = !keepDirIn3d,
-          data = this.transform(text, textAttribute, pickContext, computed3dMatrix),
-          {
-            x: x,
-            y: y,
-            z: z,
-            lastModelMatrix: lastModelMatrix
-          } = data;
-        this.canvasRenderer.z = z;
-        let pickPoint = point;
-        if (pickContext.camera) {
-          pickPoint = point.clone();
-          const globalMatrix = text.parent.globalTransMatrix;
-          pickPoint.x = globalMatrix.a * point.x + globalMatrix.c * point.y + globalMatrix.e, pickPoint.y = globalMatrix.b * point.x + globalMatrix.d * point.y + globalMatrix.f;
-        }
-        let picked = !1;
-        return this.canvasRenderer.drawShape(text, pickContext, x, y, {}, null, (context, symbolAttribute, themeAttribute) => {
-          if (picked) return !0;
-          const {
-              fontSize = textAttribute.fontSize,
-              textBaseline = textAttribute.textBaseline,
-              textAlign = textAttribute.textAlign
-            } = text.attribute,
-            bounds = text.AABBBounds,
-            height = bounds.height(),
-            width = bounds.width(),
-            offsetY = textLayoutOffsetY(textBaseline, height, fontSize),
-            offsetX = textDrawOffsetX(textAlign, width);
-          return context.rect(offsetX + x, offsetY + y, width, height, z), picked = context.isPointInPath(pickPoint.x, pickPoint.y), picked;
-        }, (context, symbolAttribute, themeAttribute) => picked), this.canvasRenderer.z = 0, pickContext.modelMatrix !== lastModelMatrix && mat4Allocate.free(pickContext.modelMatrix), pickContext.modelMatrix = lastModelMatrix, pickContext.highPerformanceRestore(), picked;
-      }
-    }
-
-    let loadTextPick$1 = !1;
-    function bindTextCanvasPickerContribution(container) {
-      loadTextPick$1 || (loadTextPick$1 = !0, container.bind(CanvasTextPicker).toDynamicValue(() => new DefaultCanvasTextPicker(resolveContainerBinding(container, TextRender))).inSingletonScope(), container.bind(CanvasPickerContribution).toService(CanvasTextPicker));
-    }
-
     class DefaultCanvasPickerService extends DefaultPickService {
       constructor(contributions, drawContribution, pickItemInterceptorContributions, pickServiceInterceptorContributions) {
         super(pickItemInterceptorContributions, pickServiceInterceptorContributions), this.contributions = contributions, this.drawContribution = drawContribution, this.pickItemInterceptorContributions = pickItemInterceptorContributions, this.pickServiceInterceptorContributions = pickServiceInterceptorContributions, this.global.hooks.onSetEnv.tap("canvas-picker-service", (_, env, global) => {
@@ -36382,78 +36720,32 @@
       register: registerShadowRootGraphic
     }, {
       register: registerStarGraphic,
-      bindModule: starModule
-    }, {
-      register: registerSymbolGraphic,
-      bindModule: symbolModule
-    }, {
-      register: registerTextGraphic,
-      bindModule: textModule
-    }, {
-      register: registerWrapTextGraphic
-    }];
-    let standardGraphicsInstalled = !1;
-    function ensureStandardGraphicsInstalled() {
-      if (standardGraphicsInstalled) return;
-      const bindingContext = getRuntimeInstallerBindingContext();
-      standardGraphicsInstalled = !0, standardGraphicInstallSteps.forEach(({
-        register: register,
-        bindModule: bindModule
-      }) => {
-        register(), null == bindModule || bindModule({
-          bind: bindingContext.bind
-        });
-      }), refreshRuntimeInstallerContributions();
-    }
-    function installStandardGraphicsToApp(app) {
-      configureRuntimeApplicationForApp(app), ensureStandardGraphicsInstalled(), installRuntimeDrawContributionsToApp(app), installRuntimeGraphicRenderersToApp(app);
-    }
-
-    const browser = isBrowserEnv();
-
-    class DefaultMathArcPicker extends PickerBase {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "arc", this.numberType = ARC_NUMBER_TYPE;
-      }
-    }
-
-    let loadArcPick = !1;
-    function bindArcMathPickerContribution(container) {
-      loadArcPick || (loadArcPick = !0, container.bind(MathArcPicker).toDynamicValue(() => new DefaultMathArcPicker(resolveContainerBinding(container, ArcRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathArcPicker));
-    }
-
-    function _registerArc() {
-      if (_registerArc.__loaded) return;
-      _registerArc.__loaded = !0;
-      const legacyContext = getLegacyBindingContext();
-      registerArcGraphic(), arcModule({
-        bind: legacyContext.bind
-      }), browser ? bindArcCanvasPickerContribution(legacyContext) : bindArcMathPickerContribution(legacyContext);
-    }
-    _registerArc.__loaded = !1;
-    const registerArc = _registerArc;
-
-    class DefaultMathAreaPicker extends PickerBase {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "area", this.numberType = AREA_NUMBER_TYPE;
-      }
-    }
-
-    let loadAreaPick = !1;
-    function bindAreaMathPickerContribution(container) {
-      loadAreaPick || (loadAreaPick = !0, container.bind(MathAreaPicker).toDynamicValue(() => new DefaultMathAreaPicker(resolveContainerBinding(container, AreaRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathAreaPicker));
+      bindModule: starModule
+    }, {
+      register: registerSymbolGraphic,
+      bindModule: symbolModule
+    }, {
+      register: registerTextGraphic,
+      bindModule: textModule
+    }, {
+      register: registerWrapTextGraphic
+    }];
+    let standardGraphicsInstalled = !1;
+    function ensureStandardGraphicsInstalled() {
+      if (standardGraphicsInstalled) return;
+      const bindingContext = getRuntimeInstallerBindingContext();
+      standardGraphicsInstalled = !0, standardGraphicInstallSteps.forEach(({
+        register: register,
+        bindModule: bindModule
+      }) => {
+        register(), null == bindModule || bindModule({
+          bind: bindingContext.bind
+        });
+      }), refreshRuntimeInstallerContributions();
     }
-
-    function _registerArea() {
-      if (_registerArea.__loaded) return;
-      _registerArea.__loaded = !0;
-      const legacyContext = getLegacyBindingContext();
-      registerAreaGraphic(), areaModule({
-        bind: legacyContext.bind
-      }), browser ? bindAreaCanvasPickerContribution(legacyContext) : bindAreaMathPickerContribution(legacyContext);
+    function installStandardGraphicsToApp(app) {
+      configureRuntimeApplicationForApp(app), ensureStandardGraphicsInstalled(), installRuntimeDrawContributionsToApp(app), installRuntimeGraphicRenderersToApp(app);
     }
-    _registerArea.__loaded = !1;
-    const registerArea = _registerArea;
 
     class DefaultMathCirclePicker extends PickerBase {
       constructor(canvasRenderer) {
@@ -36477,181 +36769,6 @@
     _registerCircle.__loaded = !1;
     const registerCircle = _registerCircle;
 
-    class DefaultMathGlyphPicker extends GlyphPickerBase {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer;
-      }
-    }
-
-    let loadGlyphPick = !1;
-    function bindGlyphMathPickerContribution(container) {
-      loadGlyphPick || (loadGlyphPick = !0, container.bind(MathGlyphPicker).toDynamicValue(() => new DefaultMathGlyphPicker(resolveContainerBinding(container, GlyphRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathGlyphPicker));
-    }
-
-    function _registerGlyph() {
-      if (_registerGlyph.__loaded) return;
-      _registerGlyph.__loaded = !0;
-      const legacyContext = getLegacyBindingContext();
-      registerGlyphGraphic(), glyphModule({
-        bind: legacyContext.bind
-      }), browser ? bindGlyphCanvasPickerContribution(legacyContext) : bindGlyphMathPickerContribution(legacyContext);
-    }
-    _registerGlyph.__loaded = !1;
-    const registerGlyph = _registerGlyph;
-
-    function _registerGroup() {
-      _registerGroup.__loaded || (_registerGroup.__loaded = !0, registerGroupGraphic());
-    }
-    _registerGroup.__loaded = !1;
-    const registerGroup = _registerGroup;
-
-    class DefaultMathImagePicker {
-      constructor() {
-        this.type = "image", this.numberType = IMAGE_NUMBER_TYPE;
-      }
-      contains(image, point, params) {
-        const {
-          pickContext: pickContext
-        } = null != params ? params : {};
-        return !!pickContext && !!image.AABBBounds.containsPoint(point);
-      }
-    }
-
-    let loadImagePick = !1;
-    function bindImageMathPickerContribution(container) {
-      loadImagePick || (loadImagePick = !0, container.bind(MathImagePicker).toDynamicValue(() => new DefaultMathImagePicker()).inSingletonScope(), container.bind(MathPickerContribution).toService(MathImagePicker));
-    }
-
-    function _registerImage() {
-      if (_registerImage.__loaded) return;
-      _registerImage.__loaded = !0;
-      const legacyContext = getLegacyBindingContext();
-      registerImageGraphic(), imageModule({
-        bind: legacyContext.bind
-      }), browser ? bindImageCanvasPickerContribution(legacyContext) : bindImageMathPickerContribution(legacyContext);
-    }
-    _registerImage.__loaded = !1;
-    const registerImage = _registerImage;
-
-    class DefaultMathLinePicker extends PickerBase {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "line", this.numberType = LINE_NUMBER_TYPE;
-      }
-    }
-
-    let loadLinePick = !1;
-    function bindLineMathPickerContribution(container) {
-      loadLinePick || (loadLinePick = !0, container.bind(MathLinePicker).toDynamicValue(() => new DefaultMathLinePicker(resolveContainerBinding(container, LineRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathLinePicker));
-    }
-
-    function _registerLine() {
-      if (_registerLine.__loaded) return;
-      _registerLine.__loaded = !0;
-      const legacyContext = getLegacyBindingContext();
-      registerLineGraphic(), lineModule({
-        bind: legacyContext.bind
-      }), browser ? bindLineCanvasPickerContribution(legacyContext) : bindLineMathPickerContribution(legacyContext);
-    }
-    _registerLine.__loaded = !1;
-    const registerLine = _registerLine;
-
-    class DefaultMathPathPicker extends PickerBase {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "path", this.numberType = PATH_NUMBER_TYPE;
-      }
-    }
-
-    let loadPathPick = !1;
-    function bindPathMathPickerContribution(container) {
-      loadPathPick || (loadPathPick = !0, container.bind(MathPathPicker).toDynamicValue(() => new DefaultMathPathPicker(resolveContainerBinding(container, PathRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathPathPicker));
-    }
-
-    function _registerPath() {
-      if (_registerPath.__loaded) return;
-      _registerPath.__loaded = !0;
-      const legacyContext = getLegacyBindingContext();
-      registerPathGraphic(), pathModule({
-        bind: legacyContext.bind
-      }), browser ? bindPathCanvasPickerContribution(legacyContext) : bindPathMathPickerContribution(legacyContext);
-    }
-    _registerPath.__loaded = !1;
-    const registerPath = _registerPath;
-
-    class DefaultMathPolygonPicker extends PickerBase {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "polygon", this.numberType = POLYGON_NUMBER_TYPE;
-      }
-    }
-
-    let loadPolygonPick = !1;
-    function bindPolygonMathPickerContribution(container) {
-      loadPolygonPick || (loadPolygonPick = !0, container.bind(MathPolygonPicker).toDynamicValue(() => new DefaultMathPolygonPicker(resolveContainerBinding(container, PolygonRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathPolygonPicker));
-    }
-
-    function _registerPolygon() {
-      if (_registerPolygon.__loaded) return;
-      _registerPolygon.__loaded = !0;
-      const legacyContext = getLegacyBindingContext();
-      registerPolygonGraphic(), polygonModule({
-        bind: legacyContext.bind
-      }), browser ? bindPolygonCanvasPickerContribution(legacyContext) : bindPolygonMathPickerContribution(legacyContext);
-    }
-    _registerPolygon.__loaded = !1;
-    const registerPolygon = _registerPolygon;
-
-    class DefaultMathRectPicker extends RectPickerBase {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer;
-      }
-    }
-
-    let loadRectPick = !1;
-    function bindRectMathPickerContribution(container) {
-      loadRectPick || (loadRectPick = !0, container.bind(MathRectPicker).toDynamicValue(() => new DefaultMathRectPicker(resolveContainerBinding(container, RectRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathRectPicker));
-    }
-
-    function _registerRect() {
-      if (_registerRect.__loaded) return;
-      _registerRect.__loaded = !0;
-      const legacyContext = getLegacyBindingContext();
-      registerRectGraphic(), rectModule({
-        bind: legacyContext.bind
-      }), browser ? bindRectCanvasPickerContribution(legacyContext) : bindRectMathPickerContribution(legacyContext);
-    }
-    _registerRect.__loaded = !1;
-    const registerRect = _registerRect;
-
-    class DefaultMathRichTextPicker {
-      constructor(canvasRenderer) {
-        this.canvasRenderer = canvasRenderer, this.type = "richtext", this.numberType = RICHTEXT_NUMBER_TYPE;
-      }
-      contains(richtext, point, params) {
-        return !!richtext.AABBBounds.containsPoint(point);
-      }
-    }
-
-    let loadRichTextPick = !1;
-    function bindRichTextMathPickerContribution(container) {
-      loadRichTextPick || (loadRichTextPick = !0, container.bind(MathRichTextPicker).toDynamicValue(() => new DefaultMathRichTextPicker(resolveContainerBinding(container, RichTextRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathRichTextPicker));
-    }
-
-    function _registerRichtext() {
-      if (_registerRichtext.__loaded) return;
-      _registerRichtext.__loaded = !0;
-      const legacyContext = getLegacyBindingContext();
-      registerRichtextGraphic(), richtextModule({
-        bind: legacyContext.bind
-      }), browser ? bindRichtextCanvasPickerContribution(legacyContext) : bindRichTextMathPickerContribution(legacyContext);
-    }
-    _registerRichtext.__loaded = !1;
-    const registerRichtext = _registerRichtext;
-
-    function _registerShadowRoot() {
-      _registerShadowRoot.__loaded || (_registerShadowRoot.__loaded = !0, registerShadowRootGraphic());
-    }
-    _registerShadowRoot.__loaded = !1;
-    const registerShadowRoot = _registerShadowRoot;
-
     function _registerStar() {
       if (_registerStar.__loaded) return;
       _registerStar.__loaded = !0;
@@ -36663,53 +36780,6 @@
     _registerStar.__loaded = !1;
     const registerStar = _registerStar;
 
-    class DefaultMathSymbolPicker extends PickerBase {
-      constructor(canvasRenderer) {
-        super(), this.canvasRenderer = canvasRenderer, this.type = "symbol", this.numberType = SYMBOL_NUMBER_TYPE;
-      }
-    }
-
-    let loadSymbolPick = !1;
-    function bindSymbolMathPickerContribution(container) {
-      loadSymbolPick || (loadSymbolPick = !0, container.bind(MathSymbolPicker).toDynamicValue(() => new DefaultMathSymbolPicker(resolveContainerBinding(container, SymbolRender))).inSingletonScope(), container.bind(MathPickerContribution).toService(MathSymbolPicker));
-    }
-
-    function _registerSymbol() {
-      if (_registerSymbol.__loaded) return;
-      _registerSymbol.__loaded = !0;
-      const legacyContext = getLegacyBindingContext();
-      registerSymbolGraphic(), symbolModule({
-        bind: legacyContext.bind
-      }), browser ? bindSymbolCanvasPickerContribution(legacyContext) : bindSymbolMathPickerContribution(legacyContext);
-    }
-    _registerSymbol.__loaded = !1;
-    const registerSymbol = _registerSymbol;
-
-    class DefaultMathTextPicker {
-      constructor() {
-        this.type = "text", this.numberType = TEXT_NUMBER_TYPE;
-      }
-      contains(text, point, params) {
-        return !!text.AABBBounds.containsPoint(point);
-      }
-    }
-
-    let loadTextPick = !1;
-    function bindTextMathPickerContribution(container) {
-      loadTextPick || (loadTextPick = !0, container.bind(MathTextPicker).toDynamicValue(() => new DefaultMathTextPicker()).inSingletonScope(), container.bind(MathPickerContribution).toService(MathTextPicker));
-    }
-
-    function _registerText() {
-      if (_registerText.__loaded) return;
-      _registerText.__loaded = !0;
-      const legacyContext = getLegacyBindingContext();
-      registerTextGraphic(), textModule({
-        bind: legacyContext.bind
-      }), browser ? bindTextCanvasPickerContribution(legacyContext) : bindTextMathPickerContribution(legacyContext);
-    }
-    _registerText.__loaded = !1;
-    const registerText = _registerText;
-
     function _registerWrapText() {
       _registerWrapText.__loaded || (_registerWrapText.__loaded = !0, registerWrapTextGraphic());
     }