@egret/runtime 0.0.0-stage → 7.0.1-rc.3
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/LICENSE +201 -0
- package/NOTICE +21 -0
- package/README.md +70 -2
- package/README.zh-CN.md +71 -0
- package/dist/AssetLease.d.ts +23 -0
- package/dist/AssetLease.js +69 -0
- package/dist/AssetManager.d.ts +56 -0
- package/dist/AssetManager.js +451 -0
- package/dist/AssetRef.d.ts +20 -0
- package/dist/AssetRef.js +32 -0
- package/dist/Bitmap.d.ts +40 -0
- package/dist/Bitmap.js +545 -0
- package/dist/ByteReader.d.ts +30 -0
- package/dist/ByteReader.js +177 -0
- package/dist/ByteWriter.d.ts +29 -0
- package/dist/ByteWriter.js +180 -0
- package/dist/CancellationController.d.ts +10 -0
- package/dist/CancellationController.js +66 -0
- package/dist/DisplayObject.d.ts +89 -0
- package/dist/DisplayObject.js +340 -0
- package/dist/DisplayObjectContainer.d.ts +28 -0
- package/dist/DisplayObjectContainer.js +226 -0
- package/dist/EgretError.d.ts +11 -0
- package/dist/EgretError.js +36 -0
- package/dist/Event.d.ts +45 -0
- package/dist/Event.js +84 -0
- package/dist/EventDispatcher.d.ts +24 -0
- package/dist/EventDispatcher.js +178 -0
- package/dist/Graphics.d.ts +106 -0
- package/dist/Graphics.js +504 -0
- package/dist/Mesh2D.d.ts +27 -0
- package/dist/Mesh2D.js +200 -0
- package/dist/NineSliceBitmap.d.ts +24 -0
- package/dist/NineSliceBitmap.js +164 -0
- package/dist/NineSliceGeometry2D.d.ts +18 -0
- package/dist/NineSliceGeometry2D.js +126 -0
- package/dist/Scope.d.ts +18 -0
- package/dist/Scope.js +133 -0
- package/dist/SequencePlayer.d.ts +12 -0
- package/dist/SequencePlayer.js +69 -0
- package/dist/Sprite.d.ts +8 -0
- package/dist/Sprite.js +12 -0
- package/dist/Stage.d.ts +14 -0
- package/dist/Stage.js +31 -0
- package/dist/Texture.d.ts +29 -0
- package/dist/Texture.js +177 -0
- package/dist/assetManagerOwnerState.d.ts +36 -0
- package/dist/assetManagerOwnerState.js +115 -0
- package/dist/assetState.d.ts +44 -0
- package/dist/assetState.js +2 -0
- package/dist/atlasFrameLayout.d.ts +21 -0
- package/dist/atlasFrameLayout.js +48 -0
- package/dist/bitmapDisplayState.d.ts +24 -0
- package/dist/bitmapDisplayState.js +22 -0
- package/dist/coordinateInverse.d.ts +4 -0
- package/dist/coordinateInverse.js +107 -0
- package/dist/diagnostics.d.ts +4 -0
- package/dist/diagnostics.js +13 -0
- package/dist/displayBounds.d.ts +9 -0
- package/dist/displayBounds.js +181 -0
- package/dist/displayCoordinates.d.ts +8 -0
- package/dist/displayCoordinates.js +81 -0
- package/dist/displayHitState.d.ts +18 -0
- package/dist/displayHitState.js +97 -0
- package/dist/displayHitTest.d.ts +8 -0
- package/dist/displayHitTest.js +219 -0
- package/dist/displayInputOperations.d.ts +12 -0
- package/dist/displayInputOperations.js +71 -0
- package/dist/displayTransform.d.ts +5 -0
- package/dist/displayTransform.js +38 -0
- package/dist/displayTreeState.d.ts +90 -0
- package/dist/displayTreeState.js +450 -0
- package/dist/displayVisualState.d.ts +74 -0
- package/dist/displayVisualState.js +140 -0
- package/dist/errorHelp.d.ts +14 -0
- package/dist/errorHelp.js +432 -0
- package/dist/errorHelpZh.d.ts +5 -0
- package/dist/errorHelpZh.js +340 -0
- package/dist/graphicsFill.d.ts +37 -0
- package/dist/graphicsFill.js +302 -0
- package/dist/graphicsShape.d.ts +144 -0
- package/dist/graphicsShape.js +755 -0
- package/dist/index.d.ts +50 -0
- package/dist/index.js +28 -0
- package/dist/input/PointerRouter.d.ts +4 -0
- package/dist/input/PointerRouter.js +453 -0
- package/dist/input/index.d.ts +3 -0
- package/dist/input/index.js +3 -0
- package/dist/input/types.d.ts +58 -0
- package/dist/input/types.js +3 -0
- package/dist/meshCaptureSnapshot.d.ts +5 -0
- package/dist/meshCaptureSnapshot.js +13 -0
- package/dist/meshDisplayState.d.ts +18 -0
- package/dist/meshDisplayState.js +21 -0
- package/dist/ownership.d.ts +75 -0
- package/dist/ownership.js +157 -0
- package/dist/paragraph/Paragraph.d.ts +13 -0
- package/dist/paragraph/Paragraph.js +193 -0
- package/dist/paragraph/ParagraphCache.d.ts +5 -0
- package/dist/paragraph/ParagraphCache.js +354 -0
- package/dist/paragraph/geometry.d.ts +4 -0
- package/dist/paragraph/geometry.js +180 -0
- package/dist/paragraph/index.d.ts +3 -0
- package/dist/paragraph/index.js +3 -0
- package/dist/paragraph/request.d.ts +6 -0
- package/dist/paragraph/request.js +191 -0
- package/dist/paragraph/types.d.ts +183 -0
- package/dist/paragraph/types.js +2 -0
- package/dist/preparedDisplaySubtree.d.ts +7 -0
- package/dist/preparedDisplaySubtree.js +205 -0
- package/dist/renderEffect.d.ts +47 -0
- package/dist/renderEffect.js +87 -0
- package/dist/sequenceClip.d.ts +42 -0
- package/dist/sequenceClip.js +196 -0
- package/dist/sharedFrameCapture.d.ts +24 -0
- package/dist/sharedFrameCapture.js +1069 -0
- package/dist/spriteSheet.d.ts +34 -0
- package/dist/spriteSheet.js +321 -0
- package/dist/srgbBytes.d.ts +3 -0
- package/dist/srgbBytes.js +64 -0
- package/dist/text/TextField.d.ts +13 -0
- package/dist/text/TextField.js +261 -0
- package/dist/text/TextRasterCache.d.ts +5 -0
- package/dist/text/TextRasterCache.js +1191 -0
- package/dist/text/budget.d.ts +51 -0
- package/dist/text/budget.js +116 -0
- package/dist/text/index.d.ts +4 -0
- package/dist/text/index.js +3 -0
- package/dist/text/plan.d.ts +16 -0
- package/dist/text/plan.js +238 -0
- package/dist/text/request.d.ts +44 -0
- package/dist/text/request.js +303 -0
- package/dist/text/types.d.ts +179 -0
- package/dist/text/types.js +2 -0
- package/dist/textDisplayState.d.ts +21 -0
- package/dist/textDisplayState.js +27 -0
- package/dist/ui/displayCommit.d.ts +43 -0
- package/dist/ui/displayCommit.js +376 -0
- package/dist/ui/editing.d.ts +3 -0
- package/dist/ui/editing.js +3 -0
- package/dist/ui/heightIndex.d.ts +35 -0
- package/dist/ui/heightIndex.js +295 -0
- package/dist/ui/index.d.ts +6 -0
- package/dist/ui/index.js +6 -0
- package/dist/ui/layout.d.ts +9 -0
- package/dist/ui/layout.js +349 -0
- package/dist/ui/managedState.d.ts +12 -0
- package/dist/ui/managedState.js +44 -0
- package/dist/ui/textEditState.d.ts +4 -0
- package/dist/ui/textEditState.js +206 -0
- package/dist/ui/textEditTypes.d.ts +48 -0
- package/dist/ui/textEditTypes.js +2 -0
- package/dist/ui/types.d.ts +99 -0
- package/dist/ui/types.js +2 -0
- package/package.json +44 -4
|
@@ -0,0 +1,340 @@
|
|
|
1
|
+
import { setRenderEffect } from './renderEffect.js';
|
|
2
|
+
import { assertManagedMutable } from './ui/managedState.js';
|
|
3
|
+
import { createSharedMaterial2D, isSharedMaterial2D } from '@egret/contracts';
|
|
4
|
+
import { registerDisplayHitNode, readDisplayHitState, writeDisplayHitArea, writeDisplayTouchEnabled } from './displayHitState.js';
|
|
5
|
+
import { queryDisplayBounds } from './displayBounds.js';
|
|
6
|
+
import { queryDisplayPoint } from './displayCoordinates.js';
|
|
7
|
+
import { EgretError } from './EgretError.js';
|
|
8
|
+
import { assertVisualMutable, copyRect, alphaOf, finite, invalidDisplayValue, registerVisual, visualOf, readAnchorOffset, writeAnchorOffset, recordVisualChange, VISUAL_TRANSFORM, VISUAL_APPEARANCE } from './displayVisualState.js';
|
|
9
|
+
import { EventDispatcher } from './EventDispatcher.js';
|
|
10
|
+
import { ASSERT_ATTACHABLE, ASSERT_BINDABLE, OWNERSHIP_CHILDREN } from './ownership.js';
|
|
11
|
+
import { assertLive, isTerminated, parentOf, registerNode, terminateNode } from './displayTreeState.js';
|
|
12
|
+
/** Egret's names of blend modes, and the blends of the shared material they are. */
|
|
13
|
+
const BLENDS = Object.freeze({
|
|
14
|
+
normal: 'normal',
|
|
15
|
+
add: 'add-accumulate',
|
|
16
|
+
multiply: 'multiply-factor',
|
|
17
|
+
screen: 'screen',
|
|
18
|
+
erase: 'erase'
|
|
19
|
+
});
|
|
20
|
+
// Equality is checked only after the original validation; signed zero stays distinct.
|
|
21
|
+
const sameVisualValue = Object.is;
|
|
22
|
+
/** The scale that gives a size on the parent from a size in the object's own units, with the sign the scale had. */
|
|
23
|
+
function sizeScale(value, own, scale) {
|
|
24
|
+
if (!finite(value) || value < 0)
|
|
25
|
+
throw new EgretError('DISPLAY_VALUE_INVALID');
|
|
26
|
+
if (own === 0) {
|
|
27
|
+
if (value === 0)
|
|
28
|
+
return scale;
|
|
29
|
+
throw new EgretError('DISPLAY_SIZE_UNAVAILABLE');
|
|
30
|
+
}
|
|
31
|
+
return ((scale < 0 ? -1 : 1) * value) / own;
|
|
32
|
+
}
|
|
33
|
+
/** A live display node; detach and terminal dispose are separate operations. */
|
|
34
|
+
export class DisplayObject extends EventDispatcher {
|
|
35
|
+
constructor() {
|
|
36
|
+
super();
|
|
37
|
+
registerNode(this);
|
|
38
|
+
registerVisual(this);
|
|
39
|
+
registerDisplayHitNode(this);
|
|
40
|
+
}
|
|
41
|
+
/** Explicit input regions are separate from rendering content and opacity. */
|
|
42
|
+
get touchEnabled() {
|
|
43
|
+
return readDisplayHitState(this).touchEnabled;
|
|
44
|
+
}
|
|
45
|
+
set touchEnabled(value) {
|
|
46
|
+
writeDisplayTouchEnabled(this, value);
|
|
47
|
+
}
|
|
48
|
+
get hitArea() {
|
|
49
|
+
return readDisplayHitState(this).hitArea;
|
|
50
|
+
}
|
|
51
|
+
set hitArea(value) {
|
|
52
|
+
writeDisplayHitArea(this, value);
|
|
53
|
+
}
|
|
54
|
+
get x() {
|
|
55
|
+
return visualOf(this).x;
|
|
56
|
+
}
|
|
57
|
+
set x(value) {
|
|
58
|
+
assertVisualMutable(this);
|
|
59
|
+
if (!finite(value))
|
|
60
|
+
throw invalidDisplayValue('x', value);
|
|
61
|
+
const state = visualOf(this), changed = !sameVisualValue(state.x, value);
|
|
62
|
+
state.x = value;
|
|
63
|
+
if (changed)
|
|
64
|
+
recordVisualChange(this, VISUAL_TRANSFORM);
|
|
65
|
+
}
|
|
66
|
+
get y() {
|
|
67
|
+
return visualOf(this).y;
|
|
68
|
+
}
|
|
69
|
+
set y(value) {
|
|
70
|
+
assertVisualMutable(this);
|
|
71
|
+
if (!finite(value))
|
|
72
|
+
throw invalidDisplayValue('y', value);
|
|
73
|
+
const state = visualOf(this), changed = !sameVisualValue(state.y, value);
|
|
74
|
+
state.y = value;
|
|
75
|
+
if (changed)
|
|
76
|
+
recordVisualChange(this, VISUAL_TRANSFORM);
|
|
77
|
+
}
|
|
78
|
+
/** Local pivot in logical pixels; finite values are stored without coercion. */
|
|
79
|
+
get anchorOffsetX() {
|
|
80
|
+
return readAnchorOffset(this, 'anchorOffsetX');
|
|
81
|
+
}
|
|
82
|
+
set anchorOffsetX(value) {
|
|
83
|
+
writeAnchorOffset(this, 'anchorOffsetX', value);
|
|
84
|
+
}
|
|
85
|
+
/** The pivot remains readable after disposal; writes obey node/Engine life. */
|
|
86
|
+
get anchorOffsetY() {
|
|
87
|
+
return readAnchorOffset(this, 'anchorOffsetY');
|
|
88
|
+
}
|
|
89
|
+
set anchorOffsetY(value) {
|
|
90
|
+
writeAnchorOffset(this, 'anchorOffsetY', value);
|
|
91
|
+
}
|
|
92
|
+
get scaleX() {
|
|
93
|
+
return visualOf(this).scaleX;
|
|
94
|
+
}
|
|
95
|
+
set scaleX(value) {
|
|
96
|
+
assertVisualMutable(this);
|
|
97
|
+
if (!finite(value))
|
|
98
|
+
throw invalidDisplayValue('scaleX', value);
|
|
99
|
+
const state = visualOf(this), changed = !sameVisualValue(state.scaleX, value);
|
|
100
|
+
state.scaleX = value;
|
|
101
|
+
if (changed)
|
|
102
|
+
recordVisualChange(this, VISUAL_TRANSFORM);
|
|
103
|
+
}
|
|
104
|
+
get scaleY() {
|
|
105
|
+
return visualOf(this).scaleY;
|
|
106
|
+
}
|
|
107
|
+
set scaleY(value) {
|
|
108
|
+
assertVisualMutable(this);
|
|
109
|
+
if (!finite(value))
|
|
110
|
+
throw invalidDisplayValue('scaleY', value);
|
|
111
|
+
const state = visualOf(this), changed = !sameVisualValue(state.scaleY, value);
|
|
112
|
+
state.scaleY = value;
|
|
113
|
+
if (changed)
|
|
114
|
+
recordVisualChange(this, VISUAL_TRANSFORM);
|
|
115
|
+
}
|
|
116
|
+
get rotation() {
|
|
117
|
+
return visualOf(this).rotation;
|
|
118
|
+
}
|
|
119
|
+
set rotation(value) {
|
|
120
|
+
assertVisualMutable(this);
|
|
121
|
+
if (!finite(value))
|
|
122
|
+
throw invalidDisplayValue('rotation', value);
|
|
123
|
+
const state = visualOf(this), changed = !sameVisualValue(state.rotation, value);
|
|
124
|
+
state.rotation = value;
|
|
125
|
+
if (changed)
|
|
126
|
+
recordVisualChange(this, VISUAL_TRANSFORM);
|
|
127
|
+
}
|
|
128
|
+
/** Degrees by which the y axis is turned beyond the rotation, so that upright lines lean. 0 unless set. */
|
|
129
|
+
get skewX() {
|
|
130
|
+
return visualOf(this).skewX;
|
|
131
|
+
}
|
|
132
|
+
set skewX(value) {
|
|
133
|
+
assertVisualMutable(this);
|
|
134
|
+
if (!finite(value))
|
|
135
|
+
throw invalidDisplayValue('skewX', value);
|
|
136
|
+
const state = visualOf(this), changed = !sameVisualValue(state.skewX, value);
|
|
137
|
+
state.skewX = value;
|
|
138
|
+
if (changed)
|
|
139
|
+
recordVisualChange(this, VISUAL_TRANSFORM);
|
|
140
|
+
}
|
|
141
|
+
/** Degrees by which the x axis is turned beyond the rotation, so that level lines slope. 0 unless set. */
|
|
142
|
+
get skewY() {
|
|
143
|
+
return visualOf(this).skewY;
|
|
144
|
+
}
|
|
145
|
+
set skewY(value) {
|
|
146
|
+
assertVisualMutable(this);
|
|
147
|
+
if (!finite(value))
|
|
148
|
+
throw invalidDisplayValue('skewY', value);
|
|
149
|
+
const state = visualOf(this), changed = !sameVisualValue(state.skewY, value);
|
|
150
|
+
state.skewY = value;
|
|
151
|
+
if (changed)
|
|
152
|
+
recordVisualChange(this, VISUAL_TRANSFORM);
|
|
153
|
+
}
|
|
154
|
+
/** A name the application gives the object, for `getChildByName`. Empty unless set; it changes nothing that is drawn. */
|
|
155
|
+
get name() {
|
|
156
|
+
return visualOf(this).name;
|
|
157
|
+
}
|
|
158
|
+
set name(value) {
|
|
159
|
+
assertVisualMutable(this);
|
|
160
|
+
if (typeof value !== 'string')
|
|
161
|
+
throw invalidDisplayValue('name', value);
|
|
162
|
+
visualOf(this).name = value;
|
|
163
|
+
}
|
|
164
|
+
/**
|
|
165
|
+
* The width the object takes on its parent: the width of what it and its children draw, in its own units, times its
|
|
166
|
+
* scaleX without the sign. Setting it sets scaleX, keeping its sign, so that the width becomes the value; an object
|
|
167
|
+
* that draws nothing has no width to scale and refuses any but 0.
|
|
168
|
+
*/
|
|
169
|
+
get width() {
|
|
170
|
+
return this.getBounds().width * Math.abs(visualOf(this).scaleX);
|
|
171
|
+
}
|
|
172
|
+
set width(value) {
|
|
173
|
+
this.scaleX = sizeScale(value, this.getBounds().width, visualOf(this).scaleX);
|
|
174
|
+
}
|
|
175
|
+
/** As `width`, down the object and with scaleY. */
|
|
176
|
+
get height() {
|
|
177
|
+
return this.getBounds().height * Math.abs(visualOf(this).scaleY);
|
|
178
|
+
}
|
|
179
|
+
set height(value) {
|
|
180
|
+
this.scaleY = sizeScale(value, this.getBounds().height, visualOf(this).scaleY);
|
|
181
|
+
}
|
|
182
|
+
get alpha() {
|
|
183
|
+
return visualOf(this).alpha;
|
|
184
|
+
}
|
|
185
|
+
set alpha(value) {
|
|
186
|
+
assertVisualMutable(this);
|
|
187
|
+
const alpha = alphaOf(value);
|
|
188
|
+
if (alpha === undefined)
|
|
189
|
+
throw invalidDisplayValue('alpha', value);
|
|
190
|
+
const state = visualOf(this), changed = !sameVisualValue(state.alpha, alpha);
|
|
191
|
+
state.alpha = alpha;
|
|
192
|
+
if (changed)
|
|
193
|
+
recordVisualChange(this, VISUAL_APPEARANCE);
|
|
194
|
+
}
|
|
195
|
+
get visible() {
|
|
196
|
+
return visualOf(this).visible;
|
|
197
|
+
}
|
|
198
|
+
set visible(value) {
|
|
199
|
+
assertVisualMutable(this);
|
|
200
|
+
if (typeof value !== 'boolean')
|
|
201
|
+
throw invalidDisplayValue('visible', value);
|
|
202
|
+
const state = visualOf(this), changed = !sameVisualValue(state.visible, value);
|
|
203
|
+
state.visible = value;
|
|
204
|
+
if (changed)
|
|
205
|
+
recordVisualChange(this, VISUAL_APPEARANCE);
|
|
206
|
+
}
|
|
207
|
+
/** A complete material value overrides the nearest inherited value. */
|
|
208
|
+
get sharedMaterial() {
|
|
209
|
+
return visualOf(this).sharedMaterial;
|
|
210
|
+
}
|
|
211
|
+
set sharedMaterial(value) {
|
|
212
|
+
assertVisualMutable(this);
|
|
213
|
+
if (value !== null && !isSharedMaterial2D(value))
|
|
214
|
+
throw invalidDisplayValue('sharedMaterial', value);
|
|
215
|
+
const state = visualOf(this), changed = state.sharedMaterial !== value;
|
|
216
|
+
state.sharedMaterial = value;
|
|
217
|
+
if (changed)
|
|
218
|
+
recordVisualChange(this, VISUAL_APPEARANCE);
|
|
219
|
+
}
|
|
220
|
+
/**
|
|
221
|
+
* How what this object and its children draw is combined with what is under it, by Egret's names: `add` brightens,
|
|
222
|
+
* `multiply` darkens, `screen` lightens softly and `erase` takes away by its alpha. It is the blend of `sharedMaterial`:
|
|
223
|
+
* setting it keeps the material's tints and replaces only its blend, and a child with a material of its own keeps that.
|
|
224
|
+
*/
|
|
225
|
+
get blendMode() {
|
|
226
|
+
const blend = visualOf(this).sharedMaterial?.blend ?? 'normal';
|
|
227
|
+
return blend === 'add-accumulate' || blend === 'add-preserve'
|
|
228
|
+
? 'add'
|
|
229
|
+
: blend === 'multiply-factor'
|
|
230
|
+
? 'multiply'
|
|
231
|
+
: blend;
|
|
232
|
+
}
|
|
233
|
+
set blendMode(value) {
|
|
234
|
+
assertVisualMutable(this);
|
|
235
|
+
if (typeof value !== 'string' || !Object.hasOwn(BLENDS, value))
|
|
236
|
+
throw invalidDisplayValue('blendMode', value);
|
|
237
|
+
const blend = BLENDS[value];
|
|
238
|
+
const state = visualOf(this), base = state.sharedMaterial;
|
|
239
|
+
if (base === null && blend === 'normal')
|
|
240
|
+
return;
|
|
241
|
+
if (base !== null && base.blend === blend)
|
|
242
|
+
return;
|
|
243
|
+
const next = createSharedMaterial2D({
|
|
244
|
+
light: base?.light,
|
|
245
|
+
dark: base?.dark,
|
|
246
|
+
blend,
|
|
247
|
+
samplingDomain: base?.samplingDomain,
|
|
248
|
+
filter: base?.filter,
|
|
249
|
+
addressU: base?.addressU,
|
|
250
|
+
addressV: base?.addressV,
|
|
251
|
+
regionIsolation: base?.regionIsolation,
|
|
252
|
+
minFilter: base?.minFilter,
|
|
253
|
+
magFilter: base?.magFilter
|
|
254
|
+
});
|
|
255
|
+
state.sharedMaterial = next;
|
|
256
|
+
recordVisualChange(this, VISUAL_APPEARANCE);
|
|
257
|
+
}
|
|
258
|
+
/** Shared backends execute effects; legacy captures explicitly refuse them. */
|
|
259
|
+
get renderEffect() {
|
|
260
|
+
return visualOf(this).renderEffect;
|
|
261
|
+
}
|
|
262
|
+
set renderEffect(value) {
|
|
263
|
+
setRenderEffect(this, value);
|
|
264
|
+
}
|
|
265
|
+
/** An ordering boundary is metadata, not another display or resource owner. */
|
|
266
|
+
get renderBoundary() {
|
|
267
|
+
return visualOf(this).renderBoundary;
|
|
268
|
+
}
|
|
269
|
+
set renderBoundary(value) {
|
|
270
|
+
assertVisualMutable(this);
|
|
271
|
+
if (value !== 'none' && value !== 'isolate')
|
|
272
|
+
throw invalidDisplayValue('renderBoundary', value);
|
|
273
|
+
const state = visualOf(this), changed = state.renderBoundary !== value;
|
|
274
|
+
state.renderBoundary = value;
|
|
275
|
+
if (changed)
|
|
276
|
+
recordVisualChange(this, VISUAL_APPEARANCE);
|
|
277
|
+
}
|
|
278
|
+
get clipRect() {
|
|
279
|
+
return visualOf(this).clipRect;
|
|
280
|
+
}
|
|
281
|
+
set clipRect(value) {
|
|
282
|
+
assertVisualMutable(this);
|
|
283
|
+
let copy;
|
|
284
|
+
try {
|
|
285
|
+
copy = value === undefined ? undefined : copyRect(value, 'DISPLAY_VALUE_INVALID');
|
|
286
|
+
}
|
|
287
|
+
catch (cause) {
|
|
288
|
+
if (cause instanceof EgretError)
|
|
289
|
+
throw cause;
|
|
290
|
+
throw new EgretError('DISPLAY_VALUE_INVALID', { cause });
|
|
291
|
+
}
|
|
292
|
+
assertVisualMutable(this);
|
|
293
|
+
const state = visualOf(this), changed = !sameVisualValue(state.clipRect, copy);
|
|
294
|
+
state.clipRect = copy;
|
|
295
|
+
if (changed)
|
|
296
|
+
recordVisualChange(this, VISUAL_APPEARANCE);
|
|
297
|
+
}
|
|
298
|
+
get parent() {
|
|
299
|
+
return parentOf(this);
|
|
300
|
+
}
|
|
301
|
+
get isDisposed() {
|
|
302
|
+
return isTerminated(this);
|
|
303
|
+
}
|
|
304
|
+
/** Map logical coordinates through the actual root, including its transform. */
|
|
305
|
+
localToGlobal(localX, localY, options) {
|
|
306
|
+
return queryDisplayPoint(this, localX, localY, options, false);
|
|
307
|
+
}
|
|
308
|
+
/** Solve the stored world matrix and return one owned, frozen point. */
|
|
309
|
+
globalToLocal(globalX, globalY, options) {
|
|
310
|
+
return queryDisplayPoint(this, globalX, globalY, options, true);
|
|
311
|
+
}
|
|
312
|
+
/** Measure descendant-transformed content in this node's local coordinates. */
|
|
313
|
+
getBounds(options) {
|
|
314
|
+
return queryDisplayBounds(this, options);
|
|
315
|
+
}
|
|
316
|
+
assertUsable() {
|
|
317
|
+
assertLive(this);
|
|
318
|
+
}
|
|
319
|
+
eventParent() {
|
|
320
|
+
return this.parent;
|
|
321
|
+
}
|
|
322
|
+
[ASSERT_BINDABLE]() {
|
|
323
|
+
this.assertUsable();
|
|
324
|
+
}
|
|
325
|
+
[ASSERT_ATTACHABLE]() {
|
|
326
|
+
this.assertUsable();
|
|
327
|
+
}
|
|
328
|
+
[OWNERSHIP_CHILDREN]() {
|
|
329
|
+
return [];
|
|
330
|
+
}
|
|
331
|
+
/** Mark terminal before removing listeners, so callback reentry sees disposal. */
|
|
332
|
+
dispose() {
|
|
333
|
+
if (isTerminated(this))
|
|
334
|
+
return;
|
|
335
|
+
assertManagedMutable(this);
|
|
336
|
+
terminateNode(this);
|
|
337
|
+
this.clearListeners();
|
|
338
|
+
}
|
|
339
|
+
}
|
|
340
|
+
//# sourceMappingURL=DisplayObject.js.map
|
|
@@ -0,0 +1,28 @@
|
|
|
1
|
+
import { DisplayObject } from "./DisplayObject.js";
|
|
2
|
+
import { OWNERSHIP_CHILDREN } from "./ownership.js";
|
|
3
|
+
/** Ordered display children with atomic reparenting and ownership-aware cleanup. */
|
|
4
|
+
export declare class DisplayObjectContainer extends DisplayObject {
|
|
5
|
+
constructor();
|
|
6
|
+
/** Suppressed descendants never implicitly retarget to this container. */
|
|
7
|
+
get touchChildren(): boolean;
|
|
8
|
+
set touchChildren(value: boolean);
|
|
9
|
+
get numChildren(): number;
|
|
10
|
+
[OWNERSHIP_CHILDREN](): readonly object[];
|
|
11
|
+
/** Subclass hooks run in preflight; final binding and reparenting use internal state. */
|
|
12
|
+
addChild<T extends DisplayObject>(child: T): T;
|
|
13
|
+
/** Insert at an inclusive index; subclass callbacks finish before one private plan. */
|
|
14
|
+
addChildAt<T extends DisplayObject>(child: T, index: number): T;
|
|
15
|
+
/** Detach without disposing or transferring the cleanup owner. */
|
|
16
|
+
removeChild<T extends DisplayObject>(child: T): T;
|
|
17
|
+
/** Detach every direct child without disposing nodes or transferring owners. */
|
|
18
|
+
removeChildren(): void;
|
|
19
|
+
/** The first child with this name, or undefined. Children's own children are not looked at. */
|
|
20
|
+
getChildByName(name: string): DisplayObject | undefined;
|
|
21
|
+
getChildAt(index: number): DisplayObject;
|
|
22
|
+
/** Return a genuine direct child's current zero-based index without mutation. */
|
|
23
|
+
getChildIndex(child: DisplayObject): number;
|
|
24
|
+
setChildIndex(child: DisplayObject, index: number): void;
|
|
25
|
+
private validateIndex;
|
|
26
|
+
dispose(): void;
|
|
27
|
+
}
|
|
28
|
+
//# sourceMappingURL=DisplayObjectContainer.d.ts.map
|
|
@@ -0,0 +1,226 @@
|
|
|
1
|
+
import { assertManagedEdgeMutable, assertManagedChildrenMutable, cleanupManagedWrapper, managedTerminal } from "./ui/managedState.js";
|
|
2
|
+
import { DisplayObject } from "./DisplayObject.js";
|
|
3
|
+
import { registerDisplayHitContainer, readDisplayTouchChildren, writeDisplayTouchChildren } from "./displayHitState.js";
|
|
4
|
+
import { EgretError } from "./EgretError.js";
|
|
5
|
+
import { ASSERT_ATTACHABLE, ASSERT_BINDABLE, OWNERSHIP_CHILDREN, commitBinding, engineInSubtree, engineOf, ownerOf, preflightBinding, prepareChildInsertion, publishPreparedChildInsertion, validateBinding } from "./ownership.js";
|
|
6
|
+
import { assertAttachable, assertContainer, assertLive, assertNoCycle, assertChildInsertionIndex, attachNode, childAtOf, childCountOf, childIndexOf, childrenOf, detachChildren, detachNode, isDisplayNode, isTerminated, parentOf, registerContainer, removeNode, setNodeIndex } from "./displayTreeState.js";
|
|
7
|
+
// Carries the initiating owner's boundary through unowned intermediate containers.
|
|
8
|
+
const disposalBoundaries = new WeakMap();
|
|
9
|
+
/** Ordered display children with atomic reparenting and ownership-aware cleanup. */
|
|
10
|
+
export class DisplayObjectContainer extends DisplayObject {
|
|
11
|
+
constructor() {
|
|
12
|
+
super();
|
|
13
|
+
registerContainer(this);
|
|
14
|
+
registerDisplayHitContainer(this);
|
|
15
|
+
}
|
|
16
|
+
/** Suppressed descendants never implicitly retarget to this container. */
|
|
17
|
+
get touchChildren() {
|
|
18
|
+
return readDisplayTouchChildren(this);
|
|
19
|
+
}
|
|
20
|
+
set touchChildren(value) {
|
|
21
|
+
writeDisplayTouchChildren(this, value);
|
|
22
|
+
}
|
|
23
|
+
get numChildren() {
|
|
24
|
+
return childCountOf(this);
|
|
25
|
+
}
|
|
26
|
+
[OWNERSHIP_CHILDREN]() {
|
|
27
|
+
return childrenOf(this);
|
|
28
|
+
}
|
|
29
|
+
/** Subclass hooks run in preflight; final binding and reparenting use internal state. */
|
|
30
|
+
addChild(child) {
|
|
31
|
+
assertManagedEdgeMutable(this, child);
|
|
32
|
+
// A bound receiver's existing descendants already share its permanent
|
|
33
|
+
// affinity: every attach/bind validates before commit and detach retains it.
|
|
34
|
+
// Preserve whole-tree checks for a receiver that starts unbound, even if a
|
|
35
|
+
// subclass hook binds it while this operation is in progress.
|
|
36
|
+
const receiverWasBound = engineOf(this) !== undefined;
|
|
37
|
+
const engine = engineInSubtree(this) ?? engineInSubtree(child);
|
|
38
|
+
engine?.assertOpen();
|
|
39
|
+
this.assertUsable();
|
|
40
|
+
child[ASSERT_ATTACHABLE]();
|
|
41
|
+
assertNoCycle(this, child);
|
|
42
|
+
if (engine !== undefined) {
|
|
43
|
+
if (receiverWasBound) {
|
|
44
|
+
// Incoming attachability can close the Engine. Preserve the original
|
|
45
|
+
// preflight error priority before invoking any receiver bindable hook.
|
|
46
|
+
engine.assertOpen();
|
|
47
|
+
this[ASSERT_BINDABLE]();
|
|
48
|
+
}
|
|
49
|
+
else
|
|
50
|
+
preflightBinding(this, engine);
|
|
51
|
+
preflightBinding(child, engine);
|
|
52
|
+
}
|
|
53
|
+
// Re-read state and both current trees after callback-capable preflight.
|
|
54
|
+
// Validation, binding and internal detach/attach below invoke no user code.
|
|
55
|
+
assertManagedEdgeMutable(this, child);
|
|
56
|
+
const finalEngine = engineInSubtree(this) ?? engineInSubtree(child);
|
|
57
|
+
finalEngine?.assertOpen();
|
|
58
|
+
assertLive(this);
|
|
59
|
+
assertAttachable(child);
|
|
60
|
+
assertNoCycle(this, child);
|
|
61
|
+
// Receiver hooks still run; unrelated existing descendants do not. Final
|
|
62
|
+
// incoming validation always reads the current tree without user callbacks.
|
|
63
|
+
const binding = finalEngine === undefined
|
|
64
|
+
? undefined
|
|
65
|
+
: [...(receiverWasBound ? [] : validateBinding(this, finalEngine)), ...validateBinding(child, finalEngine)];
|
|
66
|
+
if (binding !== undefined && finalEngine !== undefined)
|
|
67
|
+
commitBinding(binding, finalEngine);
|
|
68
|
+
attachNode(this, child);
|
|
69
|
+
return child;
|
|
70
|
+
}
|
|
71
|
+
/** Insert at an inclusive index; subclass callbacks finish before one private plan. */
|
|
72
|
+
addChildAt(child, index) {
|
|
73
|
+
assertManagedEdgeMutable(this, child);
|
|
74
|
+
// Authenticate and apply this API's fixed refusal order before any display hook.
|
|
75
|
+
assertContainer(this);
|
|
76
|
+
const receiverWasBound = engineOf(this) !== undefined;
|
|
77
|
+
const receiverEngine = engineInSubtree(this);
|
|
78
|
+
receiverEngine?.assertOpen();
|
|
79
|
+
assertLive(this);
|
|
80
|
+
if (!isDisplayNode(child))
|
|
81
|
+
throw new EgretError("INVALID_DISPLAY_OBJECT");
|
|
82
|
+
const engine = receiverEngine ?? engineInSubtree(child);
|
|
83
|
+
engine?.assertOpen();
|
|
84
|
+
assertAttachable(child);
|
|
85
|
+
assertNoCycle(this, child);
|
|
86
|
+
assertChildInsertionIndex(this, index);
|
|
87
|
+
this.assertUsable();
|
|
88
|
+
child[ASSERT_ATTACHABLE]();
|
|
89
|
+
if (engine !== undefined) {
|
|
90
|
+
if (receiverWasBound) {
|
|
91
|
+
engine.assertOpen();
|
|
92
|
+
this[ASSERT_BINDABLE]();
|
|
93
|
+
}
|
|
94
|
+
else
|
|
95
|
+
preflightBinding(this, engine);
|
|
96
|
+
preflightBinding(child, engine);
|
|
97
|
+
}
|
|
98
|
+
// No earlier tree/list/binding plan survives these callback-capable preflights.
|
|
99
|
+
assertManagedEdgeMutable(this, child);
|
|
100
|
+
const plan = prepareChildInsertion(this, child, index);
|
|
101
|
+
publishPreparedChildInsertion(plan);
|
|
102
|
+
return child;
|
|
103
|
+
}
|
|
104
|
+
/** Detach without disposing or transferring the cleanup owner. */
|
|
105
|
+
removeChild(child) {
|
|
106
|
+
assertManagedEdgeMutable(this, child);
|
|
107
|
+
engineOf(this)?.assertOpen();
|
|
108
|
+
assertLive(this);
|
|
109
|
+
assertLive(child);
|
|
110
|
+
removeNode(this, child);
|
|
111
|
+
return child;
|
|
112
|
+
}
|
|
113
|
+
/** Detach every direct child without disposing nodes or transferring owners. */
|
|
114
|
+
removeChildren() {
|
|
115
|
+
assertManagedChildrenMutable(this);
|
|
116
|
+
// Authenticate before reading affinity; preserve Engine-first life checks.
|
|
117
|
+
assertContainer(this);
|
|
118
|
+
engineOf(this)?.assertOpen();
|
|
119
|
+
assertLive(this);
|
|
120
|
+
detachChildren(this);
|
|
121
|
+
}
|
|
122
|
+
/** The first child with this name, or undefined. Children's own children are not looked at. */
|
|
123
|
+
getChildByName(name) {
|
|
124
|
+
if (typeof name !== "string")
|
|
125
|
+
throw new EgretError("DISPLAY_VALUE_INVALID");
|
|
126
|
+
for (let index = 0, count = childCountOf(this); index < count; index++) {
|
|
127
|
+
const child = childAtOf(this, index);
|
|
128
|
+
if (child !== undefined && child.name === name)
|
|
129
|
+
return child;
|
|
130
|
+
}
|
|
131
|
+
return undefined;
|
|
132
|
+
}
|
|
133
|
+
getChildAt(index) {
|
|
134
|
+
this.validateIndex(index);
|
|
135
|
+
const child = childAtOf(this, index);
|
|
136
|
+
if (child === undefined)
|
|
137
|
+
throw new EgretError("INVALID_INDEX");
|
|
138
|
+
return child;
|
|
139
|
+
}
|
|
140
|
+
/** Return a genuine direct child's current zero-based index without mutation. */
|
|
141
|
+
getChildIndex(child) {
|
|
142
|
+
// Authenticate before affinity; retain Engine-first receiver lifetime checks.
|
|
143
|
+
assertContainer(this);
|
|
144
|
+
engineOf(this)?.assertOpen();
|
|
145
|
+
assertLive(this);
|
|
146
|
+
if (!isDisplayNode(child))
|
|
147
|
+
throw new EgretError("INVALID_DISPLAY_OBJECT");
|
|
148
|
+
assertLive(child);
|
|
149
|
+
return childIndexOf(this, child);
|
|
150
|
+
}
|
|
151
|
+
setChildIndex(child, index) {
|
|
152
|
+
assertManagedEdgeMutable(this, child);
|
|
153
|
+
this.assertUsable();
|
|
154
|
+
assertLive(this);
|
|
155
|
+
this.validateIndex(index);
|
|
156
|
+
engineOf(this)?.assertOpen();
|
|
157
|
+
assertManagedEdgeMutable(this, child);
|
|
158
|
+
setNodeIndex(this, child, index);
|
|
159
|
+
}
|
|
160
|
+
validateIndex(index) {
|
|
161
|
+
if (!Number.isInteger(index) || index < 0 || index >= childCountOf(this))
|
|
162
|
+
throw new EgretError("INVALID_INDEX");
|
|
163
|
+
}
|
|
164
|
+
dispose() {
|
|
165
|
+
if (isTerminated(this))
|
|
166
|
+
return;
|
|
167
|
+
if (!managedTerminal(this))
|
|
168
|
+
assertManagedChildrenMutable(this);
|
|
169
|
+
const boundary = disposalBoundaries.get(this) ?? { owner: ownerOf(this) };
|
|
170
|
+
const engine = engineOf(this);
|
|
171
|
+
const failures = [];
|
|
172
|
+
const recordFailure = (cause) => {
|
|
173
|
+
const causes = cause instanceof EgretError &&
|
|
174
|
+
(cause.code === "EVENT_LISTENER_CLEANUP_FAILED" || cause.code === "DISPLAY_TREE_CLEANUP_FAILED")
|
|
175
|
+
? [cause.cause, ...cause.cleanupErrors]
|
|
176
|
+
: [cause];
|
|
177
|
+
for (const item of causes) {
|
|
178
|
+
if (engine === undefined)
|
|
179
|
+
failures.push(item);
|
|
180
|
+
else {
|
|
181
|
+
engine.captureCleanup(item);
|
|
182
|
+
engine.report({
|
|
183
|
+
code: "DISPLAY_CHILD_CLEANUP_FAILED",
|
|
184
|
+
phase: "display-tree",
|
|
185
|
+
severity: "error",
|
|
186
|
+
cause: item
|
|
187
|
+
});
|
|
188
|
+
}
|
|
189
|
+
}
|
|
190
|
+
};
|
|
191
|
+
// A listener cleanup failure must not skip the current child subtree.
|
|
192
|
+
try {
|
|
193
|
+
super.dispose();
|
|
194
|
+
}
|
|
195
|
+
catch (cause) {
|
|
196
|
+
recordFailure(cause);
|
|
197
|
+
}
|
|
198
|
+
for (const child of childrenOf(this)) {
|
|
199
|
+
if (parentOf(child) !== this)
|
|
200
|
+
continue;
|
|
201
|
+
const childOwner = ownerOf(child);
|
|
202
|
+
// Detach a foreign-owned subtree intact; its Scope remains responsible for it.
|
|
203
|
+
if (childOwner !== undefined && childOwner !== boundary.owner) {
|
|
204
|
+
detachNode(child);
|
|
205
|
+
engine?.report({ code: "FOREIGN_SUBTREE_DETACHED", phase: "display-tree", severity: "warning" });
|
|
206
|
+
continue;
|
|
207
|
+
}
|
|
208
|
+
disposalBoundaries.set(child, boundary);
|
|
209
|
+
try {
|
|
210
|
+
if (!cleanupManagedWrapper(child))
|
|
211
|
+
child.dispose();
|
|
212
|
+
}
|
|
213
|
+
catch (cause) {
|
|
214
|
+
recordFailure(cause);
|
|
215
|
+
}
|
|
216
|
+
finally {
|
|
217
|
+
disposalBoundaries.delete(child);
|
|
218
|
+
if (parentOf(child) === this)
|
|
219
|
+
detachNode(child);
|
|
220
|
+
}
|
|
221
|
+
}
|
|
222
|
+
if (failures.length !== 0)
|
|
223
|
+
throw new EgretError("DISPLAY_TREE_CLEANUP_FAILED", { cause: failures[0], cleanupErrors: failures.slice(1) });
|
|
224
|
+
}
|
|
225
|
+
}
|
|
226
|
+
//# sourceMappingURL=DisplayObjectContainer.js.map
|
|
@@ -0,0 +1,11 @@
|
|
|
1
|
+
export interface EgretErrorOptions {
|
|
2
|
+
readonly cause?: unknown;
|
|
3
|
+
readonly cleanupErrors?: readonly unknown[];
|
|
4
|
+
}
|
|
5
|
+
/** Stable machine-readable code, original cause, and associated cleanup failures. The message is for people and may change. */
|
|
6
|
+
export declare class EgretError extends Error {
|
|
7
|
+
readonly code: string;
|
|
8
|
+
readonly cleanupErrors: readonly unknown[];
|
|
9
|
+
constructor(code: string, options?: EgretErrorOptions);
|
|
10
|
+
}
|
|
11
|
+
//# sourceMappingURL=EgretError.d.ts.map
|
|
@@ -0,0 +1,36 @@
|
|
|
1
|
+
import { describeErrorCode } from './errorHelp.js';
|
|
2
|
+
/** The cause in a few words: an SDK error's own message, which carries its cause in turn, or another error's name and message. */
|
|
3
|
+
function causeText(cause, code) {
|
|
4
|
+
if (!(cause instanceof Error))
|
|
5
|
+
return '';
|
|
6
|
+
// The same code wrapped again adds nothing: what lies under it is told instead.
|
|
7
|
+
if (code !== undefined && cause instanceof EgretError && cause.code === code)
|
|
8
|
+
return causeText(cause.cause, code);
|
|
9
|
+
let text;
|
|
10
|
+
try {
|
|
11
|
+
const { name, message } = cause;
|
|
12
|
+
if (typeof message !== 'string' || message === '')
|
|
13
|
+
return '';
|
|
14
|
+
text = cause instanceof EgretError || typeof name !== 'string' || name === '' ? message : name + ': ' + message;
|
|
15
|
+
}
|
|
16
|
+
catch {
|
|
17
|
+
return '';
|
|
18
|
+
}
|
|
19
|
+
return ' Cause: ' + (text.length > 480 ? text.slice(0, 480) + '…' : text);
|
|
20
|
+
}
|
|
21
|
+
/** Stable machine-readable code, original cause, and associated cleanup failures. The message is for people and may change. */
|
|
22
|
+
export class EgretError extends Error {
|
|
23
|
+
code;
|
|
24
|
+
cleanupErrors;
|
|
25
|
+
constructor(code, options = {}) {
|
|
26
|
+
// The message is the code and, where this SDK has one, a sentence about it. Programs read `code`.
|
|
27
|
+
// What caused it follows, so a log line that shows only the message still names the first failure.
|
|
28
|
+
const help = describeErrorCode(code);
|
|
29
|
+
super((help === '' ? code : code + ': ' + help) + causeText(options.cause, code), { cause: options.cause });
|
|
30
|
+
this.name = 'EgretError';
|
|
31
|
+
this.code = code;
|
|
32
|
+
// Copy and freeze the list without replacing the original failure cause.
|
|
33
|
+
this.cleanupErrors = Object.freeze([...(options.cleanupErrors ?? [])]);
|
|
34
|
+
}
|
|
35
|
+
}
|
|
36
|
+
//# sourceMappingURL=EgretError.js.map
|
package/dist/Event.d.ts
ADDED
|
@@ -0,0 +1,45 @@
|
|
|
1
|
+
import type { EventDispatcher } from "./EventDispatcher.js";
|
|
2
|
+
declare const PAYLOAD_TYPE: unique symbol;
|
|
3
|
+
/** Descriptor identity and invariant payload type belong together. */
|
|
4
|
+
export interface EventType<T> {
|
|
5
|
+
readonly key: string;
|
|
6
|
+
readonly bubbles: boolean;
|
|
7
|
+
readonly cancelable: boolean;
|
|
8
|
+
readonly [PAYLOAD_TYPE]?: (payload: T) => T;
|
|
9
|
+
}
|
|
10
|
+
export interface EventTypeOptions {
|
|
11
|
+
readonly bubbles?: boolean;
|
|
12
|
+
readonly cancelable?: boolean;
|
|
13
|
+
}
|
|
14
|
+
/** Matching uses descriptor object identity; equal key strings do not alias types. */
|
|
15
|
+
export declare function createEventType<T>(key: string, options?: EventTypeOptions): EventType<T>;
|
|
16
|
+
export type EventPhase = "capturing" | "atTarget" | "bubbling";
|
|
17
|
+
interface DispatchState {
|
|
18
|
+
active: boolean;
|
|
19
|
+
stopped: boolean;
|
|
20
|
+
immediate: boolean;
|
|
21
|
+
prevented: boolean;
|
|
22
|
+
target: EventDispatcher | undefined;
|
|
23
|
+
currentTarget: EventDispatcher | undefined;
|
|
24
|
+
phase: EventPhase | undefined;
|
|
25
|
+
}
|
|
26
|
+
/** One typed payload with synchronous dispatch state; concurrent reuse is rejected. */
|
|
27
|
+
export declare class Event<T> {
|
|
28
|
+
readonly type: EventType<T>;
|
|
29
|
+
readonly payload: T;
|
|
30
|
+
constructor(type: EventType<T>, payload: NoInfer<T>);
|
|
31
|
+
get target(): EventDispatcher | undefined;
|
|
32
|
+
get currentTarget(): EventDispatcher | undefined;
|
|
33
|
+
get eventPhase(): EventPhase | undefined;
|
|
34
|
+
get defaultPrevented(): boolean;
|
|
35
|
+
stopPropagation(): void;
|
|
36
|
+
stopImmediatePropagation(): void;
|
|
37
|
+
preventDefault(): void;
|
|
38
|
+
}
|
|
39
|
+
/** Package-internal state operations, omitted from @egret/engine exports. */
|
|
40
|
+
export declare function beginDispatch(event: object, target: EventDispatcher): DispatchState;
|
|
41
|
+
export declare function visitDispatch(event: object, current: EventDispatcher, phase: EventPhase): void;
|
|
42
|
+
/** Keep target/defaultPrevented for inspection; clear transient dispatch pointers. */
|
|
43
|
+
export declare function endDispatch(event: object): void;
|
|
44
|
+
export {};
|
|
45
|
+
//# sourceMappingURL=Event.d.ts.map
|