mol_plot_all 1.2.1699 → 1.2.1701

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.
Files changed (5) hide show
  1. package/node.d.ts +217 -0
  2. package/node.d.ts.map +1 -1
  3. package/package.json +1 -1
  4. package/web.d.ts +1419 -0
  5. package/web.d.ts.map +1 -1
package/web.d.ts CHANGED
@@ -1,3 +1,1053 @@
1
+ declare let _$_: {
2
+ new (): {};
3
+ } & typeof globalThis;
4
+ declare class $ extends _$_ {
5
+ }
6
+ declare namespace $ {
7
+ export type $ = typeof $$;
8
+ export class $$ extends $ {
9
+ static $: $;
10
+ }
11
+ namespace $$ {
12
+ type $$ = $;
13
+ }
14
+ export {};
15
+ }
16
+
17
+ declare namespace $ {
18
+ var $mol_dom_context: typeof globalThis;
19
+ }
20
+
21
+ declare namespace $ {
22
+ }
23
+
24
+ declare namespace $ {
25
+ var $mol_dom: typeof globalThis;
26
+ }
27
+
28
+ declare namespace $ {
29
+ function $mol_style_attach(id: string, text: string): HTMLStyleElement | null;
30
+ }
31
+
32
+ declare namespace $ {
33
+ class $mol_promise<Result = void> extends Promise<Result> {
34
+ done: (value: Result | PromiseLike<Result>) => void;
35
+ fail: (reason?: any) => void;
36
+ constructor(executor?: (done: (value: Result | PromiseLike<Result>) => void, fail: (reason?: any) => void) => void);
37
+ }
38
+ }
39
+
40
+ declare namespace $ {
41
+ class $mol_promise_blocker<Result> extends $mol_promise<Result> {
42
+ static [Symbol.toStringTag]: string;
43
+ }
44
+ }
45
+
46
+ declare namespace $ {
47
+ class $mol_decor<Value> {
48
+ readonly value: Value;
49
+ constructor(value: Value);
50
+ prefix(): string;
51
+ valueOf(): Value;
52
+ postfix(): string;
53
+ toString(): string;
54
+ }
55
+ }
56
+
57
+ declare namespace $ {
58
+ type $mol_style_unit_length = '%' | 'px' | 'cm' | 'mm' | 'Q' | 'in' | 'pc' | 'pt' | 'cap' | 'ch' | 'em' | 'rem' | 'ex' | 'ic' | 'lh' | 'rlh' | 'vh' | 'vw' | 'vi' | 'vb' | 'vmin' | 'vmax';
59
+ type $mol_style_unit_angle = 'deg' | 'rad' | 'grad' | 'turn';
60
+ type $mol_style_unit_time = 's' | 'ms';
61
+ type $mol_style_unit_any = $mol_style_unit_length | $mol_style_unit_angle | $mol_style_unit_time;
62
+ type $mol_style_unit_str<Quanity extends $mol_style_unit_any = $mol_style_unit_any> = `${number}${Quanity}`;
63
+ class $mol_style_unit<Literal extends $mol_style_unit_any> extends $mol_decor<number> {
64
+ readonly literal: Literal;
65
+ constructor(value: number, literal: Literal);
66
+ postfix(): Literal;
67
+ static per(value: number): `${number}%`;
68
+ static px(value: number): `${number}px`;
69
+ static mm(value: number): `${number}mm`;
70
+ static cm(value: number): `${number}cm`;
71
+ static Q(value: number): `${number}Q`;
72
+ static in(value: number): `${number}in`;
73
+ static pc(value: number): `${number}pc`;
74
+ static pt(value: number): `${number}pt`;
75
+ static cap(value: number): `${number}cap`;
76
+ static ch(value: number): `${number}ch`;
77
+ static em(value: number): `${number}em`;
78
+ static rem(value: number): `${number}rem`;
79
+ static ex(value: number): `${number}ex`;
80
+ static ic(value: number): `${number}ic`;
81
+ static lh(value: number): `${number}lh`;
82
+ static rlh(value: number): `${number}rlh`;
83
+ static vh(value: number): `${number}vh`;
84
+ static vw(value: number): `${number}vw`;
85
+ static vi(value: number): `${number}vi`;
86
+ static vb(value: number): `${number}vb`;
87
+ static vmin(value: number): `${number}vmin`;
88
+ static vmax(value: number): `${number}vmax`;
89
+ static deg(value: number): `${number}deg`;
90
+ static rad(value: number): `${number}rad`;
91
+ static grad(value: number): `${number}grad`;
92
+ static turn(value: number): `${number}turn`;
93
+ static s(value: number): `${number}s`;
94
+ static ms(value: number): `${number}ms`;
95
+ }
96
+ }
97
+
98
+ declare namespace $ {
99
+ type $mol_style_func_name = 'calc' | 'hsla' | 'rgba' | 'var' | 'clamp' | 'scale' | 'cubic-bezier' | 'linear' | 'steps' | $mol_style_func_image | $mol_style_func_filter;
100
+ type $mol_style_func_image = 'url' | 'linear-gradient' | 'radial-gradient' | 'conic-gradient';
101
+ type $mol_style_func_filter = 'blur' | 'brightness' | 'contrast' | 'drop-shadow' | 'grayscale' | 'hue-rotate' | 'invert' | 'opacity' | 'sepia' | 'saturate';
102
+ class $mol_style_func<Name extends $mol_style_func_name, Value = unknown> extends $mol_decor<Value> {
103
+ readonly name: Name;
104
+ constructor(name: Name, value: Value);
105
+ prefix(): string;
106
+ postfix(): string;
107
+ static linear_gradient<Value>(value: Value): $mol_style_func<"linear-gradient", Value>;
108
+ static radial_gradient<Value>(value: Value): $mol_style_func<"radial-gradient", Value>;
109
+ static calc<Value>(value: Value): $mol_style_func<"calc", Value>;
110
+ static vary<Name extends string, Value extends string>(name: Name, defaultValue?: Value): $mol_style_func<"var", Name | (Name | Value)[]>;
111
+ static url<Href extends string>(href: Href): $mol_style_func<"url", string>;
112
+ static hsla(hue: number | $mol_style_func<'var'>, saturation: number, lightness: number, alpha: number): $mol_style_func<"hsla", (number | `${number}%` | $mol_style_func<"var", unknown>)[]>;
113
+ static clamp(min: $mol_style_unit_str<any>, mid: $mol_style_unit_str<any>, max: $mol_style_unit_str<any>): $mol_style_func<"clamp", `${number}${any}`[]>;
114
+ static rgba(red: number | $mol_style_func<'var'>, green: number | $mol_style_func<'var'>, blue: number | $mol_style_func<'var'>, alpha: number | $mol_style_func<'var'>): $mol_style_func<"rgba", (number | $mol_style_func<"var", unknown>)[]>;
115
+ static scale(zoom: number): $mol_style_func<"scale", number[]>;
116
+ static linear(...breakpoints: Array<number | [number, number | $mol_style_unit_str<'%'>]>): $mol_style_func<"linear", string[]>;
117
+ static cubic_bezier(x1: number, y1: number, x2: number, y2: number): $mol_style_func<"cubic-bezier", number[]>;
118
+ static steps(value: number, step_position: 'jump-start' | 'jump-end' | 'jump-none' | 'jump-both' | 'start' | 'end'): $mol_style_func<"steps", (number | "end" | "start" | "jump-start" | "jump-end" | "jump-none" | "jump-both")[]>;
119
+ static blur(value?: $mol_style_unit_str<$mol_style_unit_length>): $mol_style_func<"blur", string>;
120
+ static brightness(value?: number | $mol_style_unit_str<'%'>): $mol_style_func<"brightness", string | number>;
121
+ static contrast(value?: number | $mol_style_unit_str<'%'>): $mol_style_func<"contrast", string | number>;
122
+ static drop_shadow(color: $mol_style_properties_color, x_offset: $mol_style_unit_str<$mol_style_unit_length>, y_offset: $mol_style_unit_str<$mol_style_unit_length>, blur_radius?: $mol_style_unit_str<$mol_style_unit_length>): $mol_style_func<"drop-shadow", readonly [$mol_style_properties_color, `${number}%` | `${number}px` | `${number}mm` | `${number}cm` | `${number}Q` | `${number}in` | `${number}pc` | `${number}pt` | `${number}cap` | `${number}ch` | `${number}em` | `${number}rem` | `${number}ex` | `${number}ic` | `${number}lh` | `${number}rlh` | `${number}vh` | `${number}vw` | `${number}vi` | `${number}vb` | `${number}vmin` | `${number}vmax`, `${number}%` | `${number}px` | `${number}mm` | `${number}cm` | `${number}Q` | `${number}in` | `${number}pc` | `${number}pt` | `${number}cap` | `${number}ch` | `${number}em` | `${number}rem` | `${number}ex` | `${number}ic` | `${number}lh` | `${number}rlh` | `${number}vh` | `${number}vw` | `${number}vi` | `${number}vb` | `${number}vmin` | `${number}vmax`, `${number}%` | `${number}px` | `${number}mm` | `${number}cm` | `${number}Q` | `${number}in` | `${number}pc` | `${number}pt` | `${number}cap` | `${number}ch` | `${number}em` | `${number}rem` | `${number}ex` | `${number}ic` | `${number}lh` | `${number}rlh` | `${number}vh` | `${number}vw` | `${number}vi` | `${number}vb` | `${number}vmin` | `${number}vmax`] | readonly [$mol_style_properties_color, `${number}%` | `${number}px` | `${number}mm` | `${number}cm` | `${number}Q` | `${number}in` | `${number}pc` | `${number}pt` | `${number}cap` | `${number}ch` | `${number}em` | `${number}rem` | `${number}ex` | `${number}ic` | `${number}lh` | `${number}rlh` | `${number}vh` | `${number}vw` | `${number}vi` | `${number}vb` | `${number}vmin` | `${number}vmax`, `${number}%` | `${number}px` | `${number}mm` | `${number}cm` | `${number}Q` | `${number}in` | `${number}pc` | `${number}pt` | `${number}cap` | `${number}ch` | `${number}em` | `${number}rem` | `${number}ex` | `${number}ic` | `${number}lh` | `${number}rlh` | `${number}vh` | `${number}vw` | `${number}vi` | `${number}vb` | `${number}vmin` | `${number}vmax`]>;
123
+ static grayscale(value?: number | $mol_style_unit_str<'%'>): $mol_style_func<"grayscale", string | number>;
124
+ static hue_rotate(value?: 0 | $mol_style_unit_str<$mol_style_unit_angle>): $mol_style_func<"hue-rotate", string | 0>;
125
+ static invert(value?: number | $mol_style_unit_str<'%'>): $mol_style_func<"invert", string | number>;
126
+ static opacity(value?: number | $mol_style_unit_str<'%'>): $mol_style_func<"opacity", string | number>;
127
+ static sepia(value?: number | $mol_style_unit_str<'%'>): $mol_style_func<"sepia", string | number>;
128
+ static saturate(value?: number | $mol_style_unit_str<'%'>): $mol_style_func<"saturate", string | number>;
129
+ }
130
+ }
131
+
132
+ declare namespace $ {
133
+ type $mol_type_override<Base, Over> = Omit<Base, keyof Over> & Over;
134
+ }
135
+
136
+ declare namespace $ {
137
+ export type $mol_style_properties = Partial<$mol_type_override<CSSStyleDeclaration, Overrides>>;
138
+ type Common = 'inherit' | 'initial' | 'unset' | 'revert' | 'revert-layer' | 'none' | $mol_style_func<'var'>;
139
+ type Portion = `${number}${'%'}` | number;
140
+ type Space = '' | ' ';
141
+ type Var = `var(--${string})`;
142
+ type Calc = `calc(${string})`;
143
+ type Angle = number | `${number}${'deg' | 'turn'}` | Var | Calc | 'none';
144
+ export type $mol_style_properties_color = 'aliceblue' | 'antiquewhite' | 'aqua' | 'aquamarine' | 'azure' | 'beige' | 'bisque' | 'black' | 'blanchedalmond' | 'blue' | 'blueviolet' | 'brown' | 'burlywood' | 'cadetblue' | 'chartreuse' | 'chocolate' | 'coral' | 'cornflowerblue' | 'cornsilk' | 'crimson' | 'cyan' | 'darkblue' | 'darkcyan' | 'darkgoldenrod' | 'darkgray' | 'darkgreen' | 'darkgrey' | 'darkkhaki' | 'darkmagenta' | 'darkolivegreen' | 'darkorange' | 'darkorchid' | 'darkred' | 'darksalmon' | 'darkseagreen' | 'darkslateblue' | 'darkslategrey' | 'darkturquoise' | 'darkviolet' | 'deeppink' | 'deepskyblue' | 'dimgray' | 'dimgrey' | 'dodgerblue' | 'firebrick' | 'floralwhite' | 'forestgreen' | 'fuchsia' | 'gainsboro' | 'ghostwhite' | 'gold' | 'goldenrod' | 'gray' | 'green' | 'greenyellow' | 'grey' | 'honeydew' | 'hotpink' | 'indianred' | 'indigo' | 'ivory' | 'khaki' | 'lavender' | 'lavenderblush' | 'lawngreen' | 'lemonchiffon' | 'lightblue' | 'lightcoral' | 'lightcyan' | 'lightgoldenrodyellow' | 'lightgray' | 'lightgreen' | 'lightgrey' | 'lightpink' | 'lightsalmon' | 'lightseagreen' | 'lightskyblue' | 'lightslategray' | 'lightslategrey' | 'lightsteelblue' | 'lightyellow' | 'lime' | 'limegreen' | 'linen' | 'magenta' | 'maroon' | 'mediumaquamarine' | 'mediumblue' | 'mediumorchid' | 'mediumpurple' | 'mediumseagreen' | 'mediumslateblue' | 'mediumspringgreen' | 'mediumturquoise' | 'mediumvioletred' | 'midnightblue' | 'mintcream' | 'mistyrose' | 'moccasin' | 'navajowhite' | 'navy' | 'oldlace' | 'olive' | 'olivedrab' | 'orange' | 'orangered' | 'orchid' | 'palegoldenrod' | 'palegreen' | 'paleturquoise' | 'palevioletred' | 'papayawhip' | 'peachpuff' | 'peru' | 'pink' | 'plum' | 'powderblue' | 'purple' | 'rebeccapurple' | 'red' | 'rosybrown' | 'royalblue' | 'saddlebrown' | 'salmon' | 'sandybrown' | 'seagreen' | 'seashell' | 'sienna' | 'silver' | 'skyblue' | 'slateblue' | 'slategray' | 'slategrey' | 'snow' | 'springgreen' | 'steelblue' | 'tan' | 'teal' | 'thistle' | 'tomato' | 'turquoise' | 'violet' | 'wheat' | 'white' | 'whitesmoke' | 'yellow' | 'yellowgreen' | 'transparent' | 'currentcolor' | $mol_style_func<'hsla' | 'rgba' | 'var'> | `#${string}` | `hsl(${Space}${Angle} ${Portion} ${Portion}${'' | `${Space}/${Space}${Portion}`}${Space})`;
145
+ type Length = 0 | `${number}${$mol_style_unit_length}` | $mol_style_func<'calc' | 'var' | 'clamp'>;
146
+ type Size = 'auto' | 'max-content' | 'min-content' | 'fit-content' | Length | Common;
147
+ type Directions<Value> = Value | readonly [Value, Value] | {
148
+ top?: Value;
149
+ right?: Value;
150
+ bottom?: Value;
151
+ left?: Value;
152
+ };
153
+ type Single_animation_composition = 'replace' | 'add' | 'accumulate';
154
+ type Single_animation_direction = 'normal' | 'reverse' | 'alternate' | 'alternate-reverse';
155
+ type Single_animation_fill_mode = 'none' | 'forwards' | 'backwards' | 'both';
156
+ type Single_animation_iteration_count = 'infinite' | number;
157
+ type Single_animation_play_state = 'running' | 'paused';
158
+ type Easing_function = Linear_easing_function | Cubic_bezier_easing_function | Step_easing_function;
159
+ type Linear_easing_function = 'linear' | $mol_style_func<'linear'>;
160
+ type Cubic_bezier_easing_function = 'ease' | 'ease-in' | 'ease-out' | 'ease-in-out' | $mol_style_func<'cubic-bezier'>;
161
+ type Step_easing_function = 'step-start' | 'step-end' | $mol_style_func<'steps'>;
162
+ type Compat_auto = 'searchfield' | 'textarea' | 'push-button' | 'slider-horizontal' | 'checkbox' | 'radio' | 'menulist' | 'listbox' | 'meter' | 'progress-bar' | 'button';
163
+ type Compat_special = 'textfield' | 'menulist-button';
164
+ type Mix_blend_mode = Blend_mode | 'plus-darker' | 'plus-lighter';
165
+ type Blend_mode = 'normal' | 'multiply' | 'screen' | 'overlay' | 'darken' | 'lighten' | 'color-dodge' | 'color-burn' | 'hard-light' | 'soft-light' | 'difference' | 'exclusion' | 'hue' | 'saturation' | 'color' | 'luminosity';
166
+ type Box = 'border-box' | 'padding-box' | 'content-box';
167
+ type Baseline_position = 'baseline' | `${'first' | 'last'} baseline`;
168
+ type Content_distribution = 'space-between' | 'space-around' | 'space-evenly' | 'stretch';
169
+ type Self_position = 'center' | 'start' | 'end' | 'self-start' | 'self-end' | 'flex-start' | 'flex-end';
170
+ type Content_position = 'center' | 'start' | 'end' | 'flex-start' | 'flex-end';
171
+ type Span_align = 'none' | 'start' | 'end' | 'center' | $mol_style_func<'var'>;
172
+ type Snap_axis = 'x' | 'y' | 'block' | 'inline' | 'both' | $mol_style_func<'var'>;
173
+ type Overflow = 'visible' | 'hidden' | 'clip' | 'scroll' | 'auto' | 'overlay' | Common;
174
+ type Overflow_position = 'unsafe' | 'safe';
175
+ type ContainRule = 'size' | 'layout' | 'style' | 'paint' | $mol_style_func<'var'>;
176
+ type Repeat = 'repeat-x' | 'repeat-y' | 'repeat' | 'space' | 'round' | 'no-repeat' | $mol_style_func<'var'>;
177
+ type BG_size = Length | 'auto' | 'contain' | 'cover';
178
+ interface Overrides {
179
+ accentColor?: $mol_style_properties_color | Common;
180
+ align?: {
181
+ content?: 'normal' | Baseline_position | Content_distribution | Content_position | `${Overflow_position} ${Content_position}` | Common;
182
+ items?: 'normal' | 'stretch' | Baseline_position | Self_position | `${Overflow_position} ${Self_position}` | Common;
183
+ self?: 'auto' | 'normal' | 'stretch' | Baseline_position | Self_position | `${Overflow_position} ${Self_position}` | Common;
184
+ };
185
+ justify?: {
186
+ content?: 'normal' | Baseline_position | Content_distribution | Content_position | `${Overflow_position} ${Content_position}` | Common;
187
+ items?: 'normal' | 'stretch' | Baseline_position | Self_position | `${Overflow_position} ${Self_position}` | Common;
188
+ self?: 'auto' | 'normal' | 'stretch' | Baseline_position | Self_position | `${Overflow_position} ${Self_position}` | Common;
189
+ };
190
+ all?: Common;
191
+ animation?: {
192
+ composition?: Single_animation_composition | Single_animation_composition[][] | Common;
193
+ delay?: $mol_style_unit_str<$mol_style_unit_time> | $mol_style_unit_str<$mol_style_unit_time>[][] | Common;
194
+ direction?: Single_animation_direction | Single_animation_direction[][] | Common;
195
+ duration?: $mol_style_unit_str<$mol_style_unit_time> | $mol_style_unit_str<$mol_style_unit_time>[][] | Common;
196
+ fillMode?: Single_animation_fill_mode | Single_animation_fill_mode[][] | Common;
197
+ iterationCount?: Single_animation_iteration_count | Single_animation_iteration_count[][] | Common;
198
+ name?: 'none' | string & {} | ('none' | string & {})[][] | Common;
199
+ playState?: Single_animation_play_state | Single_animation_play_state[][] | Common;
200
+ timingFunction?: Easing_function | Easing_function[][] | Common;
201
+ };
202
+ appearance?: 'none' | 'auto' | Compat_auto | Compat_special | Common;
203
+ aspectRatio?: 'auto' | number | `${number} / ${number}`;
204
+ backdropFilter: $mol_style_func<$mol_style_func_filter> | $mol_style_func<'url'> | ($mol_style_func<$mol_style_func_filter> | $mol_style_func<'url'>)[][] | 'none' | Common;
205
+ backfaceVisibility: 'visible' | 'hidden' | Common;
206
+ justifyContent?: 'start' | 'end' | 'flex-start' | 'flex-end' | 'left' | 'right' | 'space-between' | 'space-around' | 'space-evenly' | 'normal' | 'stretch' | 'center' | Common;
207
+ gap?: Length | readonly [Length, Length] | Common;
208
+ background?: 'none' | {
209
+ attachment?: 'scroll' | 'fixed' | 'local' | ('scroll' | 'fixed' | 'local')[][] | Common;
210
+ blendMode?: Mix_blend_mode | Mix_blend_mode[][] | Common;
211
+ clip?: Box | Box[][] | Common;
212
+ color?: $mol_style_properties_color | Common;
213
+ image?: readonly (readonly [$mol_style_func<$mol_style_func_image> | string & {}])[] | 'none' | Common;
214
+ repeat?: Repeat | [Repeat, Repeat] | Common;
215
+ position?: 'left' | 'right' | 'top' | 'bottom' | 'center' | Common;
216
+ size?: (BG_size | [BG_size] | [BG_size, BG_size])[];
217
+ };
218
+ box?: {
219
+ shadow?: readonly ([
220
+ ...[inset: 'inset'] | [],
221
+ x: Length,
222
+ y: Length,
223
+ blur: Length,
224
+ spread: Length,
225
+ color: $mol_style_properties_color
226
+ ] | {
227
+ inset?: boolean;
228
+ x: Length;
229
+ y: Length;
230
+ blur: Length;
231
+ spread: Length;
232
+ color: $mol_style_properties_color;
233
+ })[] | 'none' | Common;
234
+ };
235
+ rx?: Length | Common;
236
+ ry?: Length | Common;
237
+ font?: {
238
+ style?: 'normal' | 'italic' | Common;
239
+ weight?: 'normal' | 'bold' | 'lighter' | 'bolder' | 100 | 200 | 300 | 400 | 500 | 600 | 700 | 800 | 900 | Common;
240
+ size?: 'xx-small' | 'x-small' | 'small' | 'medium' | 'large' | 'x-large' | 'xx-large' | 'xxx-large' | 'smaller' | 'larger' | Length | Common;
241
+ family?: string & {} | 'serif' | 'sans-serif' | 'monospace' | 'cursive' | 'fantasy' | 'system-ui' | 'ui-serif' | 'ui-sans-serif' | 'ui-monospace' | 'ui-rounded' | 'emoji' | 'math' | 'fangsong' | Common;
242
+ };
243
+ color?: $mol_style_properties_color | Common;
244
+ display?: 'block' | 'inline' | 'run-in' | 'list-item' | 'none' | 'flow' | 'flow-root' | 'table' | 'flex' | 'grid' | 'contents' | 'table-row-group' | 'table-header-group' | 'table-footer-group' | 'table-column-group' | 'table-row' | 'table-cell' | 'table-column' | 'table-caption' | 'inline-block' | 'inline-table' | 'inline-flex' | 'inline-grid' | 'ruby' | 'ruby-base' | 'ruby-text' | 'ruby-base-container' | 'ruby-text-container' | Common;
245
+ overflow?: Overflow | {
246
+ x?: Overflow | Common;
247
+ y?: Overflow | Common;
248
+ anchor?: 'auto' | 'none' | Common;
249
+ };
250
+ contain?: 'none' | 'strict' | 'content' | ContainRule | readonly ContainRule[] | Common;
251
+ whiteSpace?: 'normal' | 'nowrap' | 'break-spaces' | 'pre' | 'pre-wrap' | 'pre-line' | Common;
252
+ webkitOverflowScrolling?: 'auto' | 'touch' | Common;
253
+ scrollbar?: {
254
+ color?: readonly [$mol_style_properties_color, $mol_style_properties_color] | 'auto' | Common;
255
+ width?: 'auto' | 'thin' | 'none' | Common;
256
+ };
257
+ scroll?: {
258
+ snap?: {
259
+ type: 'none' | Snap_axis | readonly [Snap_axis, 'mandatory' | 'proximity'] | Common;
260
+ stop: 'normal' | 'always' | Common;
261
+ align: Span_align | readonly [Span_align, Span_align] | Common;
262
+ };
263
+ padding?: Directions<Length | 'auto'>;
264
+ };
265
+ width?: Size;
266
+ minWidth?: Size;
267
+ maxWidth?: Size;
268
+ height?: Size;
269
+ minHeight?: Size;
270
+ maxHeight?: Size;
271
+ margin?: Directions<Length | 'auto'>;
272
+ padding?: Directions<Length | 'auto'>;
273
+ position?: 'static' | 'relative' | 'absolute' | 'sticky' | 'fixed' | Common;
274
+ top?: Length | 'auto' | Common;
275
+ right?: Length | 'auto' | Common;
276
+ bottom?: Length | 'auto' | Common;
277
+ left?: Length | 'auto' | Common;
278
+ border?: Directions<{
279
+ radius?: Length | [Length, Length];
280
+ style?: 'none' | 'hidden' | 'dotted' | 'dashed' | 'solid' | 'double' | 'groove' | 'ridge' | 'inset' | 'outset' | Common;
281
+ color?: $mol_style_properties_color | Common;
282
+ width?: Length | Common;
283
+ }>;
284
+ flex?: 'none' | 'auto' | {
285
+ grow?: number | Common;
286
+ shrink?: number | Common;
287
+ basis?: Size | Common;
288
+ direction?: 'row' | 'row-reverse' | 'column' | 'column-reverse' | Common;
289
+ wrap?: 'wrap' | 'nowrap' | 'wrap-reverse' | Common;
290
+ };
291
+ container?: {
292
+ name?: string;
293
+ type?: Container_type | readonly Container_type[];
294
+ };
295
+ zIndex: number | Common;
296
+ opacity: number | Common;
297
+ }
298
+ type Container_type = 'normal' | 'size' | 'inline-size' | 'scroll-state' | 'anchored';
299
+ export {};
300
+ }
301
+
302
+ declare namespace $ {
303
+ function $mol_style_prop<Keys extends string[]>(prefix: string, keys: Keys): Record<Keys[number], $mol_style_func<"var", unknown>>;
304
+ }
305
+
306
+ declare namespace $ {
307
+ const $mol_theme: Record<"image" | "line" | "text" | "hue" | "back" | "hover" | "card" | "current" | "special" | "control" | "shade" | "focus" | "field" | "spirit" | "hue_spread", $mol_style_func<"var", unknown>>;
308
+ }
309
+
310
+ declare namespace $ {
311
+ }
312
+
313
+ declare namespace $ {
314
+ let $mol_gap: Record<"text" | "blur" | "page" | "block" | "space" | "round" | "emoji", $mol_style_func<"var", unknown>>;
315
+ }
316
+
317
+ declare namespace $ {
318
+ }
319
+
320
+ declare namespace $ {
321
+ function $mol_fail(error: any): never;
322
+ }
323
+
324
+ declare namespace $ {
325
+ function $mol_func_name(this: $, func: Function): string;
326
+ function $mol_func_name_from<Target extends Function>(target: Target, source: Function): Target;
327
+ }
328
+
329
+ declare namespace $ {
330
+ function $mol_dom_render_children(el: Element | DocumentFragment, childNodes: NodeList | Array<Node | string | null>): void;
331
+ }
332
+
333
+ declare namespace $ {
334
+ type $mol_type_partial_deep<Val> = Val extends object ? Val extends Function ? Val : {
335
+ [field in keyof Val]?: $mol_type_partial_deep<Val[field]> | undefined;
336
+ } : Val;
337
+ }
338
+
339
+ declare namespace $ {
340
+ let $mol_jsx_prefix: string;
341
+ let $mol_jsx_crumbs: string;
342
+ let $mol_jsx_booked: null | Set<string>;
343
+ let $mol_jsx_document: $mol_jsx.JSX.ElementClass['ownerDocument'];
344
+ const $mol_jsx_frag = "";
345
+ function $mol_jsx<Props extends $mol_jsx.JSX.IntrinsicAttributes, Children extends Array<Node | string>>(Elem: string | ((props: Props, ...children: Children) => Element), props: Props, ...childNodes: Children): Element | DocumentFragment;
346
+ namespace $mol_jsx.JSX {
347
+ interface Element extends HTMLElement {
348
+ class?: string;
349
+ }
350
+ interface ElementClass {
351
+ attributes: {};
352
+ ownerDocument: Pick<Document, 'getElementById' | 'createElementNS' | 'createDocumentFragment'>;
353
+ childNodes: Array<Node | string>;
354
+ valueOf(): Element;
355
+ }
356
+ type OrString<Dict> = {
357
+ [key in keyof Dict]: Dict[key] | string;
358
+ };
359
+ type IntrinsicElements = {
360
+ [key in keyof ElementTagNameMap]?: $.$mol_type_partial_deep<OrString<Element & IntrinsicAttributes & ElementTagNameMap[key]>>;
361
+ };
362
+ interface IntrinsicAttributes {
363
+ id?: string;
364
+ xmlns?: string;
365
+ }
366
+ interface ElementAttributesProperty {
367
+ attributes: {};
368
+ }
369
+ interface ElementChildrenAttribute {
370
+ }
371
+ }
372
+ }
373
+
374
+ declare namespace $ {
375
+ const $mol_ambient_ref: unique symbol;
376
+ type $mol_ambient_context = $;
377
+ function $mol_ambient(this: $ | void, overrides: Partial<$>): $;
378
+ }
379
+
380
+ declare namespace $ {
381
+ function $mol_delegate<Value extends object>(proto: Value, target: () => Value): Value;
382
+ }
383
+
384
+ declare namespace $ {
385
+ const $mol_owning_map: WeakMap<any, any>;
386
+ function $mol_owning_allow<Having>(having: Having): having is Having & {
387
+ destructor(): void;
388
+ };
389
+ function $mol_owning_get<Having, Owner extends object>(having: Having, Owner?: {
390
+ new (): Owner;
391
+ }): Owner | null;
392
+ function $mol_owning_check<Owner, Having>(owner: Owner, having: Having): having is Having & {
393
+ destructor(): void;
394
+ };
395
+ function $mol_owning_catch<Owner, Having>(owner: Owner, having: Having): boolean;
396
+ }
397
+
398
+ declare namespace $ {
399
+ function $mol_fail_hidden(error: any): never;
400
+ }
401
+
402
+ declare namespace $ {
403
+ type $mol_type_writable<T> = {
404
+ -readonly [P in keyof T]: T[P];
405
+ };
406
+ }
407
+
408
+ declare namespace $ {
409
+ const $mol_key_handle: unique symbol;
410
+ const $mol_key_store: WeakMap<object, string>;
411
+ }
412
+
413
+ declare namespace $ {
414
+ class $mol_object2 {
415
+ static $: $;
416
+ [Symbol.toStringTag]: string;
417
+ [$mol_ambient_ref]: $;
418
+ get $(): $;
419
+ set $(next: $);
420
+ static create<Instance>(this: new (init?: (instance: any) => void) => Instance, init?: (instance: $mol_type_writable<Instance>) => void): Instance;
421
+ static [Symbol.toPrimitive](): any;
422
+ static toString(): any;
423
+ static toJSON(): any;
424
+ static [$mol_key_handle](): any;
425
+ destructor(): void;
426
+ static destructor(): void;
427
+ [Symbol.dispose](): void;
428
+ toString(): string;
429
+ }
430
+ }
431
+
432
+ declare namespace $ {
433
+ namespace $$ { }
434
+ const $mol_object_field: unique symbol;
435
+ class $mol_object extends $mol_object2 {
436
+ static make<This extends typeof $mol_object>(this: This, config: Partial<InstanceType<This>>): InstanceType<This>;
437
+ }
438
+ }
439
+
440
+ declare namespace $ {
441
+ function $mol_guid(length?: number, exists?: (id: string) => boolean): string;
442
+ }
443
+
444
+ declare namespace $ {
445
+ enum $mol_wire_cursor {
446
+ stale = -1,
447
+ doubt = -2,
448
+ fresh = -3,
449
+ final = -4
450
+ }
451
+ }
452
+
453
+ declare namespace $ {
454
+ class $mol_wire_pub extends Object {
455
+ constructor(id?: string);
456
+ [Symbol.toStringTag]: string;
457
+ data: unknown[];
458
+ static get [Symbol.species](): ArrayConstructor;
459
+ protected sub_from: number;
460
+ get sub_list(): readonly $mol_wire_sub[];
461
+ get sub_empty(): boolean;
462
+ sub_on(sub: $mol_wire_pub, pub_pos: number): number;
463
+ sub_off(sub_pos: number): void;
464
+ reap(): void;
465
+ promote(): void;
466
+ fresh(): void;
467
+ complete(): void;
468
+ get incompleted(): boolean;
469
+ emit(quant?: $mol_wire_cursor): void;
470
+ peer_move(from_pos: number, to_pos: number): void;
471
+ peer_repos(peer_pos: number, self_pos: number): void;
472
+ }
473
+ }
474
+
475
+ declare namespace $ {
476
+ interface $mol_wire_sub extends $mol_wire_pub {
477
+ temp: boolean;
478
+ pub_list: $mol_wire_pub[];
479
+ track_on(): $mol_wire_sub | null;
480
+ track_next(pub?: $mol_wire_pub): $mol_wire_pub | null;
481
+ pub_off(pub_pos: number): void;
482
+ track_cut(sub: $mol_wire_pub | null): void;
483
+ track_off(sub: $mol_wire_pub | null): void;
484
+ absorb(quant: $mol_wire_cursor, pos: number): void;
485
+ destructor(): void;
486
+ }
487
+ }
488
+
489
+ declare namespace $ {
490
+ let $mol_wire_auto_sub: $mol_wire_sub | null;
491
+ function $mol_wire_auto(next?: $mol_wire_sub | null): $mol_wire_sub | null;
492
+ const $mol_wire_affected: ($mol_wire_sub | number)[];
493
+ }
494
+
495
+ declare namespace $ {
496
+ function $mol_dev_format_register(config: {
497
+ header: (val: any, config: any) => any;
498
+ hasBody: (val: any, config: any) => false;
499
+ } | {
500
+ header: (val: any, config: any) => any;
501
+ hasBody: (val: any, config: any) => boolean;
502
+ body: (val: any, config: any) => any;
503
+ }): void;
504
+ const $mol_dev_format_head: unique symbol;
505
+ const $mol_dev_format_body: unique symbol;
506
+ function $mol_dev_format_native(obj: any): any[];
507
+ function $mol_dev_format_auto(obj: any): any[];
508
+ function $mol_dev_format_element(element: string, style: object, ...content: any[]): any[];
509
+ let $mol_dev_format_span: (style: object, ...content: any[]) => any[];
510
+ let $mol_dev_format_div: (style: object, ...content: any[]) => any[];
511
+ let $mol_dev_format_ol: (style: object, ...content: any[]) => any[];
512
+ let $mol_dev_format_li: (style: object, ...content: any[]) => any[];
513
+ let $mol_dev_format_table: (style: object, ...content: any[]) => any[];
514
+ let $mol_dev_format_tr: (style: object, ...content: any[]) => any[];
515
+ let $mol_dev_format_td: (style: object, ...content: any[]) => any[];
516
+ let $mol_dev_format_accent: (...args: any[]) => any[];
517
+ let $mol_dev_format_strong: (...args: any[]) => any[];
518
+ let $mol_dev_format_string: (...args: any[]) => any[];
519
+ let $mol_dev_format_shade: (...args: any[]) => any[];
520
+ let $mol_dev_format_indent: (...args: any[]) => any[];
521
+ }
522
+
523
+ declare namespace $ {
524
+ class $mol_wire_pub_sub extends $mol_wire_pub implements $mol_wire_sub {
525
+ protected pub_from: number;
526
+ protected cursor: $mol_wire_cursor;
527
+ get temp(): boolean;
528
+ get pub_list(): $mol_wire_pub[];
529
+ track_on(): $mol_wire_sub | null;
530
+ promote(): void;
531
+ track_next(pub?: $mol_wire_pub): $mol_wire_pub | null;
532
+ track_off(sub: $mol_wire_sub | null): void;
533
+ pub_off(sub_pos: number): void;
534
+ destructor(): void;
535
+ track_cut(): void;
536
+ complete(): void;
537
+ complete_pubs(): void;
538
+ absorb(quant?: $mol_wire_cursor, pos?: number): void;
539
+ [$mol_dev_format_head](): any[];
540
+ get pub_empty(): boolean;
541
+ }
542
+ }
543
+
544
+ declare namespace $ {
545
+ class $mol_after_tick extends $mol_object2 {
546
+ task: () => void;
547
+ static promise: Promise<void> | null;
548
+ cancelled: boolean;
549
+ constructor(task: () => void);
550
+ destructor(): void;
551
+ }
552
+ }
553
+
554
+ declare namespace $ {
555
+ function $mol_promise_like(val: any): val is Promise<any>;
556
+ }
557
+
558
+ declare namespace $ {
559
+ abstract class $mol_wire_fiber<Host, Args extends readonly unknown[], Result> extends $mol_wire_pub_sub {
560
+ readonly task: (this: Host, ...args: Args) => Result;
561
+ readonly host?: Host | undefined;
562
+ static warm: boolean;
563
+ static planning: Set<$mol_wire_fiber<any, any, any>>;
564
+ static reaping: Set<$mol_wire_fiber<any, any, any>>;
565
+ static plan_task: $mol_after_tick | null;
566
+ static plan(): void;
567
+ static sync(): void;
568
+ cache: Result | Error | Promise<Result | Error>;
569
+ get args(): Args;
570
+ result(): Result | undefined;
571
+ get incompleted(): boolean;
572
+ field(): string;
573
+ constructor(id: string, task: (this: Host, ...args: Args) => Result, host?: Host | undefined, args?: Args);
574
+ plan(): this;
575
+ reap(): void;
576
+ toString(): string;
577
+ toJSON(): string;
578
+ [$mol_dev_format_head](): any[];
579
+ [$mol_dev_format_body](): null;
580
+ get $(): any;
581
+ emit(quant?: $mol_wire_cursor): void;
582
+ fresh(): this | undefined;
583
+ refresh(): void;
584
+ abstract put(next: Result | Error | Promise<Result | Error>): Result | Error | Promise<Result | Error>;
585
+ sync(): Awaited<Result>;
586
+ async_raw(): Promise<Result>;
587
+ async(): Promise<Result> & {
588
+ destructor(): void;
589
+ };
590
+ step(): Promise<null>;
591
+ destructor(): void;
592
+ }
593
+ }
594
+
595
+ declare namespace $ {
596
+ function $mol_key<Value>(value: Value): string;
597
+ }
598
+
599
+ declare namespace $ {
600
+ class $mol_after_frame extends $mol_object2 {
601
+ task: () => void;
602
+ static _promise: Promise<void> | null;
603
+ static get promise(): Promise<void>;
604
+ cancelled: boolean;
605
+ promise: Promise<void>;
606
+ constructor(task: () => void);
607
+ destructor(): void;
608
+ }
609
+ }
610
+
611
+ declare namespace $ {
612
+ let $mol_compare_deep_cache: WeakMap<any, WeakMap<any, boolean>>;
613
+ function $mol_compare_deep<Value>(left: Value, right: Value): boolean;
614
+ }
615
+
616
+ declare namespace $ {
617
+ type $mol_log3_event<Fields> = {
618
+ [key in string]: unknown;
619
+ } & {
620
+ time?: string;
621
+ place: unknown;
622
+ message: string;
623
+ } & Fields;
624
+ type $mol_log3_logger<Fields, Res = void> = (this: $, event: $mol_log3_event<Fields>) => Res;
625
+ let $mol_log3_come: $mol_log3_logger<{}>;
626
+ let $mol_log3_done: $mol_log3_logger<{}>;
627
+ let $mol_log3_fail: $mol_log3_logger<{}>;
628
+ let $mol_log3_warn: $mol_log3_logger<{
629
+ hint: string;
630
+ }>;
631
+ let $mol_log3_rise: $mol_log3_logger<{}>;
632
+ let $mol_log3_area: $mol_log3_logger<{}, () => void>;
633
+ function $mol_log3_area_lazy(this: $, event: $mol_log3_event<{}>): () => void;
634
+ let $mol_log3_stack: (() => void)[];
635
+ }
636
+
637
+ declare namespace $ {
638
+ type $mol_type_keys_extract<Input, Upper, Lower = never> = {
639
+ [Field in keyof Input]: unknown extends Input[Field] ? never : Input[Field] extends never ? never : Input[Field] extends Upper ? [
640
+ Lower
641
+ ] extends [Input[Field]] ? Field : never : never;
642
+ }[keyof Input];
643
+ }
644
+
645
+ declare namespace $ {
646
+ function $mol_log3_web_make(level: $mol_type_keys_extract<Console, Function>, color: string): (this: $, event: $mol_log3_event<{}>) => () => void;
647
+ }
648
+
649
+ declare namespace $ {
650
+ class $mol_wire_task<Host, Args extends readonly unknown[], Result> extends $mol_wire_fiber<Host, Args, Result> {
651
+ static getter<Host, Args extends readonly unknown[], Result>(task: (this: Host, ...args: Args) => Result): (host: Host, args: Args) => $mol_wire_task<Host, Args, Result>;
652
+ get temp(): boolean;
653
+ complete(): void;
654
+ put(next: Result | Error | Promise<Result | Error>): Error | Result | Promise<Error | Result>;
655
+ destructor(): void;
656
+ }
657
+ }
658
+
659
+ declare namespace $ {
660
+ function $mol_wire_method<Host extends object, Args extends readonly any[]>(host: Host, field: PropertyKey, descr?: TypedPropertyDescriptor<(...args: Args) => any>): {
661
+ value: (this: Host, ...args: Args) => any;
662
+ enumerable?: boolean;
663
+ configurable?: boolean;
664
+ writable?: boolean;
665
+ get?: (() => (...args: Args) => any) | undefined;
666
+ set?: ((value: (...args: Args) => any) => void) | undefined;
667
+ };
668
+ }
669
+
670
+ declare namespace $ {
671
+ type $mol_type_tail<Tuple extends readonly any[]> = ((...tail: Tuple) => any) extends ((head: any, ...tail: infer Tail) => any) ? Tail : never;
672
+ }
673
+
674
+ declare namespace $ {
675
+ type $mol_type_foot<Tuple extends readonly any[]> = Tuple['length'] extends 0 ? never : Tuple[$mol_type_tail<Tuple>['length']];
676
+ }
677
+
678
+ declare namespace $ {
679
+ function $mol_fail_catch(error: unknown): boolean;
680
+ }
681
+
682
+ declare namespace $ {
683
+ function $mol_try<Result>(handler: () => Result): Result | Error;
684
+ }
685
+
686
+ declare namespace $ {
687
+ function $mol_try_web<Result>(handler2: () => Result): Result | Error;
688
+ }
689
+
690
+ declare namespace $ {
691
+ function $mol_fail_log(error: unknown): boolean;
692
+ }
693
+
694
+ declare namespace $ {
695
+ class $mol_wire_atom<Host, Args extends readonly unknown[], Result> extends $mol_wire_fiber<Host, Args, Result> {
696
+ static solo<Host, Args extends readonly unknown[], Result>(host: Host, task: (this: Host, ...args: Args) => Result): $mol_wire_atom<Host, Args, Result>;
697
+ static plex<Host, Args extends readonly unknown[], Result>(host: Host, task: (this: Host, ...args: Args) => Result, key: Args[0]): $mol_wire_atom<Host, Args, Result>;
698
+ static watching: Set<$mol_wire_atom<any, any, any>>;
699
+ static watcher: $mol_after_frame | null;
700
+ static watch(): void;
701
+ watch(): void;
702
+ resync(args: Args): Error | Result | Promise<Error | Result>;
703
+ once(): Awaited<Result>;
704
+ channel(): ((next?: $mol_type_foot<Args>) => Awaited<Result>) & {
705
+ atom: $mol_wire_atom<Host, Args, Result>;
706
+ };
707
+ destructor(): void;
708
+ put(next: Result | Error | Promise<Result | Error>): Error | Result | Promise<Error | Result>;
709
+ }
710
+ }
711
+
712
+ declare namespace $ {
713
+ export function $mol_wire_solo<Args extends any[]>(host: object, field: string, descr?: TypedPropertyDescriptor<(...args: Args) => any>): TypedPropertyDescriptor<(...args: First_optional<Args>) => any>;
714
+ type First_optional<Args extends any[]> = Args extends [] ? [] : [Args[0] | undefined, ...$mol_type_tail<Args>];
715
+ export {};
716
+ }
717
+
718
+ declare namespace $ {
719
+ function $mol_wire_plex<Args extends [any, ...any[]]>(host: object, field: string, descr?: TypedPropertyDescriptor<(...args: Args) => any>): {
720
+ value: (this: typeof host, ...args: Args) => any;
721
+ enumerable?: boolean;
722
+ configurable?: boolean;
723
+ writable?: boolean;
724
+ get?: (() => (...args: Args) => any) | undefined;
725
+ set?: ((value: (...args: Args) => any) => void) | undefined;
726
+ };
727
+ }
728
+
729
+ declare namespace $ {
730
+ let $mol_mem: typeof $mol_wire_solo;
731
+ let $mol_mem_key: typeof $mol_wire_plex;
732
+ }
733
+
734
+ declare namespace $ {
735
+ class $mol_window extends $mol_object {
736
+ static size(): {
737
+ width: number;
738
+ height: number;
739
+ };
740
+ static resizes(next?: Event): Event | undefined;
741
+ }
742
+ }
743
+
744
+ declare namespace $ {
745
+ function $mol_guard_defined<T>(value: T): value is NonNullable<T>;
746
+ }
747
+
748
+ declare namespace $ {
749
+ class $mol_view_selection extends $mol_object {
750
+ static focused(next?: Element[], notify?: 'notify'): Element[];
751
+ }
752
+ }
753
+
754
+ declare namespace $ {
755
+ function $mol_maybe<Value>(value: Value | null | undefined): Value[];
756
+ }
757
+
758
+ declare namespace $ {
759
+ enum $mol_keyboard_code {
760
+ backspace = 8,
761
+ tab = 9,
762
+ enter = 13,
763
+ shift = 16,
764
+ ctrl = 17,
765
+ alt = 18,
766
+ pause = 19,
767
+ capsLock = 20,
768
+ escape = 27,
769
+ space = 32,
770
+ pageUp = 33,
771
+ pageDown = 34,
772
+ end = 35,
773
+ home = 36,
774
+ left = 37,
775
+ up = 38,
776
+ right = 39,
777
+ down = 40,
778
+ insert = 45,
779
+ delete = 46,
780
+ key0 = 48,
781
+ key1 = 49,
782
+ key2 = 50,
783
+ key3 = 51,
784
+ key4 = 52,
785
+ key5 = 53,
786
+ key6 = 54,
787
+ key7 = 55,
788
+ key8 = 56,
789
+ key9 = 57,
790
+ A = 65,
791
+ B = 66,
792
+ C = 67,
793
+ D = 68,
794
+ E = 69,
795
+ F = 70,
796
+ G = 71,
797
+ H = 72,
798
+ I = 73,
799
+ J = 74,
800
+ K = 75,
801
+ L = 76,
802
+ M = 77,
803
+ N = 78,
804
+ O = 79,
805
+ P = 80,
806
+ Q = 81,
807
+ R = 82,
808
+ S = 83,
809
+ T = 84,
810
+ U = 85,
811
+ V = 86,
812
+ W = 87,
813
+ X = 88,
814
+ Y = 89,
815
+ Z = 90,
816
+ metaLeft = 91,
817
+ metaRight = 92,
818
+ select = 93,
819
+ numpad0 = 96,
820
+ numpad1 = 97,
821
+ numpad2 = 98,
822
+ numpad3 = 99,
823
+ numpad4 = 100,
824
+ numpad5 = 101,
825
+ numpad6 = 102,
826
+ numpad7 = 103,
827
+ numpad8 = 104,
828
+ numpad9 = 105,
829
+ multiply = 106,
830
+ add = 107,
831
+ subtract = 109,
832
+ decimal = 110,
833
+ divide = 111,
834
+ F1 = 112,
835
+ F2 = 113,
836
+ F3 = 114,
837
+ F4 = 115,
838
+ F5 = 116,
839
+ F6 = 117,
840
+ F7 = 118,
841
+ F8 = 119,
842
+ F9 = 120,
843
+ F10 = 121,
844
+ F11 = 122,
845
+ F12 = 123,
846
+ numLock = 144,
847
+ scrollLock = 145,
848
+ semicolon = 186,
849
+ equals = 187,
850
+ comma = 188,
851
+ dash = 189,
852
+ period = 190,
853
+ forwardSlash = 191,
854
+ graveAccent = 192,
855
+ bracketOpen = 219,
856
+ slashBack = 220,
857
+ slashBackLeft = 226,
858
+ bracketClose = 221,
859
+ quoteSingle = 222
860
+ }
861
+ }
862
+
863
+ declare namespace $ {
864
+ }
865
+
866
+ declare namespace $ {
867
+ class $mol_wrapper extends $mol_object2 {
868
+ static wrap: (task: (...ags: any[]) => any) => (...ags: any[]) => any;
869
+ static run<Result>(task: () => Result): Result;
870
+ static func<Args extends any[], Result, Host = void>(func: (this: Host, ...args: Args) => Result): (this: Host, ...args: Args) => Result;
871
+ static get class(): <Class extends new (...args: any[]) => any>(Class: Class) => Class;
872
+ static get method(): (obj: object, name: PropertyKey, descr?: TypedPropertyDescriptor<any>) => TypedPropertyDescriptor<any>;
873
+ static get field(): <Host extends object, Field extends keyof Host, Args extends any[], Result>(obj: Host, name: Field, descr?: TypedPropertyDescriptor<Result>) => TypedPropertyDescriptor<Result>;
874
+ }
875
+ }
876
+
877
+ declare namespace $ {
878
+ class $mol_memo extends $mol_wrapper {
879
+ static wrap<This extends object, Value>(task: (this: This, next?: Value) => Value): (this: This, next?: Value) => Value | undefined;
880
+ }
881
+ }
882
+
883
+ declare namespace $ {
884
+ function $mol_dom_qname(name: string): string;
885
+ }
886
+
887
+ declare namespace $ {
888
+ function $mol_wire_probe<Value>(task: () => Value, def?: Value): Value | undefined;
889
+ }
890
+
891
+ declare namespace $ {
892
+ function $mol_wire_watch(): void;
893
+ }
894
+
895
+ declare namespace $ {
896
+ function $mol_const<Value>(value: Value): {
897
+ (): Value;
898
+ '()': Value;
899
+ };
900
+ }
901
+
902
+ declare namespace $ {
903
+ function $mol_wire_solid(): void;
904
+ }
905
+
906
+ declare namespace $ {
907
+ function $mol_dom_render_attributes(el: Element, attrs: {
908
+ [key: string]: string | number | boolean | null;
909
+ }): void;
910
+ }
911
+
912
+ declare namespace $ {
913
+ function $mol_dom_render_events(el: Element, events: {
914
+ [key: string]: (event: Event) => any;
915
+ }, passive?: boolean): void;
916
+ }
917
+
918
+ declare namespace $ {
919
+ function $mol_error_message(this: $, error: unknown): string;
920
+ }
921
+
922
+ declare namespace $ {
923
+ function $mol_dom_render_styles(el: Element, styles: {
924
+ [key: string]: string | number;
925
+ }): void;
926
+ }
927
+
928
+ declare namespace $ {
929
+ function $mol_dom_render_fields(el: Element, fields: {
930
+ [key: string]: any;
931
+ }): void;
932
+ }
933
+
934
+ declare namespace $ {
935
+ export function $mol_wire_async<Host extends object>(obj: Host): ObjectOrFunctionResultPromisify<Host>;
936
+ type FunctionResultPromisify<Some> = Some extends (...args: infer Args) => infer Res ? Res extends PromiseLike<unknown> ? Some : (...args: Args) => Promise<Res> : Some;
937
+ type MethodsResultPromisify<Host extends Object> = {
938
+ [K in keyof Host]: FunctionResultPromisify<Host[K]>;
939
+ };
940
+ type ObjectOrFunctionResultPromisify<Some> = (Some extends (...args: any) => unknown ? FunctionResultPromisify<Some> : {}) & (Some extends Object ? MethodsResultPromisify<Some> : Some);
941
+ export {};
942
+ }
943
+
944
+ declare namespace $ {
945
+ class $mol_after_timeout extends $mol_object2 {
946
+ delay: number;
947
+ task: () => void;
948
+ id: any;
949
+ constructor(delay: number, task: () => void);
950
+ destructor(): void;
951
+ }
952
+ }
953
+
954
+ declare namespace $ {
955
+ type $mol_type_pick<Input, Upper> = Pick<Input, $mol_type_keys_extract<Input, Upper>>;
956
+ }
957
+
958
+ declare namespace $ {
959
+ }
960
+
961
+ declare namespace $ {
962
+ type $mol_view_content = $mol_view | Node | string | number | boolean | null;
963
+ function $mol_view_visible_width(): number;
964
+ function $mol_view_visible_height(): number;
965
+ function $mol_view_state_key(suffix: string): string;
966
+ class $mol_view extends $mol_object {
967
+ static Root<This extends typeof $mol_view>(this: This, id: number): InstanceType<This>;
968
+ static roots(): $mol_view[];
969
+ static auto(): void;
970
+ title(): string;
971
+ hint(): string;
972
+ focused(next?: boolean): boolean;
973
+ state_key(suffix?: string): string;
974
+ dom_name(): string;
975
+ dom_name_space(): string;
976
+ sub(): readonly $mol_view_content[];
977
+ sub_visible(): readonly $mol_view_content[];
978
+ minimal_width(): number;
979
+ maximal_width(): number;
980
+ minimal_height(): number;
981
+ static watchers: Set<$mol_view>;
982
+ view_rect(): {
983
+ width: number;
984
+ height: number;
985
+ left: number;
986
+ right: number;
987
+ top: number;
988
+ bottom: number;
989
+ } | null;
990
+ dom_id(): string;
991
+ dom_node_external(next?: Element): Element;
992
+ dom_node(next?: Element): Element;
993
+ dom_final(): Element | undefined;
994
+ dom_tree(next?: Element): Element;
995
+ dom_node_actual(): Element;
996
+ auto(): any;
997
+ render(): void;
998
+ static view_classes(): (typeof $mol_view)[];
999
+ static _view_names?: Map<string, string[]>;
1000
+ static view_names(suffix: string): string[];
1001
+ view_names_owned(): string[];
1002
+ view_names(): Set<string>;
1003
+ theme(next?: string | null): string | null | undefined;
1004
+ attr_static(): {
1005
+ [key: string]: string | number | boolean | null;
1006
+ };
1007
+ attr(): {};
1008
+ style(): {
1009
+ [key: string]: string | number;
1010
+ };
1011
+ field(): {
1012
+ [key: string]: any;
1013
+ };
1014
+ event(): {
1015
+ [key: string]: (event: Event) => void;
1016
+ };
1017
+ event_async(): {
1018
+ [x: string]: (event: Event) => Promise<void>;
1019
+ };
1020
+ plugins(): readonly $mol_view[];
1021
+ [$mol_dev_format_head](): any[];
1022
+ view_find(check: (path: $mol_view, text?: string) => boolean, path?: $mol_view[]): Generator<$mol_view[]>;
1023
+ force_render(path: Set<$mol_view>): void;
1024
+ ensure_visible(view: $mol_view, align?: ScrollLogicalPosition): void;
1025
+ bring(): void;
1026
+ destructor(): void;
1027
+ }
1028
+ type $mol_view_all = $mol_type_pick<$, typeof $mol_view>;
1029
+ }
1030
+
1031
+ interface Window {
1032
+ cordova: any;
1033
+ }
1034
+ declare namespace $ {
1035
+ }
1036
+
1037
+ declare namespace $ {
1038
+ class $mol_plugin extends $mol_view {
1039
+ dom_node_external(next?: Element): Element;
1040
+ render(): void;
1041
+ }
1042
+ }
1043
+
1044
+ declare namespace $ {
1045
+ class $mol_state_time extends $mol_object {
1046
+ static task(precision: number, reset?: null): $mol_after_timeout | $mol_after_frame;
1047
+ static now(precision: number): number;
1048
+ }
1049
+ }
1050
+
1
1051
  declare namespace $ {
2
1052
 
3
1053
  export class $mol_svg extends $mol_view {
@@ -11,6 +1061,17 @@ declare namespace $ {
11
1061
  }
12
1062
 
13
1063
  //# sourceMappingURL=svg.view.tree.d.ts.map
1064
+ declare namespace $.$$ {
1065
+ class $mol_svg extends $.$mol_svg {
1066
+ computed_style(): Record<string, any>;
1067
+ font_size(): number;
1068
+ font_family(): any;
1069
+ }
1070
+ }
1071
+
1072
+ declare namespace $ {
1073
+ }
1074
+
14
1075
  declare namespace $ {
15
1076
 
16
1077
  export class $mol_svg_root extends $mol_svg {
@@ -26,6 +1087,88 @@ declare namespace $ {
26
1087
  }
27
1088
 
28
1089
  //# sourceMappingURL=root.view.tree.d.ts.map
1090
+ declare namespace $ {
1091
+ class $mol_vector<Value, Length extends number> extends Array<Value> {
1092
+ get length(): Length;
1093
+ constructor(...values: Value[] & {
1094
+ length: Length;
1095
+ });
1096
+ map<Res>(convert: (value: Value, index: number, array: this) => Res, self?: any): $mol_vector<Res, Length>;
1097
+ merged<Patch>(patches: readonly Patch[] & {
1098
+ length: Length;
1099
+ }, combine: (value: Value, patch: Patch) => Value): this;
1100
+ limited(this: $mol_vector<number, Length>, limits: readonly (readonly [number, number])[] & {
1101
+ length: Length;
1102
+ }): this;
1103
+ added0(this: $mol_vector<number, Length>, diff: number): this;
1104
+ added1(this: $mol_vector<number, Length>, diff: readonly number[] & {
1105
+ length: Length;
1106
+ }): this;
1107
+ substracted1(this: $mol_vector<number, Length>, diff: readonly number[] & {
1108
+ length: Length;
1109
+ }): this;
1110
+ multed0(this: $mol_vector<number, Length>, mult: number): this;
1111
+ multed1(this: $mol_vector<number, Length>, mults: readonly number[] & {
1112
+ length: Length;
1113
+ }): this;
1114
+ divided1(this: $mol_vector<number, Length>, mults: readonly number[] & {
1115
+ length: Length;
1116
+ }): this;
1117
+ powered0(this: $mol_vector<number, Length>, mult: number): this;
1118
+ expanded1(this: $mol_vector<$mol_vector_range<number>, Length>, point: readonly number[] & {
1119
+ length: Length;
1120
+ }): this;
1121
+ expanded2(this: $mol_vector<$mol_vector_range<number>, Length>, point: readonly (readonly [number, number])[] & {
1122
+ length: Length;
1123
+ }): this;
1124
+ center<Item extends $mol_vector<number, number>>(this: $mol_vector<Item, Length>): Item;
1125
+ distance(this: $mol_vector<$mol_vector<number, number>, Length>): number;
1126
+ transponed(this: $mol_vector<$mol_vector<number, number>, Length>): $mol_vector<$mol_vector<number, Length>, typeof this[0]['length']>;
1127
+ get x(): Value;
1128
+ set x(next: Value);
1129
+ get y(): Value;
1130
+ set y(next: Value);
1131
+ get z(): Value;
1132
+ set z(next: Value);
1133
+ }
1134
+ class $mol_vector_1d<Value> extends $mol_vector<Value, 1> {
1135
+ }
1136
+ class $mol_vector_2d<Value> extends $mol_vector<Value, 2> {
1137
+ }
1138
+ class $mol_vector_3d<Value> extends $mol_vector<Value, 3> {
1139
+ }
1140
+ class $mol_vector_range<Value> extends $mol_vector<Value, 2> {
1141
+ 0: Value;
1142
+ 1: Value;
1143
+ constructor(min: Value, max?: Value);
1144
+ get min(): Value;
1145
+ set min(next: Value);
1146
+ get max(): Value;
1147
+ set max(next: Value);
1148
+ get inversed(): $mol_vector_range<Value>;
1149
+ expanded0(value: Value): $mol_vector_range<Value>;
1150
+ }
1151
+ let $mol_vector_range_full: $mol_vector_range<number>;
1152
+ class $mol_vector_matrix<Width extends number, Height extends number> extends $mol_vector<readonly number[] & {
1153
+ length: Width;
1154
+ }, Height> {
1155
+ added2(diff: readonly (readonly number[] & {
1156
+ length: Width;
1157
+ })[] & {
1158
+ length: Height;
1159
+ }): this;
1160
+ multed2(diff: readonly (readonly number[] & {
1161
+ length: Width;
1162
+ })[] & {
1163
+ length: Height;
1164
+ }): this;
1165
+ }
1166
+ }
1167
+
1168
+ declare namespace $ {
1169
+ type $mol_type_enforce<Actual extends Expected, Expected> = Actual;
1170
+ }
1171
+
29
1172
  declare namespace $ {
30
1173
 
31
1174
  type $mol_vector_2d__mol_touch_1 = $mol_type_enforce<
@@ -93,6 +1236,31 @@ declare namespace $ {
93
1236
  }
94
1237
 
95
1238
  //# sourceMappingURL=touch.view.tree.d.ts.map
1239
+ declare namespace $.$$ {
1240
+ class $mol_touch extends $.$mol_touch {
1241
+ auto(): void;
1242
+ pointer_events(next?: readonly PointerEvent[]): readonly PointerEvent[];
1243
+ pointer_coords(): $mol_vector<$mol_vector_2d<number>, number>;
1244
+ pointer_center(): $mol_vector_2d<number>;
1245
+ event_coords(event: PointerEvent | WheelEvent): $mol_vector_2d<number>;
1246
+ action_point(): $mol_vector_2d<number>;
1247
+ event_eat(event: PointerEvent | WheelEvent): string;
1248
+ event_start(event: PointerEvent): void;
1249
+ event_move(event: PointerEvent): void;
1250
+ event_end(event: PointerEvent): void;
1251
+ event_leave(event: PointerEvent): void;
1252
+ swipe_left(event: PointerEvent): void;
1253
+ swipe_right(event: PointerEvent): void;
1254
+ swipe_top(event: PointerEvent): void;
1255
+ swipe_bottom(event: PointerEvent): void;
1256
+ event_wheel(event: WheelEvent): void;
1257
+ }
1258
+ }
1259
+
1260
+ declare namespace $ {
1261
+ let $mol_mem_cached: typeof $mol_wire_probe;
1262
+ }
1263
+
96
1264
  declare namespace $ {
97
1265
 
98
1266
  export class $mol_svg_group extends $mol_svg {
@@ -243,6 +1411,23 @@ declare namespace $ {
243
1411
  }
244
1412
 
245
1413
  //# sourceMappingURL=graph.view.tree.d.ts.map
1414
+ declare namespace $.$$ {
1415
+ class $mol_plot_graph extends $.$mol_plot_graph {
1416
+ viewport(): $mol_vector_2d<$mol_vector_range<number>>;
1417
+ indexes(): readonly number[];
1418
+ repos_x(val: number): number;
1419
+ repos_y(val: number): number;
1420
+ points(): readonly (readonly number[])[];
1421
+ series_x(): readonly number[];
1422
+ dimensions(): $mol_vector_2d<$mol_vector_range<number>>;
1423
+ color(): string;
1424
+ front(): readonly $.$mol_svg[];
1425
+ }
1426
+ }
1427
+
1428
+ declare namespace $ {
1429
+ }
1430
+
246
1431
  declare namespace $ {
247
1432
 
248
1433
  type $mol_vector_range__mol_plot_pane_1 = $mol_type_enforce<
@@ -446,6 +1631,35 @@ declare namespace $ {
446
1631
  }
447
1632
 
448
1633
  //# sourceMappingURL=pane.view.tree.d.ts.map
1634
+ declare namespace $.$$ {
1635
+ class $mol_plot_pane extends $.$mol_plot_pane {
1636
+ dimensions(): $mol_vector_2d<$mol_vector_range<number>>;
1637
+ size(): $mol_vector_2d<number>;
1638
+ graph_hue(index: number): number;
1639
+ graphs_colored(): $.$mol_plot_graph[];
1640
+ size_real(): $mol_vector_2d<number>;
1641
+ view_box(): string;
1642
+ scale_limit(): $mol_vector_2d<$mol_vector_range<number>>;
1643
+ scale_default(): $mol_vector_2d<number>;
1644
+ scale(next?: $mol_vector_2d<number>): $mol_vector_2d<number>;
1645
+ scale_x(next?: number): number;
1646
+ scale_y(next?: number): number;
1647
+ shift_limit(): $mol_vector_2d<$mol_vector_range<number>>;
1648
+ shift_default(): $mol_vector_2d<number>;
1649
+ graph_touched: boolean;
1650
+ shift(next?: $mol_vector_2d<number>): $mol_vector_2d<number>;
1651
+ reset(event?: Event): void;
1652
+ graphs_visible(): $.$mol_plot_graph[];
1653
+ graphs_positioned(): readonly $.$mol_plot_graph[];
1654
+ dimensions_viewport(): $mol_vector<$mol_vector_range<number>, 2>;
1655
+ viewport(): $mol_vector_2d<$mol_vector_range<number>>;
1656
+ graphs_sorted(): $.$mol_svg[];
1657
+ }
1658
+ }
1659
+
1660
+ declare namespace $ {
1661
+ }
1662
+
449
1663
  declare namespace $ {
450
1664
 
451
1665
  type $mol_plot_graph_sample__color_mol_plot_line_1 = $mol_type_enforce<
@@ -474,6 +1688,17 @@ declare namespace $ {
474
1688
  }
475
1689
 
476
1690
  //# sourceMappingURL=line.view.tree.d.ts.map
1691
+ declare namespace $.$$ {
1692
+ class $mol_plot_line extends $.$mol_plot_line {
1693
+ sub(): readonly any[];
1694
+ indexes(): number[];
1695
+ curve(): string;
1696
+ }
1697
+ }
1698
+
1699
+ declare namespace $ {
1700
+ }
1701
+
477
1702
  declare namespace $ {
478
1703
 
479
1704
  type $mol_plot_graph_sample__sub_mol_plot_group_1 = $mol_type_enforce<
@@ -492,6 +1717,16 @@ declare namespace $ {
492
1717
  }
493
1718
 
494
1719
  //# sourceMappingURL=group.view.tree.d.ts.map
1720
+ declare namespace $.$$ {
1721
+ class $mol_plot_group extends $.$mol_plot_group {
1722
+ graphs_enriched(): readonly $.$mol_plot_graph[];
1723
+ dimensions(): $mol_vector_2d<$mol_vector_range<number>>;
1724
+ graph_samples(): any[];
1725
+ back(): $mol_plot_graph[];
1726
+ front(): $mol_plot_graph[];
1727
+ }
1728
+ }
1729
+
495
1730
  declare namespace $ {
496
1731
 
497
1732
  export class $mol_svg_path extends $mol_svg {
@@ -505,6 +1740,12 @@ declare namespace $ {
505
1740
  }
506
1741
 
507
1742
  //# sourceMappingURL=path.view.tree.d.ts.map
1743
+ declare namespace $ {
1744
+ function $mol_coord_pack(high: number, low: number): number;
1745
+ function $mol_coord_high(pack: number): number;
1746
+ function $mol_coord_low(pack: number): number;
1747
+ }
1748
+
508
1749
  declare namespace $ {
509
1750
 
510
1751
  type $mol_svg_path__geometry_mol_plot_dot_1 = $mol_type_enforce<
@@ -533,6 +1774,17 @@ declare namespace $ {
533
1774
  }
534
1775
 
535
1776
  //# sourceMappingURL=dot.view.tree.d.ts.map
1777
+ declare namespace $.$$ {
1778
+ class $mol_plot_dot extends $.$mol_plot_dot {
1779
+ filled(): Set<number>;
1780
+ indexes(): number[];
1781
+ curve(): string;
1782
+ }
1783
+ }
1784
+
1785
+ declare namespace $ {
1786
+ }
1787
+
536
1788
  declare namespace $ {
537
1789
 
538
1790
  type $mol_plot_map_heat_level__hint_mol_plot_map_heat_1 = $mol_type_enforce<
@@ -588,6 +1840,21 @@ declare namespace $ {
588
1840
  }
589
1841
 
590
1842
  //# sourceMappingURL=heat.view.tree.d.ts.map
1843
+ declare namespace $.$$ {
1844
+ class $mol_plot_map_heat extends $.$mol_plot_map_heat {
1845
+ levels(): number[];
1846
+ level_graphs(): $mol_plot_map_heat_level[];
1847
+ level_points(level: number): (readonly number[])[];
1848
+ level_opacity(level: number): string;
1849
+ level_diameter(): number;
1850
+ level_aspect(): number;
1851
+ level_hint(index: number): string;
1852
+ }
1853
+ }
1854
+
1855
+ declare namespace $ {
1856
+ }
1857
+
591
1858
  declare namespace $ {
592
1859
 
593
1860
  type $mol_svg_path__geometry_mol_plot_bar_1 = $mol_type_enforce<
@@ -614,6 +1881,19 @@ declare namespace $ {
614
1881
  }
615
1882
 
616
1883
  //# sourceMappingURL=bar.view.tree.d.ts.map
1884
+ declare namespace $.$$ {
1885
+ class $mol_plot_bar extends $.$mol_plot_bar {
1886
+ indexes(): number[];
1887
+ curve(): string;
1888
+ stroke_width(): string;
1889
+ color(): string;
1890
+ dimensions(): $mol_vector_2d<$mol_vector_range<number>>;
1891
+ }
1892
+ }
1893
+
1894
+ declare namespace $ {
1895
+ }
1896
+
617
1897
  declare namespace $ {
618
1898
 
619
1899
  export class $mol_plot_fill extends $mol_plot_line {
@@ -623,6 +1903,17 @@ declare namespace $ {
623
1903
  }
624
1904
 
625
1905
  //# sourceMappingURL=fill.view.tree.d.ts.map
1906
+ declare namespace $.$$ {
1907
+ class $mol_plot_fill extends $.$mol_plot_fill {
1908
+ curve(): string;
1909
+ front(): never[];
1910
+ back(): this[];
1911
+ }
1912
+ }
1913
+
1914
+ declare namespace $ {
1915
+ }
1916
+
626
1917
  declare namespace $ {
627
1918
 
628
1919
  export class $mol_svg_rect extends $mol_svg {
@@ -643,6 +1934,13 @@ declare namespace $ {
643
1934
  }
644
1935
 
645
1936
  //# sourceMappingURL=rect.view.tree.d.ts.map
1937
+ declare namespace $.$$ {
1938
+ class $mol_svg_rect extends $.$mol_svg_rect {
1939
+ pos_x(): any;
1940
+ pos_y(): any;
1941
+ }
1942
+ }
1943
+
646
1944
  declare namespace $ {
647
1945
 
648
1946
  export class $mol_svg_text extends $mol_svg {
@@ -666,6 +1964,20 @@ declare namespace $ {
666
1964
  }
667
1965
 
668
1966
  //# sourceMappingURL=text.view.tree.d.ts.map
1967
+ declare namespace $.$$ {
1968
+ class $mol_svg_text extends $.$mol_svg_text {
1969
+ pos_x(): any;
1970
+ pos_y(): any;
1971
+ }
1972
+ }
1973
+
1974
+ declare namespace $ {
1975
+ }
1976
+
1977
+ declare namespace $ {
1978
+ function $mol_math_round_expand(val: number, gap?: number): number;
1979
+ }
1980
+
669
1981
  declare namespace $ {
670
1982
 
671
1983
  type $mol_svg_rect__pos_x_mol_plot_ruler_1 = $mol_type_enforce<
@@ -772,6 +2084,23 @@ declare namespace $ {
772
2084
  }
773
2085
 
774
2086
  //# sourceMappingURL=ruler.view.tree.d.ts.map
2087
+ declare namespace $.$$ {
2088
+ class $mol_plot_ruler extends $.$mol_plot_ruler {
2089
+ labels_formatted(): $.$mol_svg_text[];
2090
+ step(): number;
2091
+ snap_to_grid(coord: number): number;
2092
+ axis_points(): number[];
2093
+ precision(): number;
2094
+ label_text(index: number): string;
2095
+ font_size(): number;
2096
+ back(): $mol_svg_path[];
2097
+ front(): readonly $.$mol_svg[];
2098
+ }
2099
+ }
2100
+
2101
+ declare namespace $ {
2102
+ }
2103
+
775
2104
  declare namespace $ {
776
2105
 
777
2106
  export class $mol_plot_ruler_vert extends $mol_plot_ruler {
@@ -786,6 +2115,22 @@ declare namespace $ {
786
2115
  }
787
2116
 
788
2117
  //# sourceMappingURL=vert.view.tree.d.ts.map
2118
+ declare namespace $.$$ {
2119
+ class $mol_plot_ruler_vert extends $.$mol_plot_ruler_vert {
2120
+ dimensions_axis(): $mol_vector_range<number>;
2121
+ viewport_axis(): $mol_vector_range<number>;
2122
+ scale_axis(): number;
2123
+ scale_step(): number;
2124
+ shift_axis(): number;
2125
+ curve(): string;
2126
+ title_pos_x(): string;
2127
+ label_pos_y(index: number): string;
2128
+ }
2129
+ }
2130
+
2131
+ declare namespace $ {
2132
+ }
2133
+
789
2134
  declare namespace $ {
790
2135
 
791
2136
  export class $mol_plot_ruler_hor extends $mol_plot_ruler {
@@ -800,6 +2145,32 @@ declare namespace $ {
800
2145
  }
801
2146
 
802
2147
  //# sourceMappingURL=hor.view.tree.d.ts.map
2148
+ declare namespace $.$$ {
2149
+ class $mol_plot_ruler_hor extends $.$mol_plot_ruler_hor {
2150
+ dimensions_axis(): $mol_vector_range<number>;
2151
+ viewport_axis(): $mol_vector_range<number>;
2152
+ scale_axis(): number;
2153
+ scale_step(): number;
2154
+ shift_axis(): number;
2155
+ curve(): string;
2156
+ label_pos_x(index: number): string;
2157
+ background_y(): string;
2158
+ title_pos_y(): string;
2159
+ background_height(): string;
2160
+ }
2161
+ }
2162
+
2163
+ declare namespace $ {
2164
+ }
2165
+
2166
+ declare namespace $ {
2167
+ function $mol_font_canvas(next?: CanvasRenderingContext2D): CanvasRenderingContext2D;
2168
+ }
2169
+
2170
+ declare namespace $ {
2171
+ function $mol_font_measure(font: string, text: string): number;
2172
+ }
2173
+
803
2174
  declare namespace $ {
804
2175
 
805
2176
  type $mol_svg_rect__width_mol_svg_text_box_1 = $mol_type_enforce<
@@ -851,6 +2222,18 @@ declare namespace $ {
851
2222
  }
852
2223
 
853
2224
  //# sourceMappingURL=box.view.tree.d.ts.map
2225
+ declare namespace $.$$ {
2226
+ class $mol_svg_text_box extends $.$mol_svg_text_box {
2227
+ box_width(): string;
2228
+ width(): number;
2229
+ box_pos_x(): string;
2230
+ box_pos_y(): string;
2231
+ }
2232
+ }
2233
+
2234
+ declare namespace $ {
2235
+ }
2236
+
854
2237
  declare namespace $ {
855
2238
 
856
2239
  type $mol_vector_range__mol_plot_mark_cross_1 = $mol_type_enforce<
@@ -928,6 +2311,26 @@ declare namespace $ {
928
2311
  }
929
2312
 
930
2313
  //# sourceMappingURL=cross.view.tree.d.ts.map
2314
+ declare namespace $.$$ {
2315
+ class $mol_plot_mark_cross extends $.$mol_plot_mark_cross {
2316
+ nearest(): {
2317
+ value: $mol_vector_2d<number>;
2318
+ scaled: $mol_vector_2d<number>;
2319
+ index: number;
2320
+ } | null;
2321
+ curve(): string;
2322
+ title_x(): string;
2323
+ title_x_pos_x(): string;
2324
+ title_x_pos_y(): string;
2325
+ title_y(): string;
2326
+ title_y_pos_y(): string;
2327
+ title_y_pos_x(): string;
2328
+ }
2329
+ }
2330
+
2331
+ declare namespace $ {
2332
+ }
2333
+
931
2334
  declare namespace $ {
932
2335
 
933
2336
  export class $mol_plot_mark_hor extends $mol_plot_ruler_hor {
@@ -937,5 +2340,21 @@ declare namespace $ {
937
2340
  }
938
2341
 
939
2342
  //# sourceMappingURL=hor.view.tree.d.ts.map
2343
+ declare namespace $.$$ {
2344
+ class $mol_plot_mark_hor extends $.$mol_plot_mark_hor {
2345
+ series_x(): readonly number[];
2346
+ labels(): readonly string[];
2347
+ visible_indexes(): number[];
2348
+ curve(): string;
2349
+ label_text(index: number): string;
2350
+ labels_formatted(): $.$mol_svg_text[];
2351
+ label_pos_x(index: number): string;
2352
+ label_pos_y(index: number): string;
2353
+ }
2354
+ }
2355
+
2356
+ declare namespace $ {
2357
+ }
2358
+
940
2359
  export = $;
941
2360
  //# sourceMappingURL=web.d.ts.map