@mark1russell7/visuals 0.0.0-bootstrap.0 → 0.1.0
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 +21 -0
- package/README.md +128 -1
- package/build/index.d.ts +64 -0
- package/build/index.d.ts.map +1 -0
- package/build/index.js +1 -0
- package/build/motion-Ba4IIfAV.js +338 -0
- package/build/motion-Ba4IIfAV.js.map +1 -0
- package/build/theme-eOmfx75p.d.ts +177 -0
- package/build/theme-eOmfx75p.d.ts.map +1 -0
- package/build/three.d.ts +126 -0
- package/build/three.d.ts.map +1 -0
- package/build/three.js +397 -0
- package/build/three.js.map +1 -0
- package/package.json +73 -6
|
@@ -0,0 +1,177 @@
|
|
|
1
|
+
import { Point3 } from "@mark1russell7/layout-contract";
|
|
2
|
+
/**
|
|
3
|
+
* The direction of a view: where the camera is, as seen from the point that it looks at.
|
|
4
|
+
* The space of a stage has the y axis up.
|
|
5
|
+
*/
|
|
6
|
+
interface ViewAngles {
|
|
7
|
+
/** The angle from the up axis to the camera, in radians. At 0, the camera looks down from above. */
|
|
8
|
+
readonly polar: number;
|
|
9
|
+
/** The angle around the up axis, in radians. At 0, the camera is on the positive z side of the point. */
|
|
10
|
+
readonly azimuth: number;
|
|
11
|
+
}
|
|
12
|
+
/** A place of a camera: the point that it looks at, the angles of its view and its distance from the point. */
|
|
13
|
+
interface Place extends ViewAngles {
|
|
14
|
+
readonly target: Point3;
|
|
15
|
+
readonly distance: number;
|
|
16
|
+
}
|
|
17
|
+
/** The three axes of a camera, as unit vectors in the space of the stage. */
|
|
18
|
+
interface ViewAxes {
|
|
19
|
+
/** The vector from the point that the camera looks at to the camera. */
|
|
20
|
+
readonly back: Point3;
|
|
21
|
+
/** The vector to the right side of the picture. */
|
|
22
|
+
readonly right: Point3;
|
|
23
|
+
/** The vector to the top of the picture. */
|
|
24
|
+
readonly up: Point3;
|
|
25
|
+
}
|
|
26
|
+
/** The limits of the place of a camera. */
|
|
27
|
+
interface PlaceLimits {
|
|
28
|
+
/** The smallest polar angle. At 0, the azimuth of a camera has no meaning. */
|
|
29
|
+
readonly minPolar: number;
|
|
30
|
+
/** The largest polar angle. */
|
|
31
|
+
readonly maxPolar: number;
|
|
32
|
+
/** The smallest distance from the target. */
|
|
33
|
+
readonly minDistance: number;
|
|
34
|
+
/** The largest distance from the target. */
|
|
35
|
+
readonly maxDistance: number;
|
|
36
|
+
}
|
|
37
|
+
/** This function gives the axes of the camera of a view. At a polar angle of 0, the top of the picture is the negative z axis. */
|
|
38
|
+
declare function viewAxes(view: ViewAngles): ViewAxes;
|
|
39
|
+
/**
|
|
40
|
+
* This function gives the smallest distance from `target` at which a camera shows each point.
|
|
41
|
+
*
|
|
42
|
+
* The camera looks at `target` along the direction of `view`. `fov` is the vertical angle of the picture in degrees,
|
|
43
|
+
* and `aspect` is the width of the picture divided by its height.
|
|
44
|
+
* The function gives 0 for no points, and for an angle or an aspect that makes no picture.
|
|
45
|
+
*/
|
|
46
|
+
declare function fitDistance(points: readonly Point3[], target: Point3, view: ViewAngles, fov: number, aspect: number): number;
|
|
47
|
+
/**
|
|
48
|
+
* This function gives the smallest distance from the center of a ball at which a camera shows a cap of the ball.
|
|
49
|
+
*
|
|
50
|
+
* The camera looks at the center of the ball, and the center of the cap is on the line to the camera.
|
|
51
|
+
* `radius` is the radius of the ball. `angle` is the angle of the cap at the center of the ball, in radians, from 0 to π / 2.
|
|
52
|
+
* `fov` is the vertical angle of the picture in degrees, and `aspect` is the width of the picture divided by its height.
|
|
53
|
+
* The function gives 0 for an angle or an aspect that makes no picture.
|
|
54
|
+
*/
|
|
55
|
+
declare function capDistance(radius: number, angle: number, fov: number, aspect: number): number;
|
|
56
|
+
/** This function gives the position of a camera at a distance from `target`, in the direction of `view`. */
|
|
57
|
+
declare function cameraPosition(target: Point3, view: ViewAngles, distance: number): Point3;
|
|
58
|
+
/** This function gives the angles of the view from `target` to a camera, and the distance between them. A camera at the target gives the angles 0. */
|
|
59
|
+
declare function viewOf(camera: Point3, target: Point3): ViewAngles & {
|
|
60
|
+
readonly distance: number;
|
|
61
|
+
};
|
|
62
|
+
/** This function gives the angle between two azimuths along the shortest way, from −π to π. */
|
|
63
|
+
declare function turnBetween(from: number, to: number): number;
|
|
64
|
+
/** This function gives a place in its limits. The target and the azimuth stay as they are. */
|
|
65
|
+
declare function clampPlace(place: Place, limits: PlaceLimits): Place;
|
|
66
|
+
/**
|
|
67
|
+
* This function gives the height of a camera above the surface of a stage, as a part of its distance from the target.
|
|
68
|
+
*
|
|
69
|
+
* `surface` is the radius of the ball around the target that the camera stays out of. A stage with no ball has the value 0.
|
|
70
|
+
* The result is the factor of the turn speed and the zoom speed of a camera: near the surface, a camera moves slowly.
|
|
71
|
+
* The result is 0.02 at least, so a camera on the surface can move away.
|
|
72
|
+
*/
|
|
73
|
+
declare function speedAt(distance: number, surface: number): number;
|
|
74
|
+
/**
|
|
75
|
+
* This function gives the place at a part of the way between two places. `part` goes from 0 to 1.
|
|
76
|
+
*
|
|
77
|
+
* The azimuth goes along the shortest way. The height above the surface changes by an equal factor for each equal step,
|
|
78
|
+
* so a zoom has one speed in the picture. `surface` is the radius of the ball around the target, or 0 for no ball.
|
|
79
|
+
*/
|
|
80
|
+
declare function placeBetween(from: Place, to: Place, part: number, surface?: number): Place;
|
|
81
|
+
/** The space that the content of a stage fills. A view and the limits of the camera come from it. */
|
|
82
|
+
interface StageExtent {
|
|
83
|
+
/** The points that a view of all the content shows, for example each corner of each solid. */
|
|
84
|
+
readonly corners: readonly Point3[];
|
|
85
|
+
/** The point that the camera looks at. */
|
|
86
|
+
readonly center: Point3;
|
|
87
|
+
/**
|
|
88
|
+
* The radius of the ball around the center that the camera stays out of, for example the radius of a globe.
|
|
89
|
+
* The default is 0: the content has no ball.
|
|
90
|
+
*/
|
|
91
|
+
readonly surface?: number | undefined;
|
|
92
|
+
/** The smallest distance of the camera from the center. The default comes from the views of the stage. */
|
|
93
|
+
readonly minDistance?: number | undefined;
|
|
94
|
+
/** The largest distance of the camera from the center. The default comes from the views of the stage. */
|
|
95
|
+
readonly maxDistance?: number | undefined;
|
|
96
|
+
}
|
|
97
|
+
/** The picture that a view is for: the content, and the angle and the shape of the picture. */
|
|
98
|
+
interface ViewFrame {
|
|
99
|
+
readonly extent: StageExtent;
|
|
100
|
+
/** The vertical angle of the picture, in degrees. */
|
|
101
|
+
readonly fieldOfView: number;
|
|
102
|
+
/** The width of the picture divided by its height. */
|
|
103
|
+
readonly aspect: number;
|
|
104
|
+
}
|
|
105
|
+
/** A view of a stage: a function that gives the place of the camera for a picture. A new size of the picture gives a new place. */
|
|
106
|
+
type StageView = (frame: ViewFrame) => Place;
|
|
107
|
+
/** The limits of the camera of a stage: the limits of its place, and the nearest and the farthest depth that it draws. */
|
|
108
|
+
interface StageLimits extends PlaceLimits {
|
|
109
|
+
readonly near: number;
|
|
110
|
+
readonly far: number;
|
|
111
|
+
}
|
|
112
|
+
/** The space around the content in a view that shows all of it, as a factor of the distance. */
|
|
113
|
+
declare const FIT_MARGIN = 1.06;
|
|
114
|
+
/** This function gives the radius of the ball around the center of an extent, or 0 for no ball. */
|
|
115
|
+
declare function surfaceOf(extent: StageExtent): number;
|
|
116
|
+
/**
|
|
117
|
+
* This function makes a view that shows each corner of the content from one direction.
|
|
118
|
+
* `margin` is the space around the content, as a factor of the distance. An extent with no corners gives the distance 1.
|
|
119
|
+
*/
|
|
120
|
+
declare function fitView(angles: ViewAngles, margin?: number): StageView;
|
|
121
|
+
/**
|
|
122
|
+
* This function makes a view of a part of the ball of the content: a cap around the point of the ball below the camera.
|
|
123
|
+
*
|
|
124
|
+
* `angles` is the direction from the center of the ball to the camera. `angle` is the angle of the cap at the center of the ball, in radians.
|
|
125
|
+
* `margin` is the space around the cap, as a factor of the height above the ball. An extent with no ball gives the distance 1.
|
|
126
|
+
*/
|
|
127
|
+
declare function capView(angles: ViewAngles, angle: number, margin?: number): StageView;
|
|
128
|
+
/**
|
|
129
|
+
* This function gives the limits of the camera of a stage for a picture.
|
|
130
|
+
*
|
|
131
|
+
* The largest distance of the views is the base. The camera goes out to 3 times this distance, and in to 3 % of the height of that view.
|
|
132
|
+
* The extent can give each distance. The nearest depth is small against the height of the nearest camera, and the farthest depth is behind all the content.
|
|
133
|
+
*/
|
|
134
|
+
declare function stageLimits(frame: ViewFrame, views: readonly StageView[], polar: {
|
|
135
|
+
readonly min: number;
|
|
136
|
+
readonly max: number;
|
|
137
|
+
}): StageLimits;
|
|
138
|
+
/** The mark of a record. 0 is no mark. 1 is a record under the pointer or in the marked list. 2 is the selected record. */
|
|
139
|
+
type Mark = 0 | 1 | 2;
|
|
140
|
+
/** The records of a stage that have a mark. Each record has a name. */
|
|
141
|
+
interface Marks {
|
|
142
|
+
/** The name of the record under the pointer. */
|
|
143
|
+
readonly hovered: string | undefined;
|
|
144
|
+
/** The name of the selected record. */
|
|
145
|
+
readonly selected: string | undefined;
|
|
146
|
+
/** The names of the records that the page marks. */
|
|
147
|
+
readonly marked: ReadonlySet<string>;
|
|
148
|
+
}
|
|
149
|
+
/** The marks of a stage with no pointer on it and no selected record. */
|
|
150
|
+
declare const NO_MARKS: Marks;
|
|
151
|
+
/** This function gives the mark of a record. The selected record has the highest mark. */
|
|
152
|
+
declare function markOf(marks: Marks, record: string): Mark;
|
|
153
|
+
/** A pointer that moves this distance or less between down and up makes a click, in CSS pixels. */
|
|
154
|
+
declare const CLICK_DISTANCE = 4;
|
|
155
|
+
/**
|
|
156
|
+
* This function tells if a pointer that went down and up made a click. A pointer that moved more than `limit` made a drag.
|
|
157
|
+
* The positions and the limit are in CSS pixels.
|
|
158
|
+
*/
|
|
159
|
+
declare function isClick(down: {
|
|
160
|
+
readonly x: number;
|
|
161
|
+
readonly y: number;
|
|
162
|
+
}, up: {
|
|
163
|
+
readonly x: number;
|
|
164
|
+
readonly y: number;
|
|
165
|
+
}, limit?: number): boolean;
|
|
166
|
+
/**
|
|
167
|
+
* The colors that each stage uses. Each color is a CSS hex color, for example `#22364a`.
|
|
168
|
+
* A stage has no background: the page shows behind the content. The theme of a content adds its own colors.
|
|
169
|
+
*/
|
|
170
|
+
interface StageTheme {
|
|
171
|
+
/** The color of the light from above. */
|
|
172
|
+
readonly sky: string;
|
|
173
|
+
/** The color of the light from below. */
|
|
174
|
+
readonly ground: string;
|
|
175
|
+
}
|
|
176
|
+
export { clampPlace as C, turnBetween as D, speedAt as E, viewAxes as O, capDistance as S, placeBetween as T, Place as _, NO_MARKS as a, ViewAxes as b, FIT_MARGIN as c, StageView as d, ViewFrame as f, surfaceOf as g, stageLimits as h, Marks as i, viewOf as k, StageExtent as l, fitView as m, CLICK_DISTANCE as n, isClick as o, capView as p, Mark as r, markOf as s, StageTheme as t, StageLimits as u, PlaceLimits as v, fitDistance as w, cameraPosition as x, ViewAngles as y };
|
|
177
|
+
//# sourceMappingURL=theme-eOmfx75p.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"theme-eOmfx75p.d.ts","names":[],"sources":["../src/view.ts","../src/extent.ts","../src/marks.ts","../src/theme.ts"],"mappings":";;;;;UAMiB;;WAEN;;WAEA;;;UAIM,cAAc;WACpB,QAAQ;WACR;;;UAIM;;WAEN,MAAM;;WAEN,OAAO;;WAEP,IAAI;;;UAIE;;WAEN;;WAEA;;WAEA;;WAEA;;;iBAIK,SAAS,MAAM,aAAa;;;;;;;;iBAwB5B,YAAY,iBAAiB,UAAU,QAAQ,QAAQ,MAAM,YAAY,aAAa;;;;;;;;;iBAsBtF,YAAY,gBAAgB,eAAe,aAAa;;iBAaxD,eAAe,QAAQ,QAAQ,MAAM,YAAY,mBAAmB;;iBAMpE,OAAO,QAAQ,QAAQ,QAAQ,SAAS;WAAwB;;;iBAUhE,YAAY,cAAc;;iBAO1B,WAAW,OAAO,OAAO,QAAQ,cAAc;;;;;;;;iBAgB/C,QAAQ,kBAAkB;;;;;;;iBAW1B,aAAa,MAAM,OAAO,IAAI,OAAO,cAAc,mBAAsB;;UCnJxE;;WAEN,kBAAkB;;WAElB,QAAQ;;;;;WAKR;;WAEA;;WAEA;;;UAIM;WACN,QAAQ;;WAER;;WAEA;;;KAIC,aAAa,OAAO,cAAc;;UAG7B,oBAAoB;WAC1B;WACA;;;cAIE;;iBAGG,UAAU,QAAQ;;;;;iBASlB,QAAQ,QAAQ,YAAY,kBAA8B;;;;;;;iBAa1D,QAAQ,QAAQ,YAAY,eAAe,kBAA8B;;;;;;;iBAczE,YAAY,OAAO,WAAW,gBAAgB,aAAa;WAAkB;WAAsB;IAAgB;;KC7EvH;;UAGK;;WAEN;;WAEA;;WAEA,QAAQ;;;cAIN,UAAU;;iBAGP,OAAO,OAAO,OAAO,iBAAiB;;cAMzC;;;;;iBAMG,QAAQ;WAAiB;WAAoB;GAAa;WAAe;WAAoB;GAAa;;;;;UCzBzG;;WAEN;;WAEA"}
|
package/build/three.d.ts
ADDED
|
@@ -0,0 +1,126 @@
|
|
|
1
|
+
import { _ as Place, d as StageView, l as StageExtent, r as Mark, t as StageTheme } from "./theme-eOmfx75p.js";
|
|
2
|
+
import { Object3D, PerspectiveCamera, Raycaster } from "three";
|
|
3
|
+
/** The record under the pointer: its name, and the value that the content gives for it. */
|
|
4
|
+
interface StagePick<P> {
|
|
5
|
+
/** The name of the record. The marks of the stage use this name. */
|
|
6
|
+
readonly record: string;
|
|
7
|
+
/** The value of the record for the page, for example its kind and its source. */
|
|
8
|
+
readonly value: P;
|
|
9
|
+
}
|
|
10
|
+
/** One picture of a stage, for the step of its content. */
|
|
11
|
+
interface StageFrame {
|
|
12
|
+
readonly camera: PerspectiveCamera;
|
|
13
|
+
/** The time since the last picture, in seconds. */
|
|
14
|
+
readonly seconds: number;
|
|
15
|
+
/**
|
|
16
|
+
* This value is true for the first picture of a content, and for a person who asks for less motion.
|
|
17
|
+
* Each change then has no time: the content sets each value to its goal immediately.
|
|
18
|
+
*/
|
|
19
|
+
readonly settle: boolean;
|
|
20
|
+
/** The height of the picture, in CSS pixels. */
|
|
21
|
+
readonly height: number;
|
|
22
|
+
/** The vertical angle of the picture, in degrees. */
|
|
23
|
+
readonly fieldOfView: number;
|
|
24
|
+
}
|
|
25
|
+
/**
|
|
26
|
+
* The content of a stage: the three.js objects of one scene, and what the stage asks of them.
|
|
27
|
+
* `P` is the type of the value of a pick, and `T` is the type of the theme.
|
|
28
|
+
*/
|
|
29
|
+
interface StageContent<P, T extends StageTheme = StageTheme> {
|
|
30
|
+
/** The three.js objects of the content. The stage adds them to its world, and removes them. */
|
|
31
|
+
readonly objects: readonly Object3D[];
|
|
32
|
+
/** The space that the content fills. */
|
|
33
|
+
readonly extent: StageExtent;
|
|
34
|
+
/** This function tells if the content has a record with a name. */
|
|
35
|
+
has(record: string): boolean;
|
|
36
|
+
/** This function gives the record that a ray from the camera finds first, or `undefined` for no record. */
|
|
37
|
+
pick(ray: Raycaster): StagePick<P> | undefined;
|
|
38
|
+
/** This function gives each part its colors, from the theme and the mark of its record. */
|
|
39
|
+
paint(theme: T, mark: (record: string) => Mark): void;
|
|
40
|
+
/**
|
|
41
|
+
* This function changes the parts that depend on the camera or on the time, before each picture.
|
|
42
|
+
* It gives true while a part continues to change. The stage then makes the next picture.
|
|
43
|
+
*/
|
|
44
|
+
step?(frame: StageFrame): boolean;
|
|
45
|
+
/** This function releases the memory of the graphics card that the content uses. */
|
|
46
|
+
dispose(): void;
|
|
47
|
+
}
|
|
48
|
+
/** The lights of a stage. A content with materials that use no light ignores them. */
|
|
49
|
+
interface StageLights {
|
|
50
|
+
/** The strength of the light from above and below. */
|
|
51
|
+
readonly sky: number;
|
|
52
|
+
/** The strength of the light from one direction. */
|
|
53
|
+
readonly sun: number;
|
|
54
|
+
/** The position that the light from one direction comes from. */
|
|
55
|
+
readonly from: {
|
|
56
|
+
readonly x: number;
|
|
57
|
+
readonly y: number;
|
|
58
|
+
readonly z: number;
|
|
59
|
+
};
|
|
60
|
+
}
|
|
61
|
+
/** The options of a stage. */
|
|
62
|
+
interface StageOptions<P, T extends StageTheme = StageTheme> {
|
|
63
|
+
/** The first content. The stage disposes each content that it gets. */
|
|
64
|
+
readonly content: StageContent<P, T>;
|
|
65
|
+
readonly theme: T;
|
|
66
|
+
/** The name of the picture for a screen reader. */
|
|
67
|
+
readonly label: string;
|
|
68
|
+
/** The views of the stage, each with a name. */
|
|
69
|
+
readonly views: Readonly<Record<string, StageView>>;
|
|
70
|
+
/** The name of the first view. The keys `Home` and `0` show it. */
|
|
71
|
+
readonly home: string;
|
|
72
|
+
/** The name of the view of a key, for example `{ t: "top" }`. A letter has no case. */
|
|
73
|
+
readonly keys?: Readonly<Record<string, string>> | undefined;
|
|
74
|
+
/** The vertical angle of the picture, in degrees. A small angle gives the look of a drawing. The default is 32. */
|
|
75
|
+
readonly fieldOfView?: number | undefined;
|
|
76
|
+
/** The smallest and the largest polar angle of the camera, in radians. The default keeps the camera above the plane of the target. */
|
|
77
|
+
readonly polar?: {
|
|
78
|
+
readonly min?: number | undefined;
|
|
79
|
+
readonly max?: number | undefined;
|
|
80
|
+
} | undefined;
|
|
81
|
+
/** This value is true if a person can move the target with a drag of the second button. The default is true. */
|
|
82
|
+
readonly pan?: boolean | undefined;
|
|
83
|
+
readonly lights?: StageLights | undefined;
|
|
84
|
+
/** The stage starts this function when the pointer goes to a different record, or to no record. */
|
|
85
|
+
readonly onHover?: ((pick: P | undefined) => void) | undefined;
|
|
86
|
+
/** The stage starts this function when a person selects a record with the pointer, or selects no record. */
|
|
87
|
+
readonly onSelect?: ((pick: P | undefined) => void) | undefined;
|
|
88
|
+
}
|
|
89
|
+
/** A stage in a page: one canvas with a camera that a person moves, and one content. */
|
|
90
|
+
interface Stage<P, T extends StageTheme = StageTheme> {
|
|
91
|
+
/** The canvas of the stage. It is in the container. */
|
|
92
|
+
readonly canvas: HTMLCanvasElement;
|
|
93
|
+
/** This function shows a different content, and disposes the old content. The view stays if a person moved it. */
|
|
94
|
+
setContent(content: StageContent<P, T>): void;
|
|
95
|
+
/** This function changes the colors. */
|
|
96
|
+
setTheme(theme: T): void;
|
|
97
|
+
/** This function moves the camera to a view: a name of the options, or a view function. `animate` has the default true. */
|
|
98
|
+
setView(view: string | StageView, animate?: boolean): void;
|
|
99
|
+
/** This function gives the place of the camera. */
|
|
100
|
+
place(): Place;
|
|
101
|
+
/** This function marks records by their names, as the pointer does. An empty list removes the marks. */
|
|
102
|
+
highlight(records: readonly string[]): void;
|
|
103
|
+
/** This function selects one record by its name, or no record. It does not start `onSelect`. */
|
|
104
|
+
select(record: string | undefined): void;
|
|
105
|
+
/** This function paints the content again and makes a new picture. Use it after a change of the content. */
|
|
106
|
+
refresh(): void;
|
|
107
|
+
/** This function removes the canvas and releases the memory of the graphics card. It disposes the content. */
|
|
108
|
+
dispose(): void;
|
|
109
|
+
}
|
|
110
|
+
/** The default vertical angle of the picture, in degrees. */
|
|
111
|
+
export declare const FIELD_OF_VIEW = 32;
|
|
112
|
+
/** The default lights: a strong light from above and below, and a light from the front left. */
|
|
113
|
+
export declare const STAGE_LIGHTS: StageLights;
|
|
114
|
+
/**
|
|
115
|
+
* This function makes a stage in a container of a page. The stage fills the container, so give the container a size.
|
|
116
|
+
*
|
|
117
|
+
* A person turns the content with a drag, and moves nearer with the wheel after a click in the picture.
|
|
118
|
+
* A click selects the record under the pointer. With the keyboard, the arrow keys turn the content, `+` and `-` change the distance,
|
|
119
|
+
* and `Home` shows the first view. The stage makes a picture only after a change.
|
|
120
|
+
*
|
|
121
|
+
* The function gives `undefined` when the browser has no WebGL 2. It does not throw, and it writes no error to the console.
|
|
122
|
+
* The page then shows a different picture of the same data.
|
|
123
|
+
*/
|
|
124
|
+
export declare function createStage<P, T extends StageTheme = StageTheme>(container: HTMLElement, options: StageOptions<P, T>): Stage<P, T> | undefined;
|
|
125
|
+
export type { Stage, StageContent, StageFrame, StageLights, StageOptions, StagePick };
|
|
126
|
+
//# sourceMappingURL=three.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"three.d.ts","names":[],"sources":["../src/stage/stage.ts"],"mappings":";;;UAUiB,UAAU;;WAEhB;;WAEA,OAAO;;;UAID;WACN,QAAQ;;WAER;;;;;WAKA;;WAEA;;WAEA;;;;;;UAOM,aAAa,GAAG,UAAU,aAAa;;WAE7C,kBAAkB;;WAElB,QAAQ;;EAEjB,IAAI;;EAEJ,KAAK,KAAK,YAAY,UAAU;;EAEhC,MAAM,OAAO,GAAG,OAAO,mBAAmB;;;;;EAK1C,MAAM,OAAO;;EAEb;;;UAIe;;WAEN;;WAEA;;WAEA;aAAiB;aAAoB;aAAoB;;;;UAInD,aAAa,GAAG,UAAU,aAAa;;WAE7C,SAAS,aAAa,GAAG;WACzB,OAAO;;WAEP;;WAEA,OAAO,SAAS,eAAe;;WAE/B;;WAEA,OAAO,SAAS;;WAEhB;;WAEA;aAAmB;aAAmC;;;WAEtD;WACA,SAAS;;WAET,YAAY,MAAM;;WAElB,aAAa,MAAM;;;UAIb,MAAM,GAAG,UAAU,aAAa;;WAEtC,QAAQ;;EAEjB,WAAW,SAAS,aAAa,GAAG;;EAEpC,SAAS,OAAO;;EAEhB,QAAQ,eAAe,WAAW;;EAElC,SAAS;;EAET,UAAU;;EAEV,OAAO;;EAEP;;EAEA;;;qBAIW;;qBAGA,cAAc;;;;;;;;;;;wBA6BX,YAAY,GAAG,UAAU,aAAa,YAAY,WAAW,aAAa,SAAS,aAAa,GAAG,KAAK,MAAM,GAAG"}
|