@context-action/core 1.2.6 → 1.3.1

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 (38) hide show
  1. package/CHANGELOG.md +22 -0
  2. package/README.md +31 -1
  3. package/dist/element-BRlY61kW.cjs +631 -0
  4. package/dist/element-BTaXgo7n.js +597 -0
  5. package/dist/element-BTaXgo7n.js.map +1 -0
  6. package/dist/element-DPioFL7C.d.cts +163 -0
  7. package/dist/element-DPioFL7C.d.cts.map +1 -0
  8. package/dist/element-DPioFL7C.d.ts +163 -0
  9. package/dist/element-DPioFL7C.d.ts.map +1 -0
  10. package/dist/element-react.cjs +91 -0
  11. package/dist/element-react.d.cts +11 -0
  12. package/dist/element-react.d.cts.map +1 -0
  13. package/dist/element-react.d.ts +11 -0
  14. package/dist/element-react.d.ts.map +1 -0
  15. package/dist/element-react.js +85 -0
  16. package/dist/element-react.js.map +1 -0
  17. package/dist/element.cjs +9 -0
  18. package/dist/element.d.cts +3 -0
  19. package/dist/element.d.ts +3 -0
  20. package/dist/element.js +3 -0
  21. package/dist/index.cjs +154 -47
  22. package/dist/index.d.cts +2 -1
  23. package/dist/index.d.cts.map +1 -1
  24. package/dist/index.d.ts +2 -1
  25. package/dist/index.d.ts.map +1 -1
  26. package/dist/index.js +154 -47
  27. package/dist/index.js.map +1 -1
  28. package/dist/public-action-methods-C_ppItRr.d.cts +5 -0
  29. package/dist/public-action-methods-C_ppItRr.d.cts.map +1 -0
  30. package/dist/public-action-methods-C_ppItRr.d.ts +5 -0
  31. package/dist/public-action-methods-C_ppItRr.d.ts.map +1 -0
  32. package/docs/action-contracts.md +78 -0
  33. package/docs/element-host-patterns.en.md +129 -0
  34. package/docs/element-host-patterns.ko.md +116 -0
  35. package/docs/element-interop.md +138 -0
  36. package/docs/interop-review.en.md +55 -0
  37. package/docs/interop-review.ko.md +51 -0
  38. package/package.json +35 -4
