embedded-react 0.16.0 → 0.18.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/aot/compiler/animations.mjs +102 -34
- package/aot/compiler/assemble.mjs +169 -31
- package/aot/compiler/boot.mjs +441 -0
- package/aot/compiler/branch-merge.mjs +315 -0
- package/aot/compiler/c/animations.mjs +90 -16
- package/aot/compiler/c/boot.mjs +127 -0
- package/aot/compiler/c/expressions.mjs +63 -8
- package/aot/compiler/c/nodes.mjs +34 -13
- package/aot/compiler/c/statements.mjs +92 -15
- package/aot/compiler/check.mjs +32 -3
- package/aot/compiler/collect.mjs +95 -9
- package/aot/compiler/control-flow.mjs +43 -18
- package/aot/compiler/diagnostics.mjs +33 -0
- package/aot/compiler/elements/dial.mjs +8 -7
- package/aot/compiler/elements/props.mjs +19 -9
- package/aot/compiler/elements/text-input.mjs +7 -2
- package/aot/compiler/expressions.mjs +132 -10
- package/aot/compiler/handlers.mjs +62 -24
- package/aot/compiler/ir/boot.mjs +16 -0
- package/aot/compiler/ir/nodes.mjs +28 -4
- package/aot/compiler/ir/reads.mjs +351 -0
- package/aot/compiler/keyboard.mjs +35 -21
- package/aot/compiler/lower.mjs +40 -11
- package/aot/compiler/nodes.mjs +22 -9
- package/aot/compiler/options.mjs +63 -12
- package/aot/compiler/static-eval.mjs +314 -56
- package/aot/compiler/style-text.mjs +201 -19
- package/aot/compiler/svg.mjs +7 -3
- package/aot/style-map.mjs +9 -11
- package/assets/bake-svg.mjs +3 -2
- package/package.json +1 -1
- package/sim/embedded-react.wasm +0 -0
- package/src/embedded-react/Animated.js +41 -0
- package/src/embedded-react/Button.js +3 -4
- package/src/embedded-react/Pressable.js +59 -0
- package/src/embedded-react/TouchableOpacity.js +6 -9
- package/src/embedded-react/index.d.ts +118 -30
- package/src/embedded-react/index.js +1 -1
- package/src/embedded-react/named-colors.js +37 -0
- package/src/embedded-react/svg-ops.js +13 -16
- package/src/host-config.js +50 -8
|
@@ -0,0 +1,441 @@
|
|
|
1
|
+
/*
|
|
2
|
+
* Copyright 2026 Cory Lamming
|
|
3
|
+
*
|
|
4
|
+
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
5
|
+
* you may not use this file except in compliance with the License.
|
|
6
|
+
* You may obtain a copy of the License at
|
|
7
|
+
*
|
|
8
|
+
* http://www.apache.org/licenses/LICENSE-2.0
|
|
9
|
+
*
|
|
10
|
+
* Unless required by applicable law or agreed to in writing, software
|
|
11
|
+
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
12
|
+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
13
|
+
* See the License for the specific language governing permissions and
|
|
14
|
+
* limitations under the License.
|
|
15
|
+
*/
|
|
16
|
+
/*----------------------------------------------------------------------------------------------------------------------
|
|
17
|
+
- Imports
|
|
18
|
+
---------------------------------------------------------------------------------------------------------------------*/
|
|
19
|
+
import { attemptLowering } from './check.mjs';
|
|
20
|
+
import { INT } from './ir/types.mjs';
|
|
21
|
+
/*----------------------------------------------------------------------------------------------------------------------
|
|
22
|
+
- Constants
|
|
23
|
+
---------------------------------------------------------------------------------------------------------------------*/
|
|
24
|
+
/** The kinds of value a boot slot holds. */
|
|
25
|
+
const SLOT_KINDS = new Set(['bool', 'int', 'float', 'string']);
|
|
26
|
+
/** The current compile's boot values, or null outside a compile. */
|
|
27
|
+
let context = null;
|
|
28
|
+
/*----------------------------------------------------------------------------------------------------------------------
|
|
29
|
+
- Implementation
|
|
30
|
+
---------------------------------------------------------------------------------------------------------------------*/
|
|
31
|
+
/**
|
|
32
|
+
* A value known at boot: `screen.width` / `screen.height`, or an expression derived only from them and
|
|
33
|
+
* constants. It carries the JS expression that computes it, the names that expression reads, and what it is
|
|
34
|
+
* on the panel the build was compiled for, which a site that needs a compile-time constant folds instead.
|
|
35
|
+
*/
|
|
36
|
+
export class BootValue {
|
|
37
|
+
/** The expression, or null for a panel dimension. */
|
|
38
|
+
node;
|
|
39
|
+
/** The names the expression reads. */
|
|
40
|
+
scope;
|
|
41
|
+
/** What it is on the build's panel. */
|
|
42
|
+
value;
|
|
43
|
+
/** Boot can work it out from its expression. */
|
|
44
|
+
lowerable;
|
|
45
|
+
/** What its slot is named after, once it is bound to a name. */
|
|
46
|
+
name;
|
|
47
|
+
/** The panel dimension it is, if it is one. */
|
|
48
|
+
dimension;
|
|
49
|
+
/** What a fold of it assumes when boot cannot work it out: the test that picked it. */
|
|
50
|
+
basis;
|
|
51
|
+
/** A value assuming this one is the same as assuming, as for `!flag` and `flag`. */
|
|
52
|
+
equivalent = null;
|
|
53
|
+
/** The slot boot reads it from, once looked up; null when boot cannot work it out. */
|
|
54
|
+
slot = undefined;
|
|
55
|
+
/**
|
|
56
|
+
* @param node The expression, or null for a panel dimension.
|
|
57
|
+
* @param scope The names the expression reads.
|
|
58
|
+
* @param value What it is on the build's panel.
|
|
59
|
+
* @param lowerable Boot can work it out from its expression.
|
|
60
|
+
* @param name What its slot is named after, if it is bound to a name yet.
|
|
61
|
+
* @param dimension The panel dimension it is, if it is one.
|
|
62
|
+
* @param basis What a fold of it assumes when boot cannot work it out.
|
|
63
|
+
*/
|
|
64
|
+
constructor(node, scope, value, lowerable, name = null, dimension = null, basis = []) {
|
|
65
|
+
this.node = node;
|
|
66
|
+
this.scope = scope;
|
|
67
|
+
this.value = value;
|
|
68
|
+
this.lowerable = lowerable;
|
|
69
|
+
this.name = name;
|
|
70
|
+
this.dimension = dimension;
|
|
71
|
+
this.basis = basis;
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
/** Thrown by a strict fold that read a boot value, so the caller takes its runtime path instead. */
|
|
75
|
+
export class BootReadError extends Error {
|
|
76
|
+
constructor() {
|
|
77
|
+
super('AOT: the value depends on the panel size');
|
|
78
|
+
}
|
|
79
|
+
}
|
|
80
|
+
/**
|
|
81
|
+
* Whether a value is a boot value.
|
|
82
|
+
*
|
|
83
|
+
* @param value The value.
|
|
84
|
+
*
|
|
85
|
+
* @returns True for a BootValue.
|
|
86
|
+
*/
|
|
87
|
+
export const isBoot = (value) => value instanceof BootValue;
|
|
88
|
+
/**
|
|
89
|
+
* Whether a value is an object or array a fold built, which may hold boot values (an AST node never is).
|
|
90
|
+
*
|
|
91
|
+
* @param value The value.
|
|
92
|
+
*
|
|
93
|
+
* @returns True for a plain object or an array.
|
|
94
|
+
*/
|
|
95
|
+
export const isContainer = (value) => Array.isArray(value) ||
|
|
96
|
+
(typeof value === 'object' &&
|
|
97
|
+
value !== null &&
|
|
98
|
+
Object.getPrototypeOf(value) === Object.prototype);
|
|
99
|
+
/**
|
|
100
|
+
* What a value is on the build's panel, one level down: a boot value's own value, anything else itself.
|
|
101
|
+
*
|
|
102
|
+
* @param value The value.
|
|
103
|
+
*
|
|
104
|
+
* @returns The value.
|
|
105
|
+
*/
|
|
106
|
+
export function buildValueOf(value) {
|
|
107
|
+
let current = value;
|
|
108
|
+
while (isBoot(current)) {
|
|
109
|
+
current = current.value;
|
|
110
|
+
}
|
|
111
|
+
return current;
|
|
112
|
+
}
|
|
113
|
+
/**
|
|
114
|
+
* Whether a value is, or holds, a boot value.
|
|
115
|
+
*
|
|
116
|
+
* @param value The value.
|
|
117
|
+
*
|
|
118
|
+
* @returns True when it does.
|
|
119
|
+
*/
|
|
120
|
+
export function containsBoot(value) {
|
|
121
|
+
if (isBoot(value))
|
|
122
|
+
return true;
|
|
123
|
+
if (!isContainer(value))
|
|
124
|
+
return false;
|
|
125
|
+
return Object.values(value).some(containsBoot);
|
|
126
|
+
}
|
|
127
|
+
/**
|
|
128
|
+
* A value with every boot value in it replaced by what it is on the build's panel, each one recorded as an
|
|
129
|
+
* assumption. A container that holds none is returned as is.
|
|
130
|
+
*
|
|
131
|
+
* @param value The value.
|
|
132
|
+
*
|
|
133
|
+
* @returns The value as the build's panel gives it.
|
|
134
|
+
*/
|
|
135
|
+
export function foldBoot(value) {
|
|
136
|
+
if (isBoot(value)) {
|
|
137
|
+
context?.assumed.add(value.equivalent ?? value);
|
|
138
|
+
return foldBoot(value.value);
|
|
139
|
+
}
|
|
140
|
+
if (!isContainer(value) || !containsBoot(value))
|
|
141
|
+
return value;
|
|
142
|
+
if (Array.isArray(value))
|
|
143
|
+
return value.map(foldBoot);
|
|
144
|
+
return Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, foldBoot(entry)]));
|
|
145
|
+
}
|
|
146
|
+
/**
|
|
147
|
+
* Names the boot values a const binds that are not named yet: the value itself, or each entry of an object
|
|
148
|
+
* or array after its key, so their slots read like the source.
|
|
149
|
+
*
|
|
150
|
+
* @param value The const's value.
|
|
151
|
+
* @param name The const's name.
|
|
152
|
+
*/
|
|
153
|
+
export function nameBootValues(value, name) {
|
|
154
|
+
if (isBoot(value)) {
|
|
155
|
+
value.name ??= name;
|
|
156
|
+
}
|
|
157
|
+
else if (isContainer(value) && containsBoot(value)) {
|
|
158
|
+
for (const [key, entry] of Object.entries(value)) {
|
|
159
|
+
nameBootValues(entry, `${name}_${key}`);
|
|
160
|
+
}
|
|
161
|
+
}
|
|
162
|
+
}
|
|
163
|
+
/**
|
|
164
|
+
* The `screen` global: its width and height are boot values, set from er_app_build()'s arguments.
|
|
165
|
+
*
|
|
166
|
+
* @param screen The panel the build is compiled for.
|
|
167
|
+
* @param screen.width Its width.
|
|
168
|
+
* @param screen.height Its height.
|
|
169
|
+
*
|
|
170
|
+
* @returns The binding.
|
|
171
|
+
*/
|
|
172
|
+
export const screenBinding = (screen) => ({
|
|
173
|
+
width: new BootValue(null, {}, screen.width, true, null, 'width'),
|
|
174
|
+
height: new BootValue(null, {}, screen.height, true, null, 'height'),
|
|
175
|
+
});
|
|
176
|
+
/**
|
|
177
|
+
* Starts recording a compile's boot values.
|
|
178
|
+
*/
|
|
179
|
+
export function beginBoot() {
|
|
180
|
+
context = {
|
|
181
|
+
env: null,
|
|
182
|
+
lower: null,
|
|
183
|
+
slots: [],
|
|
184
|
+
assumed: new Set(),
|
|
185
|
+
lowering: new Set(),
|
|
186
|
+
wholes: new Map(),
|
|
187
|
+
};
|
|
188
|
+
}
|
|
189
|
+
/**
|
|
190
|
+
* Gives the compile's boot values the environment and lowering their slots are worked out with.
|
|
191
|
+
*
|
|
192
|
+
* @param env The app's environment.
|
|
193
|
+
* @param lower The expression lowering.
|
|
194
|
+
*/
|
|
195
|
+
export function setBootLowering(env, lower) {
|
|
196
|
+
if (context) {
|
|
197
|
+
context.env = env;
|
|
198
|
+
context.lower = lower;
|
|
199
|
+
}
|
|
200
|
+
}
|
|
201
|
+
/**
|
|
202
|
+
* Ends a compile's boot values: what the compile's slots are, and what its folds assumed of the panel.
|
|
203
|
+
*
|
|
204
|
+
* @returns The app's boot values.
|
|
205
|
+
*/
|
|
206
|
+
export function endBoot() {
|
|
207
|
+
const ending = context;
|
|
208
|
+
if (!ending)
|
|
209
|
+
return { slots: [], assumptions: [] };
|
|
210
|
+
// Look each assumed value's slot up while the context still lowers, so the guard can read it.
|
|
211
|
+
const assumptions = [];
|
|
212
|
+
const guarded = new Set();
|
|
213
|
+
let assumesPanel = false;
|
|
214
|
+
const assume = (value) => {
|
|
215
|
+
const slot = bootSlotOf(value);
|
|
216
|
+
const buildValue = buildValueOf(value);
|
|
217
|
+
if (slot && isGuardable(buildValue)) {
|
|
218
|
+
if (!guarded.has(slot)) {
|
|
219
|
+
guarded.add(slot);
|
|
220
|
+
assumptions.push({ kind: 'value', slot, value: buildValue });
|
|
221
|
+
}
|
|
222
|
+
}
|
|
223
|
+
else if (value.basis.length) {
|
|
224
|
+
value.basis.forEach(assume);
|
|
225
|
+
}
|
|
226
|
+
else {
|
|
227
|
+
assumesPanel = true;
|
|
228
|
+
}
|
|
229
|
+
};
|
|
230
|
+
ending.assumed.forEach(assume);
|
|
231
|
+
if (assumesPanel) {
|
|
232
|
+
assumptions.push({ kind: 'panel' });
|
|
233
|
+
}
|
|
234
|
+
context = null;
|
|
235
|
+
return { slots: ending.slots, assumptions };
|
|
236
|
+
}
|
|
237
|
+
/**
|
|
238
|
+
* Drops a compile's boot values after it failed.
|
|
239
|
+
*/
|
|
240
|
+
export function abandonBoot() {
|
|
241
|
+
context = null;
|
|
242
|
+
}
|
|
243
|
+
/**
|
|
244
|
+
* Whether a guard can compare a slot against a value.
|
|
245
|
+
*
|
|
246
|
+
* @param value The value on the build's panel.
|
|
247
|
+
*
|
|
248
|
+
* @returns True for a finite number, a string, or a boolean.
|
|
249
|
+
*/
|
|
250
|
+
const isGuardable = (value) => typeof value === 'string' ||
|
|
251
|
+
typeof value === 'boolean' ||
|
|
252
|
+
(typeof value === 'number' && Number.isFinite(value));
|
|
253
|
+
/**
|
|
254
|
+
* A C identifier for a slot named after `name`, unique among the compile's slots.
|
|
255
|
+
*
|
|
256
|
+
* @param name The name.
|
|
257
|
+
*
|
|
258
|
+
* @returns The field.
|
|
259
|
+
*/
|
|
260
|
+
function slotField(name) {
|
|
261
|
+
const base = name.replace(/[^A-Za-z0-9_]/g, '_').replace(/^(?=\d)/, '_');
|
|
262
|
+
const taken = new Set(context.slots.map(slot => slot.field));
|
|
263
|
+
let field = base || 'value';
|
|
264
|
+
for (let suffix = 2; taken.has(field); suffix++) {
|
|
265
|
+
field = `${base}_${suffix}`;
|
|
266
|
+
}
|
|
267
|
+
return field;
|
|
268
|
+
}
|
|
269
|
+
/**
|
|
270
|
+
* Whether two lowered expressions compute the same value the same way (they read slots by identity).
|
|
271
|
+
*
|
|
272
|
+
* @param first One expression.
|
|
273
|
+
* @param second The other.
|
|
274
|
+
*
|
|
275
|
+
* @returns True when they do.
|
|
276
|
+
*/
|
|
277
|
+
function sameExpr(first, second) {
|
|
278
|
+
if (first === second)
|
|
279
|
+
return true;
|
|
280
|
+
if (typeof first !== 'object' ||
|
|
281
|
+
typeof second !== 'object' ||
|
|
282
|
+
first === null ||
|
|
283
|
+
second === null ||
|
|
284
|
+
Array.isArray(first) !== Array.isArray(second)) {
|
|
285
|
+
return false;
|
|
286
|
+
}
|
|
287
|
+
const firstKeys = Object.keys(first);
|
|
288
|
+
return (firstKeys.length === Object.keys(second).length &&
|
|
289
|
+
firstKeys.every(key => key === 'slot'
|
|
290
|
+
? first[key] ===
|
|
291
|
+
second[key]
|
|
292
|
+
: sameExpr(first[key], second[key])));
|
|
293
|
+
}
|
|
294
|
+
/**
|
|
295
|
+
* The environment a slot's expression lowers in: the app's, with no runtime names, and `scope` as its
|
|
296
|
+
* constants.
|
|
297
|
+
*
|
|
298
|
+
* @param env The app's environment.
|
|
299
|
+
* @param scope The names the expression reads.
|
|
300
|
+
*
|
|
301
|
+
* @returns The environment.
|
|
302
|
+
*/
|
|
303
|
+
const bootEnv = (env, scope) => ({
|
|
304
|
+
...env,
|
|
305
|
+
state: new Map(),
|
|
306
|
+
locals: new Map(),
|
|
307
|
+
consts: scope,
|
|
308
|
+
animations: new Map(),
|
|
309
|
+
refs: new Map(),
|
|
310
|
+
pans: new Map(),
|
|
311
|
+
callbacks: new Map(),
|
|
312
|
+
helpers: new Map(),
|
|
313
|
+
children: null,
|
|
314
|
+
fnProps: undefined,
|
|
315
|
+
cbPrefix: undefined,
|
|
316
|
+
event: null,
|
|
317
|
+
gesture: null,
|
|
318
|
+
pan: null,
|
|
319
|
+
math64: false,
|
|
320
|
+
animLocals: undefined,
|
|
321
|
+
});
|
|
322
|
+
/**
|
|
323
|
+
* The environment a boot value's own expression lowers in, for a caller that lowers it some other way than
|
|
324
|
+
* as a slot (a style enum, say).
|
|
325
|
+
*
|
|
326
|
+
* @param value The value.
|
|
327
|
+
*
|
|
328
|
+
* @returns The environment, or null when boot cannot work the value out.
|
|
329
|
+
*/
|
|
330
|
+
export function bootEnvOf(value) {
|
|
331
|
+
if (!context?.env || !value.lowerable || !value.node)
|
|
332
|
+
return null;
|
|
333
|
+
return bootEnv(context.env, value.scope);
|
|
334
|
+
}
|
|
335
|
+
/**
|
|
336
|
+
* The slot boot reads a value from, lowered on first use, after the slots its expression reads. A value boot
|
|
337
|
+
* cannot work out (one only a fold can give, or one read outside a compile) has none.
|
|
338
|
+
*
|
|
339
|
+
* @param value The value.
|
|
340
|
+
*
|
|
341
|
+
* @returns Its slot, or null.
|
|
342
|
+
*/
|
|
343
|
+
export function bootSlotOf(value) {
|
|
344
|
+
if (value.slot !== undefined)
|
|
345
|
+
return value.slot;
|
|
346
|
+
if (!context?.env || !context.lower)
|
|
347
|
+
return null;
|
|
348
|
+
// Null first, so an expression that reads itself has no slot.
|
|
349
|
+
value.slot = null;
|
|
350
|
+
let slot;
|
|
351
|
+
if (value.dimension) {
|
|
352
|
+
slot = {
|
|
353
|
+
field: slotField(`screen_${value.dimension}`),
|
|
354
|
+
type: INT,
|
|
355
|
+
init: { kind: 'screen', dimension: value.dimension },
|
|
356
|
+
};
|
|
357
|
+
}
|
|
358
|
+
else {
|
|
359
|
+
if (!value.lowerable || !value.node)
|
|
360
|
+
return null;
|
|
361
|
+
const { env, lower } = context;
|
|
362
|
+
let expr;
|
|
363
|
+
const { lowering } = context;
|
|
364
|
+
lowering.add(value.node);
|
|
365
|
+
try {
|
|
366
|
+
expr = attemptLowering(() => lower(value.node, bootEnv(env, value.scope)));
|
|
367
|
+
}
|
|
368
|
+
catch {
|
|
369
|
+
return null;
|
|
370
|
+
}
|
|
371
|
+
finally {
|
|
372
|
+
lowering.delete(value.node);
|
|
373
|
+
}
|
|
374
|
+
if (!SLOT_KINDS.has(expr.type.kind))
|
|
375
|
+
return null;
|
|
376
|
+
// A value that only reads another slot shares it, as does one worked out the same way as an earlier slot.
|
|
377
|
+
if (expr.kind === 'boot') {
|
|
378
|
+
value.slot = expr.slot;
|
|
379
|
+
return expr.slot;
|
|
380
|
+
}
|
|
381
|
+
const sameSlot = context.slots.find(slot => slot.init.kind === 'expr' && sameExpr(slot.init.expr, expr));
|
|
382
|
+
if (sameSlot) {
|
|
383
|
+
value.slot = sameSlot;
|
|
384
|
+
return sameSlot;
|
|
385
|
+
}
|
|
386
|
+
slot = {
|
|
387
|
+
field: slotField(value.name ?? 'value'),
|
|
388
|
+
type: expr.type,
|
|
389
|
+
init: { kind: 'expr', expr },
|
|
390
|
+
};
|
|
391
|
+
}
|
|
392
|
+
context.slots.push(slot);
|
|
393
|
+
value.slot = slot;
|
|
394
|
+
return slot;
|
|
395
|
+
}
|
|
396
|
+
/**
|
|
397
|
+
* Marks the assumptions recorded so far, for a lowering attempt whose folds should not stand if it is abandoned.
|
|
398
|
+
*
|
|
399
|
+
* @returns A function that drops every assumption recorded after the mark.
|
|
400
|
+
*/
|
|
401
|
+
export function bootCheckpoint() {
|
|
402
|
+
const marked = context;
|
|
403
|
+
const saved = marked ? new Set(marked.assumed) : null;
|
|
404
|
+
return () => {
|
|
405
|
+
if (marked && saved) {
|
|
406
|
+
marked.assumed = saved;
|
|
407
|
+
}
|
|
408
|
+
};
|
|
409
|
+
}
|
|
410
|
+
/**
|
|
411
|
+
* The boot value an expression read as a whole stands for: the first one found for it in this scope, so every
|
|
412
|
+
* read of the expression shares one slot. Null while a slot is being lowered: its expression is one slot.
|
|
413
|
+
*
|
|
414
|
+
* @param node The expression.
|
|
415
|
+
* @param scope The scope it was read in.
|
|
416
|
+
* @param value The boot value a fold of it gave.
|
|
417
|
+
*
|
|
418
|
+
* @returns The boot value to read, or null.
|
|
419
|
+
*/
|
|
420
|
+
export function wholeBootValue(node, scope, value) {
|
|
421
|
+
if (!context || context.lowering.size)
|
|
422
|
+
return null;
|
|
423
|
+
let byScope = context.wholes.get(node);
|
|
424
|
+
if (!byScope) {
|
|
425
|
+
byScope = new Map();
|
|
426
|
+
context.wholes.set(node, byScope);
|
|
427
|
+
}
|
|
428
|
+
const known = byScope.get(scope);
|
|
429
|
+
if (known)
|
|
430
|
+
return known;
|
|
431
|
+
byScope.set(scope, value);
|
|
432
|
+
return value;
|
|
433
|
+
}
|
|
434
|
+
/**
|
|
435
|
+
* Records that a fold read a boot value at the build's panel.
|
|
436
|
+
*
|
|
437
|
+
* @param value The value.
|
|
438
|
+
*/
|
|
439
|
+
export function assumeBoot(value) {
|
|
440
|
+
context?.assumed.add(value);
|
|
441
|
+
}
|