@blakron/core 0.5.18 → 0.6.0

package/dist/blakron/display/DisplayObject.js

@@ -17,16 +17,16 @@ function clampRotation(value) {
 export class DisplayObject extends EventDispatcher {
     // ── Static fields ─────────────────────────────────────────────────────────
     static defaultTouchEnabled = false;
-    static enterFrameCallBackList = [];
-    static renderCallBackList = [];
-    static eventAddToStageList = [];
-    static eventRemoveFromStageList = [];
+    static $enterFrameCallBackList = [];
+    static $renderCallBackList = [];
+    static $eventAddToStageList = [];
+    static $eventRemoveFromStageList = [];
     /**
      * @internal
-     * Injected by Player at startup. Called when renderMode changes (visible,
+     * Injected by Player at startup. Called when $renderMode changes (visible,
      * filters, mask, blendMode) so the WebGLRenderer can mark its InstructionSet dirty.
      */
-    static _onStructureChange;
+    static $onStructureChange;
     /**
      * @internal
      * Injected by Player at startup. Called when a DisplayObject's visual data
@@ -34,19 +34,19 @@ export class DisplayObject extends EventDispatcher {
      * The renderer uses this to update the transform snapshot in the InstructionSet
      * without doing a full rebuild.
      */
-    static _onRenderableDirty;
+    static $onRenderableDirty;
     /**
      * @internal Register a structure-change listener. Returns an unregister function.
      * Using a registration pattern instead of a single static field supports
      * multiple Player instances on the same page.
      */
     static addStructureChangeListener(fn) {
-        const prev = DisplayObject._onStructureChange;
+        const prev = DisplayObject.$onStructureChange;
         if (!prev) {
-            DisplayObject._onStructureChange = fn;
+            DisplayObject.$onStructureChange = fn;
         }
         else {
-            DisplayObject._onStructureChange = () => {
+            DisplayObject.$onStructureChange = () => {
                 prev();
                 fn();
             };
@@ -54,8 +54,8 @@ export class DisplayObject extends EventDispatcher {
         return () => {
             // Simple removal: if only one listener, clear; otherwise rebuild chain.
             // For the common single-player case this is zero overhead.
-            if (DisplayObject._onStructureChange === fn) {
-                DisplayObject._onStructureChange = undefined;
+            if (DisplayObject.$onStructureChange === fn) {
+                DisplayObject.$onStructureChange = undefined;
             }
         };
     }
@@ -63,62 +63,62 @@ export class DisplayObject extends EventDispatcher {
      * @internal Register a renderable-dirty listener. Returns an unregister function.
      */
     static addRenderableDirtyListener(fn) {
-        const prev = DisplayObject._onRenderableDirty;
+        const prev = DisplayObject.$onRenderableDirty;
         if (!prev) {
-            DisplayObject._onRenderableDirty = fn;
+            DisplayObject.$onRenderableDirty = fn;
         }
         else {
-            DisplayObject._onRenderableDirty = obj => {
+            DisplayObject.$onRenderableDirty = obj => {
                 prev(obj);
                 fn(obj);
             };
         }
         return () => {
-            if (DisplayObject._onRenderableDirty === fn) {
-                DisplayObject._onRenderableDirty = undefined;
+            if (DisplayObject.$onRenderableDirty === fn) {
+                DisplayObject.$onRenderableDirty = undefined;
             }
         };
     }
     // ── Instance fields ───────────────────────────────────────────────────────
     // 场景图
-    hasAddToStage = false;
-    children;
-    internalParent;
-    internalStage;
-    nestLevel = 0;
+    $hasAddToStage = false;
+    $children;
+    $parent;
+    $stage;
+    $nestLevel = 0;
     // 变换
-    internalX = 0;
-    internalY = 0;
-    internalAnchorOffsetX = 0;
-    internalAnchorOffsetY = 0;
-    explicitWidth = NaN;
-    explicitHeight = NaN;
-    useTranslate = false;
+    $x = 0;
+    $y = 0;
+    $anchorOffsetX = 0;
+    $anchorOffsetY = 0;
+    $explicitWidth = NaN;
+    $explicitHeight = NaN;
+    $useTranslate = false;
     // 外观
-    internalVisible = true;
-    internalAlpha = 1;
-    internalBlendMode = 0;
-    internalFilters = [];
-    internalCacheAsBitmap = false;
-    internalTouchEnabled = DisplayObject.defaultTouchEnabled;
+    $visible = true;
+    $alpha = 1;
+    $blendMode = 0;
+    $filters = [];
+    $cacheAsBitmap = false;
+    $touchEnabled = DisplayObject.defaultTouchEnabled;
     // 遮罩
-    internalMask;
-    internalMaskRect;
-    internalScrollRect;
-    maskedObject;
+    $mask;
+    $maskRect;
+    $scrollRect;
+    $maskedObject;
     // 渲染状态
-    renderMode;
-    renderObjectType = 0 /* RenderObjectType.NONE */;
-    renderDirty = false;
-    cacheDirty = false;
-    displayList;
-    // 世界缓存（markDirty 更新，O(1) 读取）
-    worldAlpha = 1;
-    worldTint = 0xffffff;
-    tintRGB = 0;
+    $renderMode;
+    $renderObjectType = 0 /* RenderObjectType.NONE */;
+    $renderDirty = false;
+    $cacheDirty = false;
+    $displayList;
+    // 世界缓存（$markDirty 更新，O(1) 读取）
+    $worldAlpha = 1;
+    $worldTint = 0xffffff;
+    $tintRGB = 0;
     // 排序
-    sortDirty = false;
-    lastSortedIndex = 0;
+    $sortDirty = false;
+    $lastSortedIndex = 0;
     // bounds 缓存
     _boundsDirty = true;
     _cachedBounds = new Rectangle();
@@ -155,153 +155,153 @@ export class DisplayObject extends EventDispatcher {
         this._name = value;
     }
     get parent() {
-        return this.internalParent;
+        return this.$parent;
     }
     get stage() {
-        return this.internalStage;
+        return this.$stage;
     }
     get matrix() {
-        return this.getMatrix().clone();
+        return this.$getMatrix().clone();
     }
     set matrix(value) {
-        this.setMatrix(value);
+        this.$setMatrix(value);
     }
     get x() {
-        return this.internalX;
+        return this.$x;
     }
     set x(value) {
-        this.setX(value);
+        this.$setX(value);
     }
     get y() {
-        return this.internalY;
+        return this.$y;
     }
     set y(value) {
-        this.setY(value);
+        this.$setY(value);
     }
     get scaleX() {
         return this._scaleX;
     }
     set scaleX(value) {
-        this.setScaleX(value);
+        this.$setScaleX(value);
     }
     get scaleY() {
         return this._scaleY;
     }
     set scaleY(value) {
-        this.setScaleY(value);
+        this.$setScaleY(value);
     }
     get rotation() {
         return this._rotation;
     }
     set rotation(value) {
-        this.setRotation(value);
+        this.$setRotation(value);
     }
     get skewX() {
         return this._skewXdeg;
     }
     set skewX(value) {
-        this.setSkewX(value);
+        this.$setSkewX(value);
     }
     get skewY() {
         return this._skewYdeg;
     }
     set skewY(value) {
-        this.setSkewY(value);
+        this.$setSkewY(value);
     }
     get width() {
-        return isNaN(this.explicitWidth) ? this.getOriginalBounds().width : this.explicitWidth;
+        return isNaN(this.$explicitWidth) ? this.$getOriginalBounds().width : this.$explicitWidth;
     }
     set width(value) {
-        this.explicitWidth = isNaN(value) ? NaN : value;
+        this.$explicitWidth = isNaN(value) ? NaN : value;
     }
     get height() {
-        return isNaN(this.explicitHeight) ? this.getOriginalBounds().height : this.explicitHeight;
+        return isNaN(this.$explicitHeight) ? this.$getOriginalBounds().height : this.$explicitHeight;
     }
     set height(value) {
-        this.explicitHeight = isNaN(value) ? NaN : value;
+        this.$explicitHeight = isNaN(value) ? NaN : value;
     }
     get measuredWidth() {
-        return this.getOriginalBounds().width;
+        return this.$getOriginalBounds().width;
     }
     get measuredHeight() {
-        return this.getOriginalBounds().height;
+        return this.$getOriginalBounds().height;
     }
     get anchorOffsetX() {
-        return this.internalAnchorOffsetX;
+        return this.$anchorOffsetX;
     }
     set anchorOffsetX(value) {
-        this.setAnchorOffsetX(value);
+        this.$setAnchorOffsetX(value);
     }
     get anchorOffsetY() {
-        return this.internalAnchorOffsetY;
+        return this.$anchorOffsetY;
     }
     set anchorOffsetY(value) {
-        this.setAnchorOffsetY(value);
+        this.$setAnchorOffsetY(value);
     }
     get visible() {
-        return this.internalVisible;
+        return this.$visible;
     }
     set visible(value) {
-        this.setVisible(value);
+        this.$setVisible(value);
     }
     get cacheAsBitmap() {
-        return this.internalCacheAsBitmap;
+        return this.$cacheAsBitmap;
     }
     set cacheAsBitmap(value) {
-        this.internalCacheAsBitmap = value;
-        this.setHasDisplayList(value);
+        this.$cacheAsBitmap = value;
+        this.$setHasDisplayList(value);
     }
     get filters() {
-        return this.internalFilters;
+        return this.$filters;
     }
     set filters(value) {
-        this.internalFilters = value ? [...value] : [];
-        this.updateRenderMode();
-        this.markDirty();
+        this.$filters = value ? [...value] : [];
+        this.$updateRenderMode();
+        this.$markDirty();
     }
     get alpha() {
-        return this.internalAlpha;
+        return this.$alpha;
     }
     set alpha(value) {
-        this.setAlpha(value);
+        this.$setAlpha(value);
     }
     get touchEnabled() {
-        return this.internalTouchEnabled;
+        return this.$touchEnabled;
     }
     set touchEnabled(value) {
-        this.internalTouchEnabled = !!value;
+        this.$touchEnabled = !!value;
     }
     get scrollRect() {
-        return this.internalScrollRect;
+        return this.$scrollRect;
     }
     set scrollRect(value) {
-        this.setScrollRect(value);
+        this.$setScrollRect(value);
     }
     get blendMode() {
-        return numberToBlendMode(this.internalBlendMode);
+        return numberToBlendMode(this.$blendMode);
     }
     set blendMode(value) {
         const mode = blendModeToNumber(value);
-        if (this.internalBlendMode === mode) {
+        if (this.$blendMode === mode) {
             return;
         }
-        this.internalBlendMode = mode;
-        this.updateRenderMode();
-        this.markDirty();
+        this.$blendMode = mode;
+        this.$updateRenderMode();
+        this.$markDirty();
     }
     get mask() {
-        return this.internalMask ?? this.internalMaskRect;
+        return this.$mask ?? this.$maskRect;
     }
     set mask(value) {
-        this.setMask(value);
+        this.$setMask(value);
     }
     get tint() {
         return this._tint;
     }
     set tint(value) {
         this._tint = typeof value === 'number' && value >= 0 && value <= 0xffffff ? value : 0xffffff;
-        this.tintRGB = (this._tint >> 16) + (this._tint & 0xff00) + ((this._tint & 0xff) << 16);
-        this.markDirty();
+        this.$tintRGB = (this._tint >> 16) + (this._tint & 0xff00) + ((this._tint & 0xff) << 16);
+        this.$markDirty();
     }
     get zIndex() {
         return this._zIndex;
@@ -309,7 +309,7 @@ export class DisplayObject extends EventDispatcher {
     set zIndex(value) {
         this._zIndex = value;
         if (this.parent) {
-            this.parent.sortDirty = true;
+            this.parent.$sortDirty = true;
         }
     }
     get sortableChildren() {
@@ -320,58 +320,58 @@ export class DisplayObject extends EventDispatcher {
     }
     // ── Public methods ────────────────────────────────────────────────────────
     getBounds(resultRect, calculateAnchor = true) {
-        resultRect = this.getTransformedBoundsInternal(this, resultRect);
+        resultRect = this.$getTransformedBoundsInternal(this, resultRect);
         if (calculateAnchor) {
-            if (this.internalAnchorOffsetX !== 0) {
-                resultRect.x -= this.internalAnchorOffsetX;
+            if (this.$anchorOffsetX !== 0) {
+                resultRect.x -= this.$anchorOffsetX;
             }
-            if (this.internalAnchorOffsetY !== 0) {
-                resultRect.y -= this.internalAnchorOffsetY;
+            if (this.$anchorOffsetY !== 0) {
+                resultRect.y -= this.$anchorOffsetY;
             }
         }
         return resultRect;
     }
     getTransformedBounds(targetCoordinateSpace, resultRect) {
-        return this.getTransformedBoundsInternal(targetCoordinateSpace ?? this, resultRect);
+        return this.$getTransformedBoundsInternal(targetCoordinateSpace ?? this, resultRect);
     }
     globalToLocal(stageX = 0, stageY = 0, resultPoint) {
-        return this.getInvertedConcatenatedMatrix().transformPoint(stageX, stageY, resultPoint);
+        return this.$getInvertedConcatenatedMatrix().transformPoint(stageX, stageY, resultPoint);
     }
     localToGlobal(localX = 0, localY = 0, resultPoint) {
-        return this.getConcatenatedMatrix().transformPoint(localX, localY, resultPoint);
+        return this.$getConcatenatedMatrix().transformPoint(localX, localY, resultPoint);
     }
     hitTestPoint(x, y, shapeFlag) {
         if (this._scaleX === 0 || this._scaleY === 0) {
             return false;
         }
-        const m = this.getInvertedConcatenatedMatrix();
+        const m = this.$getInvertedConcatenatedMatrix();
         const bounds = this.getBounds(undefined, false);
         const localX = m.a * x + m.c * y + m.tx;
         const localY = m.b * x + m.d * y + m.ty;
         if (!bounds.contains(localX, localY)) {
             return false;
         }
-        const rect = this.internalScrollRect ?? this.internalMaskRect;
+        const rect = this.$scrollRect ?? this.$maskRect;
         if (rect && !rect.contains(localX, localY)) {
             return false;
         }
         if (!shapeFlag) {
             return true;
         }
-        // Pixel-perfect: delegate to hitTest which Shape/Sprite override
-        return this.hitTest(x, y) !== undefined;
+        // Pixel-perfect: delegate to $hitTest which Shape/Sprite override
+        return this.$hitTest(x, y) !== undefined;
     }
     sortChildren() {
-        this.sortDirty = false;
+        this.$sortDirty = false;
     }
     dispatchEvent(event) {
         if (!event.bubbles) {
             return super.dispatchEvent(event);
         }
-        const list = this.getPropagationList(this);
+        const list = this.$getPropagationList(this);
         const targetIndex = list.length * 0.5;
         event.setDispatchContext(this, 2 /* EventPhase.AT_TARGET */);
-        this.dispatchPropagationEvent(event, list, targetIndex);
+        this.$dispatchPropagationEvent(event, list, targetIndex);
         return !event.isDefaultPrevented();
     }
     willTrigger(type) {
@@ -380,14 +380,14 @@ export class DisplayObject extends EventDispatcher {
             if (node.hasEventListener(type)) {
                 return true;
             }
-            node = node.internalParent;
+            node = node.$parent;
         }
         return false;
     }
     addEventListener(type, listener, useCapture, priority) {
         super.addEventListener(type, listener, useCapture, priority);
         if (type === Event.ENTER_FRAME || type === Event.RENDER) {
-            const list = type === Event.ENTER_FRAME ? DisplayObject.enterFrameCallBackList : DisplayObject.renderCallBackList;
+            const list = type === Event.ENTER_FRAME ? DisplayObject.$enterFrameCallBackList : DisplayObject.$renderCallBackList;
             if (!list.includes(this)) {
                 list.push(this);
             }
@@ -396,7 +396,7 @@ export class DisplayObject extends EventDispatcher {
     removeEventListener(type, listener, useCapture) {
         super.removeEventListener(type, listener, useCapture);
         if ((type === Event.ENTER_FRAME || type === Event.RENDER) && !this.hasEventListener(type)) {
-            const list = type === Event.ENTER_FRAME ? DisplayObject.enterFrameCallBackList : DisplayObject.renderCallBackList;
+            const list = type === Event.ENTER_FRAME ? DisplayObject.$enterFrameCallBackList : DisplayObject.$renderCallBackList;
             const index = list.indexOf(this);
             if (index !== -1) {
                 list.splice(index, 1);
@@ -404,39 +404,39 @@ export class DisplayObject extends EventDispatcher {
         }
     }
     // ── Internal methods (used by subclasses and framework) ───────────────────
-    setParent(parent) {
-        this.internalParent = parent;
+    $setParent(parent) {
+        this.$parent = parent;
     }
-    onAddToStage(stage, nestLevel) {
-        this.internalStage = stage;
-        this.nestLevel = nestLevel;
-        this.hasAddToStage = true;
-        DisplayObject.eventAddToStageList.push(this);
+    $onAddToStage(stage, $nestLevel) {
+        this.$stage = stage;
+        this.$nestLevel = $nestLevel;
+        this.$hasAddToStage = true;
+        DisplayObject.$eventAddToStageList.push(this);
     }
-    onRemoveFromStage() {
-        this.nestLevel = 0;
-        this.internalStage = undefined;
-        DisplayObject.eventRemoveFromStageList.push(this);
+    $onRemoveFromStage() {
+        this.$nestLevel = 0;
+        this.$stage = undefined;
+        DisplayObject.$eventRemoveFromStageList.push(this);
     }
-    getMatrix() {
+    $getMatrix() {
         if (this._matrixDirty) {
             this._matrixDirty = false;
             this._matrix.updateScaleAndRotation(this._scaleX, this._scaleY, this._skewX, this._skewY);
         }
-        this._matrix.tx = this.internalX;
-        this._matrix.ty = this.internalY;
+        this._matrix.tx = this.$x;
+        this._matrix.ty = this.$y;
         return this._matrix;
     }
-    setMatrix(matrix, needUpdateProperties = true) {
+    $setMatrix(matrix, needUpdateProperties = true) {
         const m = this._matrix;
         m.a = matrix.a;
         m.b = matrix.b;
         m.c = matrix.c;
         m.d = matrix.d;
-        this.internalX = matrix.tx;
-        this.internalY = matrix.ty;
+        this.$x = matrix.tx;
+        this.$y = matrix.ty;
         this._matrixDirty = false;
-        this.useTranslate = !(m.a === 1 && m.b === 0 && m.c === 0 && m.d === 1);
+        this.$useTranslate = !(m.a === 1 && m.b === 0 && m.c === 0 && m.d === 1);
         if (needUpdateProperties) {
             this._scaleX = m.getScaleX();
             this._scaleY = m.getScaleY();
@@ -446,22 +446,22 @@ export class DisplayObject extends EventDispatcher {
             this._skewYdeg = clampRotation((this._skewY * 180) / Math.PI);
             this._rotation = clampRotation((this._skewY * 180) / Math.PI);
         }
-        this.markDirty();
+        this.$markDirty();
     }
-    getConcatenatedMatrix() {
+    $getConcatenatedMatrix() {
         if (!this._concatenatedMatrix) {
             this._concatenatedMatrix = new Matrix();
         }
         const matrix = this._concatenatedMatrix;
-        if (this.internalParent) {
-            this.internalParent.getConcatenatedMatrix().preMultiplyInto(this.getMatrix(), matrix);
+        if (this.$parent) {
+            this.$parent.$getConcatenatedMatrix().preMultiplyInto(this.$getMatrix(), matrix);
         }
         else {
-            matrix.copyFrom(this.getMatrix());
+            matrix.copyFrom(this.$getMatrix());
         }
-        const ox = this.internalAnchorOffsetX;
-        const oy = this.internalAnchorOffsetY;
-        const rect = this.internalScrollRect;
+        const ox = this.$anchorOffsetX;
+        const oy = this.$anchorOffsetY;
+        const rect = this.$scrollRect;
         if (rect) {
             matrix.preMultiplyInto(sharedMatrix.setTo(1, 0, 0, 1, -rect.x - ox, -rect.y - oy), matrix);
         }
@@ -470,48 +470,48 @@ export class DisplayObject extends EventDispatcher {
         }
         return matrix;
     }
-    getInvertedConcatenatedMatrix() {
+    $getInvertedConcatenatedMatrix() {
         if (!this._invertedConcatenatedMatrix) {
             this._invertedConcatenatedMatrix = new Matrix();
         }
-        this.getConcatenatedMatrix().invertInto(this._invertedConcatenatedMatrix);
+        this.$getConcatenatedMatrix().invertInto(this._invertedConcatenatedMatrix);
         return this._invertedConcatenatedMatrix;
     }
-    setX(value) {
-        if (this.internalX === value) {
+    $setX(value) {
+        if (this.$x === value) {
             return false;
         }
-        this.internalX = value;
-        this.markDirty();
+        this.$x = value;
+        this.$markDirty();
         return true;
     }
-    setY(value) {
-        if (this.internalY === value) {
+    $setY(value) {
+        if (this.$y === value) {
             return false;
         }
-        this.internalY = value;
-        this.markDirty();
+        this.$y = value;
+        this.$markDirty();
         return true;
     }
-    setScaleX(value) {
+    $setScaleX(value) {
         if (this._scaleX === value) {
             return;
         }
         this._scaleX = value;
         this._matrixDirty = true;
-        this.updateUseTransform();
-        this.markDirty();
+        this.$updateUseTransform();
+        this.$markDirty();
     }
-    setScaleY(value) {
+    $setScaleY(value) {
         if (this._scaleY === value) {
             return;
         }
         this._scaleY = value;
         this._matrixDirty = true;
-        this.updateUseTransform();
-        this.markDirty();
+        this.$updateUseTransform();
+        this.$markDirty();
     }
-    setRotation(value) {
+    $setRotation(value) {
         value = clampRotation(value);
         if (value === this._rotation) {
             return;
@@ -521,156 +521,156 @@ export class DisplayObject extends EventDispatcher {
         this._skewY += delta;
         this._rotation = value;
         this._matrixDirty = true;
-        this.updateUseTransform();
-        this.markDirty();
+        this.$updateUseTransform();
+        this.$markDirty();
     }
-    setSkewX(value) {
+    $setSkewX(value) {
         if (value === this._skewXdeg) {
             return;
         }
         this._skewXdeg = value;
         this._skewX = (clampRotation(value) / 180) * Math.PI;
         this._matrixDirty = true;
-        this.updateUseTransform();
-        this.markDirty();
+        this.$updateUseTransform();
+        this.$markDirty();
     }
-    setSkewY(value) {
+    $setSkewY(value) {
         if (value === this._skewYdeg) {
             return;
         }
         this._skewYdeg = value;
         this._skewY = ((clampRotation(value) + this._rotation) / 180) * Math.PI;
         this._matrixDirty = true;
-        this.updateUseTransform();
-        this.markDirty();
+        this.$updateUseTransform();
+        this.$markDirty();
     }
-    setAnchorOffsetX(value) {
-        if (this.internalAnchorOffsetX === value) {
+    $setAnchorOffsetX(value) {
+        if (this.$anchorOffsetX === value) {
             return;
         }
-        this.internalAnchorOffsetX = value;
-        this.markDirty();
+        this.$anchorOffsetX = value;
+        this.$markDirty();
     }
-    setAnchorOffsetY(value) {
-        if (this.internalAnchorOffsetY === value) {
+    $setAnchorOffsetY(value) {
+        if (this.$anchorOffsetY === value) {
             return;
         }
-        this.internalAnchorOffsetY = value;
-        this.markDirty();
+        this.$anchorOffsetY = value;
+        this.$markDirty();
     }
-    setVisible(value) {
-        if (this.internalVisible === value) {
+    $setVisible(value) {
+        if (this.$visible === value) {
             return;
         }
-        this.internalVisible = value;
-        this.updateRenderMode();
-        this.markDirty();
+        this.$visible = value;
+        this.$updateRenderMode();
+        this.$markDirty();
     }
-    setAlpha(value) {
-        if (this.internalAlpha === value) {
+    $setAlpha(value) {
+        if (this.$alpha === value) {
             return;
         }
-        this.internalAlpha = value;
-        this.updateRenderMode();
-        this.markDirty();
+        this.$alpha = value;
+        this.$updateRenderMode();
+        this.$markDirty();
     }
-    setScrollRect(value) {
-        if (!value && !this.internalScrollRect) {
+    $setScrollRect(value) {
+        if (!value && !this.$scrollRect) {
             return;
         }
         if (value) {
-            if (!this.internalScrollRect) {
-                this.internalScrollRect = new Rectangle();
+            if (!this.$scrollRect) {
+                this.$scrollRect = new Rectangle();
             }
-            this.internalScrollRect.copyFrom(value);
+            this.$scrollRect.copyFrom(value);
         }
         else {
-            this.internalScrollRect = undefined;
+            this.$scrollRect = undefined;
         }
-        this.updateRenderMode();
-        this.markDirty();
+        this.$updateRenderMode();
+        this.$markDirty();
     }
-    setHasDisplayList(value) {
-        const hasDisplayList = !!this.displayList;
+    $setHasDisplayList(value) {
+        const hasDisplayList = !!this.$displayList;
         if (hasDisplayList === value) {
             return;
         }
         if (value) {
             const dl = DisplayList.create(this);
             if (dl) {
-                this.displayList = dl;
-                this.cacheDirty = true;
+                this.$displayList = dl;
+                this.$cacheDirty = true;
             }
         }
         else {
-            if (this.displayList) {
-                DisplayList.release(this.displayList);
-                this.displayList = undefined;
+            if (this.$displayList) {
+                DisplayList.release(this.$displayList);
+                this.$displayList = undefined;
             }
         }
         // cacheAsBitmap toggle changes the instruction set structure:
         // the subtree either collapses to a single displayListCache instruction
         // or expands back to individual leaf instructions.
-        DisplayObject._onStructureChange?.();
-        this.markDirty();
+        DisplayObject.$onStructureChange?.();
+        this.$markDirty();
     }
-    cacheDirtyUp() {
-        const p = this.internalParent;
-        if (p && !p.cacheDirty) {
-            p.cacheDirty = true;
+    $cacheDirtyUp() {
+        const p = this.$parent;
+        if (p && !p.$cacheDirty) {
+            p.$cacheDirty = true;
             p._boundsDirty = true;
-            p.cacheDirtyUp();
+            p.$cacheDirtyUp();
         }
     }
-    renderDirtyUp() {
-        const p = this.internalParent;
-        if (p && !p.renderDirty) {
-            p.renderDirty = true;
-            p.renderDirtyUp();
+    $renderDirtyUp() {
+        const p = this.$parent;
+        if (p && !p.$renderDirty) {
+            p.$renderDirty = true;
+            p.$renderDirtyUp();
         }
     }
-    updateUseTransform() {
-        this.useTranslate = !(this._scaleX === 1 && this._scaleY === 1 && this._skewX === 0 && this._skewY === 0);
+    $updateUseTransform() {
+        this.$useTranslate = !(this._scaleX === 1 && this._scaleY === 1 && this._skewX === 0 && this._skewY === 0);
     }
-    updateRenderMode() {
-        if (!this.internalVisible || this.internalAlpha <= 0 || this.maskedObject) {
-            this.renderMode = 1 /* RenderMode.NONE */;
+    $updateRenderMode() {
+        if (!this.$visible || this.$alpha <= 0 || this.$maskedObject) {
+            this.$renderMode = 1 /* RenderMode.NONE */;
         }
-        else if (this.internalFilters.length > 0) {
-            this.renderMode = 2 /* RenderMode.FILTER */;
+        else if (this.$filters.length > 0) {
+            this.$renderMode = 2 /* RenderMode.FILTER */;
         }
-        else if (this.internalBlendMode !== 0 || (this.internalMask && this.internalMask.internalStage)) {
-            this.renderMode = 3 /* RenderMode.CLIP */;
+        else if (this.$blendMode !== 0 || (this.$mask && this.$mask.$stage)) {
+            this.$renderMode = 3 /* RenderMode.CLIP */;
         }
-        else if (this.internalScrollRect || this.internalMaskRect) {
-            this.renderMode = 4 /* RenderMode.SCROLLRECT */;
+        else if (this.$scrollRect || this.$maskRect) {
+            this.$renderMode = 4 /* RenderMode.SCROLLRECT */;
         }
         else {
-            this.renderMode = undefined;
+            this.$renderMode = undefined;
         }
         // RenderMode change means the instruction set structure is stale.
-        DisplayObject._onStructureChange?.();
+        DisplayObject.$onStructureChange?.();
     }
-    getOriginalBounds() {
+    $getOriginalBounds() {
         if (!this._boundsDirty) {
             return this._cachedBounds;
         }
-        const bounds = this.getContentBounds();
-        this.measureChildBounds(bounds);
+        const bounds = this.$getContentBounds();
+        this.$measureChildBounds(bounds);
         this._cachedBounds.copyFrom(bounds);
         this._boundsDirty = false;
         return this._cachedBounds;
     }
-    measureChildBounds(_bounds) { }
-    getContentBounds() {
+    $measureChildBounds(_bounds) { }
+    $getContentBounds() {
         const bounds = sharedRectangle;
         bounds.setEmpty();
-        this.measureContentBounds(bounds);
+        this.$measureContentBounds(bounds);
         return bounds;
     }
-    measureContentBounds(_bounds) { }
-    getTransformedBoundsInternal(targetCoordinateSpace, resultRect) {
-        const bounds = this.getOriginalBounds();
+    $measureContentBounds(_bounds) { }
+    $getTransformedBoundsInternal(targetCoordinateSpace, resultRect) {
+        const bounds = this.$getOriginalBounds();
         if (!resultRect) {
             resultRect = new Rectangle();
         }
@@ -679,46 +679,46 @@ export class DisplayObject extends EventDispatcher {
             return resultRect;
         }
         const m = sharedMatrix;
-        targetCoordinateSpace.getInvertedConcatenatedMatrix().preMultiplyInto(this.getConcatenatedMatrix(), m);
+        targetCoordinateSpace.$getInvertedConcatenatedMatrix().preMultiplyInto(this.$getConcatenatedMatrix(), m);
         m.transformBounds(resultRect);
         return resultRect;
     }
-    getConcatenatedMatrixAt(root, matrix) {
-        const invertMatrix = root.getInvertedConcatenatedMatrix();
+    $getConcatenatedMatrixAt(root, matrix) {
+        const invertMatrix = root.$getInvertedConcatenatedMatrix();
         if ((invertMatrix.a === 0 || invertMatrix.d === 0) && (invertMatrix.b === 0 || invertMatrix.c === 0)) {
             let target = this;
-            const rootLevel = root.nestLevel;
+            const rootLevel = root.$nestLevel;
             matrix.identity();
-            while (target.nestLevel > rootLevel) {
-                const rect = target.internalScrollRect;
+            while (target.$nestLevel > rootLevel) {
+                const rect = target.$scrollRect;
                 if (rect)
                     matrix.concat(sharedMatrix.setTo(1, 0, 0, 1, -rect.x, -rect.y));
-                matrix.concat(target.getMatrix());
-                target = target.internalParent;
+                matrix.concat(target.$getMatrix());
+                target = target.$parent;
             }
         }
         else {
             invertMatrix.preMultiplyInto(matrix, matrix);
         }
     }
-    hitTest(stageX, stageY) {
-        if (!this.internalVisible || this._scaleX === 0 || this._scaleY === 0) {
+    $hitTest(stageX, stageY) {
+        if (!this.$visible || this._scaleX === 0 || this._scaleY === 0) {
             return undefined;
         }
-        const m = this.getInvertedConcatenatedMatrix();
+        const m = this.$getInvertedConcatenatedMatrix();
         if (m.a === 0 && m.b === 0 && m.c === 0 && m.d === 0) {
             return undefined;
         }
-        const bounds = this.getContentBounds();
+        const bounds = this.$getContentBounds();
         const localX = m.a * stageX + m.c * stageY + m.tx;
         const localY = m.b * stageX + m.d * stageY + m.ty;
         if (bounds.contains(localX, localY)) {
-            if (!this.children) {
-                const rect = this.internalScrollRect ?? this.internalMaskRect;
+            if (!this.$children) {
+                const rect = this.$scrollRect ?? this.$maskRect;
                 if (rect && !rect.contains(localX, localY)) {
                     return undefined;
                 }
-                if (this.internalMask && !this.internalMask.hitTest(stageX, stageY)) {
+                if (this.$mask && !this.$mask.$hitTest(stageX, stageY)) {
                     return undefined;
                 }
             }
@@ -726,17 +726,17 @@ export class DisplayObject extends EventDispatcher {
         }
         return undefined;
     }
-    updateRenderNode() { }
-    getPropagationList(target) {
+    $updateRenderNode() { }
+    $getPropagationList(target) {
         const list = [];
         let current = target;
         while (current) {
             list.push(current);
-            current = current.internalParent;
+            current = current.$parent;
         }
         return [...[...list].reverse(), ...list];
     }
-    dispatchPropagationEvent(event, list, targetIndex) {
+    $dispatchPropagationEvent(event, list, targetIndex) {
         for (let i = 0; i < list.length; i++) {
             const currentTarget = list[i];
             let phase;
@@ -758,73 +758,73 @@ export class DisplayObject extends EventDispatcher {
         }
     }
     // ── Private methods ───────────────────────────────────────────────────────
-    setMask(value) {
+    $setMask(value) {
         if (value === this) {
             return;
         }
         if (value instanceof DisplayObject) {
-            if (value === this.internalMask) {
+            if (value === this.$mask) {
                 return;
             }
-            if (value.maskedObject) {
-                value.maskedObject.mask = undefined;
+            if (value.$maskedObject) {
+                value.$maskedObject.mask = undefined;
             }
-            value.maskedObject = this;
-            this.internalMask = value;
-            this.internalMaskRect = undefined;
+            value.$maskedObject = this;
+            this.$mask = value;
+            this.$maskRect = undefined;
         }
         else if (value instanceof Rectangle) {
-            if (!this.internalMaskRect) {
-                this.internalMaskRect = new Rectangle();
+            if (!this.$maskRect) {
+                this.$maskRect = new Rectangle();
             }
-            this.internalMaskRect.copyFrom(value);
-            if (this.internalMask) {
-                this.internalMask.maskedObject = undefined;
-                this.internalMask = undefined;
+            this.$maskRect.copyFrom(value);
+            if (this.$mask) {
+                this.$mask.$maskedObject = undefined;
+                this.$mask = undefined;
             }
         }
         else {
-            if (this.internalMask) {
-                this.internalMask.maskedObject = undefined;
-                this.internalMask = undefined;
+            if (this.$mask) {
+                this.$mask.$maskedObject = undefined;
+                this.$mask = undefined;
             }
-            this.internalMaskRect = undefined;
+            this.$maskRect = undefined;
         }
-        this.updateRenderMode();
-        this.markDirty();
+        this.$updateRenderMode();
+        this.$markDirty();
     }
-    markDirty() {
-        this.renderDirty = true;
+    $markDirty() {
+        this.$renderDirty = true;
         this._boundsDirty = true;
         // Update cached world alpha and tint so _refreshLeafTransform can read
         // them in O(1) without walking the parent chain.
-        let alpha = this.internalAlpha;
-        let tint = this.tintRGB;
-        let p = this.internalParent;
+        let alpha = this.$alpha;
+        let tint = this.$tintRGB;
+        let p = this.$parent;
         while (p) {
-            alpha *= p.internalAlpha;
-            if (p.tintRGB !== 0xffffff) {
-                tint = p.tintRGB;
+            alpha *= p.$alpha;
+            if (p.$tintRGB !== 0xffffff) {
+                tint = p.$tintRGB;
             }
-            p = p.internalParent;
+            p = p.$parent;
         }
-        this.worldAlpha = alpha;
-        this.worldTint = tint;
+        this.$worldAlpha = alpha;
+        this.$worldTint = tint;
         // Notify the renderer that this object's data changed.
-        DisplayObject._onRenderableDirty?.(this);
-        const parent = this.internalParent;
-        if (parent && !parent.cacheDirty) {
-            parent.cacheDirty = true;
-            parent.cacheDirtyUp();
-        }
-        if (parent && !parent.renderDirty) {
-            parent.renderDirty = true;
-            parent.renderDirtyUp();
-        }
-        const masked = this.maskedObject;
-        if (masked && !masked.cacheDirty) {
-            masked.cacheDirty = true;
-            masked.cacheDirtyUp();
+        DisplayObject.$onRenderableDirty?.(this);
+        const parent = this.$parent;
+        if (parent && !parent.$cacheDirty) {
+            parent.$cacheDirty = true;
+            parent.$cacheDirtyUp();
+        }
+        if (parent && !parent.$renderDirty) {
+            parent.$renderDirty = true;
+            parent.$renderDirtyUp();
+        }
+        const masked = this.$maskedObject;
+        if (masked && !masked.$cacheDirty) {
+            masked.$cacheDirty = true;
+            masked.$cacheDirtyUp();
         }
     }
 }