@@ -0,0 +1,631 @@
1
+ //#region src/facade/create-public-facade.ts
2
+ function findDescriptor(target, key) {
3
+ let current = target;
4
+ while (current) {
5
+ const descriptor = Object.getOwnPropertyDescriptor(current, key);
6
+ if (descriptor) return descriptor;
7
+ current = Object.getPrototypeOf(current);
8
+ }
9
+ }
10
+ /** Allow-list projection, not a sandbox or revocable command capability. */
11
+ function createPublicFacade(keys, detachedMessage = "Public handle target is not available") {
12
+ const uniqueKeys = Array.from(new Set(keys));
13
+ return (getElement) => {
14
+ const requireElement = () => {
15
+ const element = getElement();
16
+ if (!element) throw new Error(detachedMessage);
17
+ return element;
18
+ };
19
+ const methods = /* @__PURE__ */ new WeakMap();
20
+ const facade = {};
21
+ for (const key of uniqueKeys) Object.defineProperty(facade, key, {
22
+ configurable: false,
23
+ enumerable: true,
24
+ get() {
25
+ const element = requireElement();
26
+ const value = Reflect.get(element, key, element);
27
+ if (typeof value !== "function") return value;
28
+ let cache = methods.get(element);
29
+ if (!cache) {
30
+ cache = /* @__PURE__ */ new Map();
31
+ methods.set(element, cache);
32
+ }
33
+ const cached = cache.get(key);
34
+ if (cached?.source === value) return cached.bound;
35
+ const bound = value.bind(element);
36
+ cache.set(key, {
37
+ source: value,
38
+ bound
39
+ });
40
+ return bound;
41
+ },
42
+ set(value) {
43
+ const element = requireElement();
44
+ const descriptor = findDescriptor(element, key);
45
+ if (descriptor && !descriptor.set && !descriptor.writable || !Reflect.set(element, key, value, element)) throw new TypeError(`Cannot assign to read-only property '${String(key)}'`);
46
+ }
47
+ });
48
+ return Object.freeze(facade);
49
+ };
50
+ }
51
+
52
+ //#endregion
53
+ //#region src/element/create-element-facade.ts
54
+ /** DOM specialization of the internal object projection; not a revocable capability. */
55
+ function createElementFacade(keys) {
56
+ return createPublicFacade(keys, "Custom element handle is not mounted");
57
+ }
58
+
59
+ //#endregion
60
+ //#region src/element/attribute-bindings.ts
61
+ /** Only attempted attribute writes are owned. Omission releases ownership once via removeAttribute. */
62
+ function createAttributeBindings(element, attributes, active) {
63
+ const applied = /* @__PURE__ */ new Set();
64
+ return (input) => {
65
+ for (const [key, attrName] of attributes) {
66
+ if (!active()) return;
67
+ if (key in input) {
68
+ const value = input[key];
69
+ if (!active()) return;
70
+ applied.add(key);
71
+ if (value === null || value === void 0 || value === false) element.removeAttribute(attrName);
72
+ else if (value === true) element.setAttribute(attrName, "");
73
+ else element.setAttribute(attrName, String(value));
74
+ } else if (applied.delete(key)) element.removeAttribute(attrName);
75
+ }
76
+ };
77
+ }
78
+
79
+ //#endregion
80
+ //#region src/element/event-bindings.ts
81
+ function isHandler(value) {
82
+ return typeof value === "function" || typeof value === "object" && value !== null && typeof value.handleEvent === "function";
83
+ }
84
+ function createEventBindings(element, events, active) {
85
+ const bindings = /* @__PURE__ */ new Map();
86
+ function remove(key, binding) {
87
+ binding.active = false;
88
+ bindings.delete(key);
89
+ element.removeEventListener(binding.eventName, binding.listener);
90
+ }
91
+ return {
92
+ update(input) {
93
+ const handlers = input;
94
+ for (const [key, eventName] of events) {
95
+ if (!active()) return;
96
+ const handler = handlers[key];
97
+ const old = bindings.get(key);
98
+ if (old?.handler === handler) continue;
99
+ if (old) remove(key, old);
100
+ if (!active()) return;
101
+ if (!isHandler(handler)) continue;
102
+ const binding = {
103
+ handler,
104
+ eventName,
105
+ active: true,
106
+ listener(event) {
107
+ if (!active() || !binding.active) return;
108
+ if (typeof handler === "function") handler(event);
109
+ else handler.handleEvent(event);
110
+ }
111
+ };
112
+ bindings.set(key, binding);
113
+ try {
114
+ element.addEventListener(eventName, binding.listener);
115
+ } catch (error) {
116
+ remove(key, binding);
117
+ throw error;
118
+ }
119
+ if (!active()) remove(key, binding);
120
+ }
121
+ },
122
+ disconnect() {
123
+ for (const [key, binding] of bindings) remove(key, binding);
124
+ }
125
+ };
126
+ }
127
+
128
+ //#endregion
129
+ //#region src/element/property-bindings.ts
130
+ /** Only attempted bridge writes are owned. Omission releases ownership even if reset is rejected. */
131
+ function createPropertyBindings(element, properties, active, assignmentErrors) {
132
+ const applied = /* @__PURE__ */ new Set();
133
+ const host = element;
134
+ return (input) => {
135
+ for (const key of properties) {
136
+ if (!active()) return;
137
+ if (key in input) {
138
+ const value = input[key];
139
+ if (!active()) return;
140
+ applied.add(key);
141
+ try {
142
+ host[key] = value;
143
+ } catch (error) {
144
+ if (assignmentErrors === "throw") throw error;
145
+ }
146
+ } else if (applied.delete(key)) try {
147
+ host[key] = void 0;
148
+ } catch {}
149
+ }
150
+ };
151
+ }
152
+
153
+ //#endregion
154
+ //#region src/element/style-bindings.ts
155
+ /** Only attempted style writes are owned. Omission releases ownership once via removeProperty. */
156
+ function createStyleBindings(element, styles, active) {
157
+ const applied = /* @__PURE__ */ new Set();
158
+ return (input) => {
159
+ for (const [key, cssProperty] of styles) {
160
+ if (!active()) return;
161
+ if (key in input) {
162
+ const value = input[key];
163
+ if (!active()) return;
164
+ applied.add(key);
165
+ if (value === null || value === void 0 || value === "") element.style.removeProperty(cssProperty);
166
+ else element.style.setProperty(cssProperty, String(value));
167
+ } else if (applied.delete(key)) element.style.removeProperty(cssProperty);
168
+ }
169
+ };
170
+ }
171
+
172
+ //#endregion
173
+ //#region src/element/create-element-binding.ts
174
+ /** Framework-neutral DOM transport. Lifecycle adapters supply complete snapshots, not patches. */
175
+ function createElementBinding(element, config, options = {}) {
176
+ let disposed = false;
177
+ let updating = false;
178
+ const active = () => !disposed;
179
+ const properties = createPropertyBindings(element, Array.from(new Set(config.properties ?? [])), active, options.assignmentErrors ?? "ignore");
180
+ const attributes = createAttributeBindings(element, Object.entries(config.attributes ?? {}), active);
181
+ const styles = createStyleBindings(element, Object.entries(config.styles ?? {}), active);
182
+ const events = createEventBindings(element, Object.entries(config.events ?? {}), active);
183
+ function run(update) {
184
+ if (disposed) throw new Error("Element binding is disposed");
185
+ if (updating) throw new Error("Element binding update is already in progress");
186
+ updating = true;
187
+ try {
188
+ update();
189
+ } finally {
190
+ updating = false;
191
+ }
192
+ }
193
+ return {
194
+ get disposed() {
195
+ return disposed;
196
+ },
197
+ update(input) {
198
+ run(() => {
199
+ events.update(input);
200
+ if (active()) attributes(input);
201
+ if (active()) styles(input);
202
+ if (active()) properties(input);
203
+ });
204
+ },
205
+ updateProperties(input) {
206
+ run(() => properties(input));
207
+ },
208
+ updateAttributes(input) {
209
+ run(() => attributes(input));
210
+ },
211
+ updateStyles(input) {
212
+ run(() => styles(input));
213
+ },
214
+ updateEvents(input) {
215
+ run(() => events.update(input));
216
+ },
217
+ disconnectEvents() {
218
+ events.disconnect();
219
+ },
220
+ dispose() {
221
+ disposed = true;
222
+ events.disconnect();
223
+ }
224
+ };
225
+ }
226
+
227
+ //#endregion
228
+ //#region src/element/pointer-gesture-session.ts
229
+ const DEFAULT_MODIFIERS = {
230
+ shiftKey: false,
231
+ altKey: false,
232
+ ctrlKey: false,
233
+ metaKey: false
234
+ };
235
+ function readModifiers(event) {
236
+ return {
237
+ shiftKey: Boolean(event.shiftKey),
238
+ altKey: Boolean(event.altKey),
239
+ ctrlKey: Boolean(event.ctrlKey),
240
+ metaKey: Boolean(event.metaKey)
241
+ };
242
+ }
243
+ function createIdleSnapshot() {
244
+ return {
245
+ active: false,
246
+ pointerId: null,
247
+ startX: 0,
248
+ startY: 0,
249
+ currentX: 0,
250
+ currentY: 0,
251
+ deltaX: 0,
252
+ deltaY: 0,
253
+ modifiers: { ...DEFAULT_MODIFIERS }
254
+ };
255
+ }
256
+ function cloneSnapshot(snapshot) {
257
+ return {
258
+ ...snapshot,
259
+ modifiers: { ...snapshot.modifiers }
260
+ };
261
+ }
262
+ function createPointerGestureSession(options = {}) {
263
+ let disposed = false;
264
+ let snapshot = createIdleSnapshot();
265
+ let captureTarget = null;
266
+ const releaseCapture = () => {
267
+ if (captureTarget && snapshot.pointerId !== null) try {
268
+ captureTarget.releasePointerCapture?.(snapshot.pointerId);
269
+ } catch {}
270
+ captureTarget = null;
271
+ };
272
+ return {
273
+ start(event) {
274
+ if (disposed || snapshot.active) return false;
275
+ if (event.button !== void 0 && event.button !== 0) return false;
276
+ const pointerId = event.pointerId ?? 0;
277
+ const next = {
278
+ active: true,
279
+ pointerId,
280
+ startX: event.clientX,
281
+ startY: event.clientY,
282
+ currentX: event.clientX,
283
+ currentY: event.clientY,
284
+ deltaX: 0,
285
+ deltaY: 0,
286
+ modifiers: readModifiers(event)
287
+ };
288
+ if (options.onStart?.(cloneSnapshot(next)) === false || disposed) return false;
289
+ snapshot = next;
290
+ captureTarget = event.currentTarget ?? null;
291
+ if (captureTarget) try {
292
+ captureTarget.setPointerCapture?.(pointerId);
293
+ } catch {}
294
+ return true;
295
+ },
296
+ move(event) {
297
+ if (disposed || !snapshot.active) return false;
298
+ if (event.pointerId !== void 0 && event.pointerId !== snapshot.pointerId) return false;
299
+ snapshot = {
300
+ ...snapshot,
301
+ currentX: event.clientX,
302
+ currentY: event.clientY,
303
+ deltaX: event.clientX - snapshot.startX,
304
+ deltaY: event.clientY - snapshot.startY,
305
+ modifiers: readModifiers(event)
306
+ };
307
+ options.onMove?.(cloneSnapshot(snapshot));
308
+ return true;
309
+ },
310
+ commit(event) {
311
+ if (disposed || !snapshot.active) return false;
312
+ if (event?.pointerId !== void 0 && event.pointerId !== snapshot.pointerId) return false;
313
+ if (event && Number.isFinite(event.clientX) && Number.isFinite(event.clientY)) snapshot = {
314
+ ...snapshot,
315
+ currentX: event.clientX,
316
+ currentY: event.clientY,
317
+ deltaX: event.clientX - snapshot.startX,
318
+ deltaY: event.clientY - snapshot.startY,
319
+ modifiers: readModifiers(event)
320
+ };
321
+ releaseCapture();
322
+ snapshot = {
323
+ ...snapshot,
324
+ active: false
325
+ };
326
+ options.onCommit?.(cloneSnapshot(snapshot));
327
+ return true;
328
+ },
329
+ cancel(reason) {
330
+ if (disposed || !snapshot.active) return false;
331
+ releaseCapture();
332
+ snapshot = {
333
+ ...snapshot,
334
+ active: false
335
+ };
336
+ options.onCancel?.(cloneSnapshot(snapshot), reason);
337
+ return true;
338
+ },
339
+ handleKeyDown(event) {
340
+ if (disposed || !snapshot.active || event.key !== "Escape") return false;
341
+ event.preventDefault?.();
342
+ this.cancel("escape");
343
+ return true;
344
+ },
345
+ isActive() {
346
+ return !disposed && snapshot.active;
347
+ },
348
+ getSnapshot() {
349
+ return cloneSnapshot(snapshot);
350
+ },
351
+ dispose() {
352
+ if (disposed) return;
353
+ disposed = true;
354
+ releaseCapture();
355
+ snapshot = {
356
+ ...snapshot,
357
+ active: false
358
+ };
359
+ }
360
+ };
361
+ }
362
+
363
+ //#endregion
364
+ //#region src/element/roving-focus.ts
365
+ function isForwardKey(key, orientation) {
366
+ if (orientation === "horizontal") return key === "ArrowRight";
367
+ if (orientation === "vertical") return key === "ArrowDown";
368
+ return key === "ArrowRight" || key === "ArrowDown";
369
+ }
370
+ function isBackwardKey(key, orientation) {
371
+ if (orientation === "horizontal") return key === "ArrowLeft";
372
+ if (orientation === "vertical") return key === "ArrowUp";
373
+ return key === "ArrowLeft" || key === "ArrowUp";
374
+ }
375
+ function createRovingFocusController(options) {
376
+ const orientation = options.orientation ?? "horizontal";
377
+ const loop = options.loop ?? true;
378
+ const getEnabledItems = () => options.getItems().filter((item) => !item.disabled);
379
+ const resolveEffectiveActiveId = (enabled) => {
380
+ if (enabled.length === 0) return null;
381
+ const requested = options.getActiveId();
382
+ if (requested && enabled.some((item) => item.id === requested)) return requested;
383
+ return enabled[0]?.id ?? null;
384
+ };
385
+ return {
386
+ getTabIndex(itemId) {
387
+ const enabled = getEnabledItems();
388
+ const effectiveId = resolveEffectiveActiveId(enabled);
389
+ return effectiveId !== null && itemId === effectiveId ? 0 : -1;
390
+ },
391
+ handleKeyDown(currentId, event) {
392
+ const enabled = getEnabledItems();
393
+ if (enabled.length === 0) return null;
394
+ let target;
395
+ if (event.key === "Home") target = enabled[0];
396
+ else if (event.key === "End") target = enabled[enabled.length - 1];
397
+ else if (isForwardKey(event.key, orientation) || isBackwardKey(event.key, orientation)) {
398
+ const step = isForwardKey(event.key, orientation) ? 1 : -1;
399
+ const effectiveId = resolveEffectiveActiveId(enabled);
400
+ let idx = enabled.findIndex((item) => item.id === currentId);
401
+ if (idx < 0 && effectiveId !== null) idx = enabled.findIndex((item) => item.id === effectiveId);
402
+ if (idx < 0) idx = 0;
403
+ target = enabled[loop ? (idx + step + enabled.length) % enabled.length : Math.max(0, Math.min(enabled.length - 1, idx + step))];
404
+ } else return null;
405
+ if (!target) return null;
406
+ event.preventDefault?.();
407
+ options.onFocusChange?.(target.id);
408
+ return target.id;
409
+ }
410
+ };
411
+ }
412
+
413
+ //#endregion
414
+ //#region src/element/sync-action-pipeline.ts
415
+ function createSyncActionPipeline(name) {
416
+ const guards = /* @__PURE__ */ new Map();
417
+ const handlers = /* @__PURE__ */ new Map();
418
+ const observers = /* @__PURE__ */ new Map();
419
+ let nextSeq = 1;
420
+ let destroyed = false;
421
+ function addEntry(phaseMap, action, handler, config = {}) {
422
+ if (destroyed) throw new Error(`SyncActionPipeline '${name}' is destroyed`);
423
+ if (typeof handler !== "function") throw new TypeError("Handler must be a function");
424
+ const bucket = phaseMap.get(action) ?? [];
425
+ const entry = {
426
+ id: config.id ?? `${action}-${nextSeq}`,
427
+ seq: nextSeq++,
428
+ priority: config.priority ?? 0,
429
+ when: config.when ?? "success",
430
+ once: Boolean(config.once),
431
+ handler
432
+ };
433
+ const next = [...bucket, entry].sort((a, b) => b.priority - a.priority || a.seq - b.seq);
434
+ phaseMap.set(action, next);
435
+ return () => {
436
+ const current = phaseMap.get(action);
437
+ if (!current) return;
438
+ phaseMap.set(action, current.filter((item) => item !== entry));
439
+ };
440
+ }
441
+ function consumeOnce(phaseMap, action, entry) {
442
+ if (!entry.once) return;
443
+ const list = phaseMap.get(action);
444
+ if (list) phaseMap.set(action, list.filter((item) => item !== entry));
445
+ }
446
+ return {
447
+ name,
448
+ registerGuard(action, handler, config) {
449
+ return addEntry(guards, action, handler, config);
450
+ },
451
+ register(action, handler, config) {
452
+ return addEntry(handlers, action, handler, config);
453
+ },
454
+ registerObserver(action, handler, config) {
455
+ return addEntry(observers, action, handler, config);
456
+ },
457
+ dispatch(action, initialPayload) {
458
+ if (destroyed) throw new Error(`SyncActionPipeline '${name}' is destroyed`);
459
+ let currentPayload = initialPayload;
460
+ let aborted = false;
461
+ let abortReason;
462
+ let result;
463
+ const errors = [];
464
+ for (const entry of [...guards.get(action) ?? []]) {
465
+ consumeOnce(guards, action, entry);
466
+ let entryAborted = false;
467
+ const guardController = {
468
+ abort(reason) {
469
+ aborted = true;
470
+ entryAborted = true;
471
+ abortReason = reason;
472
+ },
473
+ modifyPayload(updater) {
474
+ currentPayload = typeof updater === "function" ? updater(currentPayload) : updater;
475
+ },
476
+ getPayload() {
477
+ return currentPayload;
478
+ }
479
+ };
480
+ try {
481
+ entry.handler(currentPayload, guardController);
482
+ } catch (error) {
483
+ aborted = true;
484
+ abortReason = error instanceof Error ? error.message : String(error);
485
+ errors.push(error);
486
+ }
487
+ if (aborted || entryAborted) break;
488
+ }
489
+ if (!aborted) for (const entry of [...handlers.get(action) ?? []]) {
490
+ consumeOnce(handlers, action, entry);
491
+ const execController = {
492
+ abort(reason) {
493
+ aborted = true;
494
+ abortReason = reason;
495
+ },
496
+ modifyPayload(updater) {
497
+ currentPayload = typeof updater === "function" ? updater(currentPayload) : updater;
498
+ },
499
+ getPayload() {
500
+ return currentPayload;
501
+ },
502
+ setResult(value) {
503
+ result = value;
504
+ },
505
+ getResult() {
506
+ return result;
507
+ }
508
+ };
509
+ try {
510
+ const ret = entry.handler(currentPayload, execController);
511
+ if (ret !== void 0) result = ret;
512
+ } catch (error) {
513
+ errors.push(error);
514
+ break;
515
+ }
516
+ if (aborted) break;
517
+ }
518
+ const success = !aborted && errors.length === 0;
519
+ for (const entry of [...observers.get(action) ?? []]) {
520
+ consumeOnce(observers, action, entry);
521
+ if (entry.when === "success" && !success) continue;
522
+ if (entry.when === "failure" && success) continue;
523
+ try {
524
+ entry.handler(currentPayload, {
525
+ success,
526
+ aborted,
527
+ abortReason,
528
+ result,
529
+ errors: [...errors]
530
+ });
531
+ } catch {}
532
+ }
533
+ return {
534
+ success,
535
+ aborted,
536
+ abortReason,
537
+ payload: currentPayload,
538
+ result,
539
+ errors
540
+ };
541
+ },
542
+ destroy() {
543
+ destroyed = true;
544
+ guards.clear();
545
+ handlers.clear();
546
+ observers.clear();
547
+ }
548
+ };
549
+ }
550
+
551
+ //#endregion
552
+ //#region src/element/to-react-part-props.ts
553
+ const ATTR_TO_REACT_PROP = {
554
+ class: "className",
555
+ for: "htmlFor",
556
+ tabindex: "tabIndex"
557
+ };
558
+ function toReactStyleProperty(cssProperty) {
559
+ if (cssProperty.startsWith("--")) return cssProperty;
560
+ return cssProperty.replace(/-([a-z])/g, (_, ch) => ch.toUpperCase());
561
+ }
562
+ /**
563
+ * Projects a headless part snapshot into React 19 JSX props using an ElementBindingConfig.
564
+ */
565
+ function toReactPartProps(snapshot, config = {}) {
566
+ const reactProps = {};
567
+ const attrEntries = Object.entries(config.attributes ?? {});
568
+ const styleEntries = Object.entries(config.styles ?? {});
569
+ const eventMap = config.events ?? {};
570
+ const record = snapshot;
571
+ for (const [propKey, attrName] of attrEntries) {
572
+ if (!attrName) continue;
573
+ const value = record[propKey];
574
+ if (value === void 0 || value === null || value === false) continue;
575
+ const reactKey = ATTR_TO_REACT_PROP[attrName] ?? attrName;
576
+ reactProps[reactKey] = value === true ? "" : value;
577
+ }
578
+ const styleObj = {};
579
+ let hasStyle = false;
580
+ for (const [propKey, cssProperty] of styleEntries) {
581
+ if (!cssProperty) continue;
582
+ const value = record[propKey];
583
+ if (value === void 0 || value === null || value === "") continue;
584
+ styleObj[toReactStyleProperty(cssProperty)] = String(value);
585
+ hasStyle = true;
586
+ }
587
+ if (hasStyle) reactProps.style = styleObj;
588
+ for (const propKey of Object.keys(eventMap)) {
589
+ const candidate = record[propKey];
590
+ if (typeof candidate === "function") reactProps[propKey] = candidate;
591
+ }
592
+ return reactProps;
593
+ }
594
+
595
+ //#endregion
596
+ Object.defineProperty(exports, 'createElementBinding', {
597
+ enumerable: true,
598
+ get: function () {
599
+ return createElementBinding;
600
+ }
601
+ });
602
+ Object.defineProperty(exports, 'createElementFacade', {
603
+ enumerable: true,
604
+ get: function () {
605
+ return createElementFacade;
606
+ }
607
+ });
608
+ Object.defineProperty(exports, 'createPointerGestureSession', {
609
+ enumerable: true,
610
+ get: function () {
611
+ return createPointerGestureSession;
612
+ }
613
+ });
614
+ Object.defineProperty(exports, 'createRovingFocusController', {
615
+ enumerable: true,
616
+ get: function () {
617
+ return createRovingFocusController;
618
+ }
619
+ });
620
+ Object.defineProperty(exports, 'createSyncActionPipeline', {
621
+ enumerable: true,
622
+ get: function () {
623
+ return createSyncActionPipeline;
624
+ }
625
+ });
626
+ Object.defineProperty(exports, 'toReactPartProps', {
627
+ enumerable: true,
628
+ get: function () {
629
+ return toReactPartProps;
630
+ }
631
+ });