@wardic/dom 0.0.0-stage → 1.0.0-rc.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 the Wardic contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,9 @@
-# Temporary Holding Version
+# @wardic/dom
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The browser environment for [Wardic](https://wardic.dev): its clock on `requestAnimationFrame`, the renderer that writes styles, pointer, keyboard and focus input, the probe that reads the page, and the projection system behind layout animations, as Effect Layers.
+
+[`@wardic/solid`](https://www.npmjs.com/package/@wardic/solid) brings it; install it yourself only to build a binding of your own.
+
+- Docs: https://wardic.dev
+- Source: https://github.com/wardiclabs/wardic/tree/main/packages/dom
+- Licence: MIT

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,145 @@
+# Third-party notices
+
+Wardic follows the API of [Motion](https://motion.dev) for React, and parts of its source are ported from Motion's: rewritten in Wardic's own style, keeping Motion's algorithms, formulas and constants so the results match. Motion is MIT licensed, and its notice follows.
+
+## Motion
+
+https://github.com/motiondivision/motion
+
+Ported from Motion's source:
+
+- `@wardic/core`:
+  - `Box` and `Projection`: the projection geometry (`motion-dom`'s `projection/geometry`: `models`, `delta-calc`, `delta-apply`, `applyTreeDeltas`);
+  - `Spring`: the solver for a spring's stiffness and damping from its duration and bounce (`findSpring`);
+  - `Velocity`: a gesture's velocity from its points (`getVelocity`);
+  - `Reorder`: moving an item, and the axis a list runs on (`moveItem`, `detectAxis`);
+  - `AutoScroll`: scrolling a container while an item is dragged near its edge (`autoScrollIfNeeded`).
+- `@wardic/dom`:
+  - the projection transform (`buildProjectionTransform`);
+  - the scroll offsets (`render/dom/scroll/offsets`).
+
+```
+The MIT License (MIT)
+
+Copyright (c) 2024 [Motion](https://motion.dev) B.V.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```
+
+## Manrope
+
+https://github.com/googlefonts/manrope
+
+The docs site serves Manrope for its headings (`site/public/fonts/manrope-latin.woff2`, its variable weights 600 to 800, Latin only, with its licence beside it as `OFL.txt`), and Wardic's wordmark is "wardic" set in Manrope ExtraBold and outlined (`brand/`, and the docs header's logo, `site/src/components/logo-paths.ts`). Manrope is licensed under the SIL Open Font License, Version 1.1.
+
+```
+Copyright 2018 The Manrope Project Authors (https://github.com/googlefonts/manrope)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
+```

package/dist/Appear.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Appear animations: a mount animation a server renders as CSS, played from the first paint, before any
+ * code runs, which the engine takes over at mount from where it has got to. The DOM's half, for any
+ * binding:
+ * - **On a server:** `keyframes` samples an element's spec, its mount animation built with core's
+ *   machines, into one `@keyframes` rule, cached across requests. A render's `sheet` gives each element a
+ *   slot, whose `animation` goes in its inline style, and writes the head's `<style>` once every slot's
+ *   timing is defined.
+ * - **At mount:** `find` the element's animation, check it `matches` the client's own spec, start the run
+ *   `elapsedOf` it in (`Machine.startAt`), and `release` the element in the task that writes the engine's
+ *   first frame.
+ *
+ * @example
+ * import * as Appear from "@wardic/dom/Appear"
+ *
+ * // On a server, a sheet a render:
+ * const render = Appear.sheet()
+ * const slot = render.slot()
+ * slot.define({ spec, delay: 0 }) // `slot.animation` goes in the element's style, `render.css()` in the head
+ * // At mount:
+ * const elapsed = Option.map(Appear.find(element), Appear.elapsedOf)
+ */
+export { adoptChunks, animationOf, CHUNK_ATTRIBUTE, chunkStyle, delayOf, elapsedOf, find, keyframes, type Keyframes, matches, MAX_SECONDS, nameOf, pending, type Play, PREFIX, release, sheet, type Sheet, type Slot, type Spec, } from "./internal/appear.ts";
+//# sourceMappingURL=Appear.d.ts.map

package/dist/Appear.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Appear.d.ts","sourceRoot":"","sources":["../src/Appear.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EACL,WAAW,EACX,WAAW,EACX,eAAe,EACf,UAAU,EACV,OAAO,EACP,SAAS,EACT,IAAI,EACJ,SAAS,EACT,KAAK,SAAS,EACd,OAAO,EACP,WAAW,EACX,MAAM,EACN,OAAO,EACP,KAAK,IAAI,EACT,MAAM,EACN,OAAO,EACP,KAAK,EACL,KAAK,KAAK,EACV,KAAK,IAAI,EACT,KAAK,IAAI,GACV,MAAM,sBAAsB,CAAA"}

package/dist/Appear.js

@@ -0,0 +1,25 @@
+/**
+ * Appear animations: a mount animation a server renders as CSS, played from the first paint, before any
+ * code runs, which the engine takes over at mount from where it has got to. The DOM's half, for any
+ * binding:
+ * - **On a server:** `keyframes` samples an element's spec, its mount animation built with core's
+ *   machines, into one `@keyframes` rule, cached across requests. A render's `sheet` gives each element a
+ *   slot, whose `animation` goes in its inline style, and writes the head's `<style>` once every slot's
+ *   timing is defined.
+ * - **At mount:** `find` the element's animation, check it `matches` the client's own spec, start the run
+ *   `elapsedOf` it in (`Machine.startAt`), and `release` the element in the task that writes the engine's
+ *   first frame.
+ *
+ * @example
+ * import * as Appear from "@wardic/dom/Appear"
+ *
+ * // On a server, a sheet a render:
+ * const render = Appear.sheet()
+ * const slot = render.slot()
+ * slot.define({ spec, delay: 0 }) // `slot.animation` goes in the element's style, `render.css()` in the head
+ * // At mount:
+ * const elapsed = Option.map(Appear.find(element), Appear.elapsedOf)
+ */
+// #48, ADR-0044: the **Handoff**. `@wardic/dom/Appear` (ADR-0041).
+export { adoptChunks, animationOf, CHUNK_ATTRIBUTE, chunkStyle, delayOf, elapsedOf, find, keyframes, matches, MAX_SECONDS, nameOf, pending, PREFIX, release, sheet, } from "./internal/appear.js";
+//# sourceMappingURL=Appear.js.map

package/dist/Appear.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Appear.js","sourceRoot":"","sources":["../src/Appear.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,mEAAmE;AACnE,OAAO,EACL,WAAW,EACX,WAAW,EACX,eAAe,EACf,UAAU,EACV,OAAO,EACP,SAAS,EACT,IAAI,EACJ,SAAS,EAET,OAAO,EACP,WAAW,EACX,MAAM,EACN,OAAO,EAEP,MAAM,EACN,OAAO,EACP,KAAK,GAIN,MAAM,sBAAsB,CAAA"}

package/dist/Color.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CSS colours: `parse` reads a colour string, `format` writes one, `interpolator` blends two in a colour
+ * space, and `TOKEN` finds a colour inside a longer value, a shadow's say. A hex, `rgb()`, `hsl()` and the
+ * named colours are colours from the start; `registerSpaces` adds every other CSS colour space, so
+ * `oklch()` and `lab()` are colours too, and `interpolator("oklch")` can blend in it.
+ *
+ * @example
+ * import * as Color from "@wardic/dom/Color"
+ *
+ * Color.parse("#bf616a") // Some({ mode: "rgb", r: 0.749, g: 0.38, b: 0.416 })
+ * Color.format({ mode: "rgb", r: 1, g: 0.5, b: 0 }) // "rgb(255, 128, 0)"
+ */
+export { color as interpolator, cssColor as css, type Color, formatColor as format, parseColor as parse, COLOR_TOKEN as TOKEN, registerSpaces, spacesRegistered, } from "./internal/colors.ts";
+//# sourceMappingURL=Color.d.ts.map

package/dist/Color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Color.d.ts","sourceRoot":"","sources":["../src/Color.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,EACL,KAAK,IAAI,YAAY,EACrB,QAAQ,IAAI,GAAG,EACf,KAAK,KAAK,EACV,WAAW,IAAI,MAAM,EACrB,UAAU,IAAI,KAAK,EACnB,WAAW,IAAI,KAAK,EACpB,cAAc,EACd,gBAAgB,GACjB,MAAM,sBAAsB,CAAA"}

package/dist/Color.js

@@ -0,0 +1,16 @@
+/**
+ * CSS colours: `parse` reads a colour string, `format` writes one, `interpolator` blends two in a colour
+ * space, and `TOKEN` finds a colour inside a longer value, a shadow's say. A hex, `rgb()`, `hsl()` and the
+ * named colours are colours from the start; `registerSpaces` adds every other CSS colour space, so
+ * `oklch()` and `lab()` are colours too, and `interpolator("oklch")` can blend in it.
+ *
+ * @example
+ * import * as Color from "@wardic/dom/Color"
+ *
+ * Color.parse("#bf616a") // Some({ mode: "rgb", r: 0.749, g: 0.38, b: 0.416 })
+ * Color.format({ mode: "rgb", r: 1, g: 0.5, b: 0 }) // "rgb(255, 128, 0)"
+ */
+// `@wardic/dom/Color` (#132, ADR-0041): a colour Interpolator in a culori mode, the DOM's own (`css`,
+// sRGB), its `parse` and `format`, and its token (ADR-0024, ADR-0026); `registerSpaces` (#511).
+export { color as interpolator, cssColor as css, formatColor as format, parseColor as parse, COLOR_TOKEN as TOKEN, registerSpaces, spacesRegistered, } from "./internal/colors.js";
+//# sourceMappingURL=Color.js.map

package/dist/Color.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Color.js","sourceRoot":"","sources":["../src/Color.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,sGAAsG;AACtG,gGAAgG;AAChG,OAAO,EACL,KAAK,IAAI,YAAY,EACrB,QAAQ,IAAI,GAAG,EAEf,WAAW,IAAI,MAAM,EACrB,UAAU,IAAI,KAAK,EACnB,WAAW,IAAI,KAAK,EACpB,cAAc,EACd,gBAAgB,GACjB,MAAM,sBAAsB,CAAA"}

package/dist/DomAnnouncer.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The DOM's Announcer: a shared live region, an element a screen reader watches and reads out as its
+ * text changes, and the helpers a binding uses to describe a Reorder group's items to one. `layer` is
+ * what `DomLive` provides; `prepare` and `announceIn` work on any document.
+ *
+ * @example
+ * import * as DomAnnouncer from "@wardic/dom/DomAnnouncer"
+ *
+ * DomAnnouncer.prepare(document) // its live region, before the first announcement
+ * DomAnnouncer.announceIn(document, "Picked up Milk, position 2 of 5.")
+ */
+export { AnnouncerDomLive as layer, ANNOUNCER_ATTRIBUTE as ATTRIBUTE, documentOf, instructionsId, instructionsIdOf, showInstructions, prepareAnnouncer as prepare, announceIn, } from "./internal/announcer.ts";
+//# sourceMappingURL=DomAnnouncer.d.ts.map

package/dist/DomAnnouncer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomAnnouncer.d.ts","sourceRoot":"","sources":["../src/DomAnnouncer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,gBAAgB,IAAI,KAAK,EACzB,mBAAmB,IAAI,SAAS,EAChC,UAAU,EACV,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,IAAI,OAAO,EAC3B,UAAU,GACX,MAAM,yBAAyB,CAAA"}

package/dist/DomAnnouncer.js

@@ -0,0 +1,14 @@
+/**
+ * The DOM's Announcer: a shared live region, an element a screen reader watches and reads out as its
+ * text changes, and the helpers a binding uses to describe a Reorder group's items to one. `layer` is
+ * what `DomLive` provides; `prepare` and `announceIn` work on any document.
+ *
+ * @example
+ * import * as DomAnnouncer from "@wardic/dom/DomAnnouncer"
+ *
+ * DomAnnouncer.prepare(document) // its live region, before the first announcement
+ * DomAnnouncer.announceIn(document, "Picked up Milk, position 2 of 5.")
+ */
+// `@wardic/dom/DomAnnouncer` (#132, ADR-0041): a shared assertive live region (ADR-0037).
+export { AnnouncerDomLive as layer, ANNOUNCER_ATTRIBUTE as ATTRIBUTE, documentOf, instructionsId, instructionsIdOf, showInstructions, prepareAnnouncer as prepare, announceIn, } from "./internal/announcer.js";
+//# sourceMappingURL=DomAnnouncer.js.map

package/dist/DomAnnouncer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomAnnouncer.js","sourceRoot":"","sources":["../src/DomAnnouncer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,0FAA0F;AAC1F,OAAO,EACL,gBAAgB,IAAI,KAAK,EACzB,mBAAmB,IAAI,SAAS,EAChC,UAAU,EACV,cAAc,EACd,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,IAAI,OAAO,EAC3B,UAAU,GACX,MAAM,yBAAyB,CAAA"}

package/dist/DomClock.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The DOM's Clock: core's Clock and its Refresh frame source over the browser's `requestAnimationFrame`,
+ * as one Layer that needs nothing. `DomLive` provides it.
+ *
+ * @example
+ * import * as DomClock from "@wardic/dom/DomClock"
+ *
+ * const now = Effect.map(Clock.Clock, (clock) => clock.now()).pipe(Effect.provide(DomClock.layer))
+ */
+export { ClockDomLive as layer, } from "./internal/clock.ts";
+//# sourceMappingURL=DomClock.d.ts.map

package/dist/DomClock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomClock.d.ts","sourceRoot":"","sources":["../src/DomClock.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,YAAY,IAAI,KAAK,GACtB,MAAM,qBAAqB,CAAA"}

package/dist/DomClock.js

@@ -0,0 +1,12 @@
+/**
+ * The DOM's Clock: core's Clock and its Refresh frame source over the browser's `requestAnimationFrame`,
+ * as one Layer that needs nothing. `DomLive` provides it.
+ *
+ * @example
+ * import * as DomClock from "@wardic/dom/DomClock"
+ *
+ * const now = Effect.map(Clock.Clock, (clock) => clock.now()).pipe(Effect.provide(DomClock.layer))
+ */
+// `@wardic/dom/DomClock` (#132, ADR-0041): rAF-driven (ADR-0031).
+export { ClockDomLive as layer, } from "./internal/clock.js";
+//# sourceMappingURL=DomClock.js.map

package/dist/DomClock.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomClock.js","sourceRoot":"","sources":["../src/DomClock.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,kEAAkE;AAClE,OAAO,EACL,YAAY,IAAI,KAAK,GACtB,MAAM,qBAAqB,CAAA"}

package/dist/DomDefaultTransition.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The DOM's Default transition, Motion's by value: a spring for the transforms, a 0.3 s ease for the
+ * rest, and a 0.8 s tween through more than two keyframes. `layer` is what `DomLive` provides.
+ *
+ * @example
+ * import * as DomDefaultTransition from "@wardic/dom/DomDefaultTransition"
+ *
+ * DomDefaultTransition.transitionFor("x", 100) // { type: "spring", stiffness: 500, damping: 25, restSpeed: 10 }
+ * DomDefaultTransition.transitionFor("opacity", 1) // a 0.3 s tween
+ */
+export { DefaultTransitionDomLive as layer, keyframes, transitionFor, } from "./internal/default-transition.ts";
+//# sourceMappingURL=DomDefaultTransition.d.ts.map

package/dist/DomDefaultTransition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomDefaultTransition.d.ts","sourceRoot":"","sources":["../src/DomDefaultTransition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACL,wBAAwB,IAAI,KAAK,EACjC,SAAS,EACT,aAAa,GACd,MAAM,kCAAkC,CAAA"}

package/dist/DomDefaultTransition.js

@@ -0,0 +1,13 @@
+/**
+ * The DOM's Default transition, Motion's by value: a spring for the transforms, a 0.3 s ease for the
+ * rest, and a 0.8 s tween through more than two keyframes. `layer` is what `DomLive` provides.
+ *
+ * @example
+ * import * as DomDefaultTransition from "@wardic/dom/DomDefaultTransition"
+ *
+ * DomDefaultTransition.transitionFor("x", 100) // { type: "spring", stiffness: 500, damping: 25, restSpeed: 10 }
+ * DomDefaultTransition.transitionFor("opacity", 1) // a 0.3 s tween
+ */
+// `@wardic/dom/DomDefaultTransition` (#132, ADR-0041): ADR-0051, #357; keyframes #429.
+export { DefaultTransitionDomLive as layer, keyframes, transitionFor, } from "./internal/default-transition.js";
+//# sourceMappingURL=DomDefaultTransition.js.map

package/dist/DomDefaultTransition.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomDefaultTransition.js","sourceRoot":"","sources":["../src/DomDefaultTransition.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,uFAAuF;AACvF,OAAO,EACL,wBAAwB,IAAI,KAAK,EACjC,SAAS,EACT,aAAa,GACd,MAAM,kCAAkC,CAAA"}

package/dist/DomInput.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The DOM's InputSource: pointer, keyboard and focus events as core's own, mapped from the DOM's names by
+ * `toPointer`, `keyOf`, `kindOf` and `buttonOf`. It isn't in `DomLive`: a binding builds `layer` with the
+ * first gesture an app uses, so an app with none ships no input code.
+ *
+ * @example
+ * import * as DomInput from "@wardic/dom/DomInput"
+ *
+ * DomInput.keyOf("ArrowLeft") // "left"
+ * DomInput.buttonOf(2) // "secondary"
+ */
+export { InputDomLive as layer, keyOf, kindOf, makeFocusable, buttonOf, toPointer, type Where, } from "./internal/input.ts";
+//# sourceMappingURL=DomInput.d.ts.map

package/dist/DomInput.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomInput.d.ts","sourceRoot":"","sources":["../src/DomInput.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,EACL,YAAY,IAAI,KAAK,EACrB,KAAK,EACL,MAAM,EACN,aAAa,EACb,QAAQ,EACR,SAAS,EACT,KAAK,KAAK,GACX,MAAM,qBAAqB,CAAA"}

package/dist/DomInput.js

@@ -0,0 +1,15 @@
+/**
+ * The DOM's InputSource: pointer, keyboard and focus events as core's own, mapped from the DOM's names by
+ * `toPointer`, `keyOf`, `kindOf` and `buttonOf`. It isn't in `DomLive`: a binding builds `layer` with the
+ * first gesture an app uses, so an app with none ships no input code.
+ *
+ * @example
+ * import * as DomInput from "@wardic/dom/DomInput"
+ *
+ * DomInput.keyOf("ArrowLeft") // "left"
+ * DomInput.buttonOf(2) // "secondary"
+ */
+// `@wardic/dom/DomInput` (#132, ADR-0041): ADR-0019, ADR-0036 *Amendment (#189)*, ADR-0037. Not in
+// `DomLive`: #511, ADR-0067 decision 14.
+export { InputDomLive as layer, keyOf, kindOf, makeFocusable, buttonOf, toPointer, } from "./internal/input.js";
+//# sourceMappingURL=DomInput.js.map

package/dist/DomInput.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomInput.js","sourceRoot":"","sources":["../src/DomInput.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,mGAAmG;AACnG,yCAAyC;AACzC,OAAO,EACL,YAAY,IAAI,KAAK,EACrB,KAAK,EACL,MAAM,EACN,aAAa,EACb,QAAQ,EACR,SAAS,GAEV,MAAM,qBAAqB,CAAA"}

package/dist/DomInterpolators.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The DOM's InterpolatorRegistry: core's value kinds with the DOM's colours and complex values, and the
+ * DOM's Key rules. `layer` is what `DomLive` provides; `all` is its kinds, in the order they're tried.
+ *
+ * @example
+ * import * as DomInterpolators from "@wardic/dom/DomInterpolators"
+ *
+ * const registry = yield* InterpolatorRegistry.make(DomInterpolators.all, DomKeyRules.all)
+ * const blend = yield* registry.resolve("#bf616a", "#a3be8c")
+ * blend(0.5) // the colour halfway
+ */
+export { InterpolatorRegistryDomLive as layer, interpolators as all, } from "./internal/interpolators.ts";
+//# sourceMappingURL=DomInterpolators.d.ts.map

package/dist/DomInterpolators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomInterpolators.d.ts","sourceRoot":"","sources":["../src/DomInterpolators.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,2BAA2B,IAAI,KAAK,EACpC,aAAa,IAAI,GAAG,GACrB,MAAM,6BAA6B,CAAA"}

package/dist/DomInterpolators.js

@@ -0,0 +1,14 @@
+/**
+ * The DOM's InterpolatorRegistry: core's value kinds with the DOM's colours and complex values, and the
+ * DOM's Key rules. `layer` is what `DomLive` provides; `all` is its kinds, in the order they're tried.
+ *
+ * @example
+ * import * as DomInterpolators from "@wardic/dom/DomInterpolators"
+ *
+ * const registry = yield* InterpolatorRegistry.make(DomInterpolators.all, DomKeyRules.all)
+ * const blend = yield* registry.resolve("#bf616a", "#a3be8c")
+ * blend(0.5) // the colour halfway
+ */
+// `@wardic/dom/DomInterpolators` (#132, ADR-0041): ADR-0024, ADR-0035, ADR-0036.
+export { InterpolatorRegistryDomLive as layer, interpolators as all, } from "./internal/interpolators.js";
+//# sourceMappingURL=DomInterpolators.js.map

package/dist/DomInterpolators.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomInterpolators.js","sourceRoot":"","sources":["../src/DomInterpolators.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,iFAAiF;AACjF,OAAO,EACL,2BAA2B,IAAI,KAAK,EACpC,aAAa,IAAI,GAAG,GACrB,MAAM,6BAA6B,CAAA"}

package/dist/DomKeyRules.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The DOM's Key rules, for the keys it blends by name. `visibility` keeps `display` and `visibility` at
+ * their start until an animation's last frame when they're hiding the element, and `animatableNone`
+ * grows a shadow, a filter or a fill from nothing when one end is empty. `all` is both, in the order
+ * they're asked.
+ *
+ * @example
+ * import * as DomKeyRules from "@wardic/dom/DomKeyRules"
+ *
+ * const registry = yield* InterpolatorRegistry.make(DomInterpolators.all, [DomKeyRules.visibility])
+ */
+export { keyRules as all, visibility, animatableNone, } from "./internal/key-rules.ts";
+//# sourceMappingURL=DomKeyRules.d.ts.map

package/dist/DomKeyRules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomKeyRules.d.ts","sourceRoot":"","sources":["../src/DomKeyRules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,QAAQ,IAAI,GAAG,EACf,UAAU,EACV,cAAc,GACf,MAAM,yBAAyB,CAAA"}

package/dist/DomKeyRules.js

@@ -0,0 +1,14 @@
+/**
+ * The DOM's Key rules, for the keys it blends by name. `visibility` keeps `display` and `visibility` at
+ * their start until an animation's last frame when they're hiding the element, and `animatableNone`
+ * grows a shadow, a filter or a fill from nothing when one end is empty. `all` is both, in the order
+ * they're asked.
+ *
+ * @example
+ * import * as DomKeyRules from "@wardic/dom/DomKeyRules"
+ *
+ * const registry = yield* InterpolatorRegistry.make(DomInterpolators.all, [DomKeyRules.visibility])
+ */
+// `@wardic/dom/DomKeyRules` (#132, ADR-0041): ADR-0015, ADR-0035.
+export { keyRules as all, visibility, animatableNone, } from "./internal/key-rules.js";
+//# sourceMappingURL=DomKeyRules.js.map

package/dist/DomKeyRules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomKeyRules.js","sourceRoot":"","sources":["../src/DomKeyRules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,kEAAkE;AAClE,OAAO,EACL,QAAQ,IAAI,GAAG,EACf,UAAU,EACV,cAAc,GACf,MAAM,yBAAyB,CAAA"}

package/dist/DomPositionalKeys.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The DOM's Positional keys, the keys reduced motion lands at once rather than animating: the
+ * transforms, and the keys that place and size an element's box, `top`, `width` and the rest. `layer`
+ * is what `DomLive` provides.
+ *
+ * @example
+ * import * as DomPositionalKeys from "@wardic/dom/DomPositionalKeys"
+ *
+ * DomPositionalKeys.isPositional("width") // true: it lands at once
+ * DomPositionalKeys.isPositional("opacity") // false: it still fades
+ */
+export { PositionalKeysDomLive as layer, isPositional, } from "./internal/positional-keys.ts";
+//# sourceMappingURL=DomPositionalKeys.d.ts.map

package/dist/DomPositionalKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomPositionalKeys.d.ts","sourceRoot":"","sources":["../src/DomPositionalKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,qBAAqB,IAAI,KAAK,EAC9B,YAAY,GACb,MAAM,+BAA+B,CAAA"}

package/dist/DomPositionalKeys.js

@@ -0,0 +1,14 @@
+/**
+ * The DOM's Positional keys, the keys reduced motion lands at once rather than animating: the
+ * transforms, and the keys that place and size an element's box, `top`, `width` and the rest. `layer`
+ * is what `DomLive` provides.
+ *
+ * @example
+ * import * as DomPositionalKeys from "@wardic/dom/DomPositionalKeys"
+ *
+ * DomPositionalKeys.isPositional("width") // true: it lands at once
+ * DomPositionalKeys.isPositional("opacity") // false: it still fades
+ */
+// `@wardic/dom/DomPositionalKeys` (#132, ADR-0041): ADR-0029, ADR-0036.
+export { PositionalKeysDomLive as layer, isPositional, } from "./internal/positional-keys.js";
+//# sourceMappingURL=DomPositionalKeys.js.map

package/dist/DomPositionalKeys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomPositionalKeys.js","sourceRoot":"","sources":["../src/DomPositionalKeys.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wEAAwE;AACxE,OAAO,EACL,qBAAqB,IAAI,KAAK,EAC9B,YAAY,GACb,MAAM,+BAA+B,CAAA"}

package/dist/DomProbe.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The DOM's Probe: boxes from `getBoundingClientRect`, sizes and visibility from the observers, the
+ * viewport, the reduced-motion preference from `matchMedia`, whether the page is shown, and a container's
+ * scroll. `layer` needs the Environment's `AtomRegistry`, which it writes its live values through;
+ * `DomLive` provides both.
+ *
+ * @example
+ * import * as DomProbe from "@wardic/dom/DomProbe"
+ *
+ * const probe = DomProbe.layer.pipe(Layer.provide(AtomRegistry.layer))
+ */
+export { ProbeDomLive as layer, } from "./internal/probe.ts";
+//# sourceMappingURL=DomProbe.d.ts.map

package/dist/DomProbe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomProbe.d.ts","sourceRoot":"","sources":["../src/DomProbe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EACL,YAAY,IAAI,KAAK,GACtB,MAAM,qBAAqB,CAAA"}

package/dist/DomProbe.js

@@ -0,0 +1,14 @@
+/**
+ * The DOM's Probe: boxes from `getBoundingClientRect`, sizes and visibility from the observers, the
+ * viewport, the reduced-motion preference from `matchMedia`, whether the page is shown, and a container's
+ * scroll. `layer` needs the Environment's `AtomRegistry`, which it writes its live values through;
+ * `DomLive` provides both.
+ *
+ * @example
+ * import * as DomProbe from "@wardic/dom/DomProbe"
+ *
+ * const probe = DomProbe.layer.pipe(Layer.provide(AtomRegistry.layer))
+ */
+// `@wardic/dom/DomProbe` (#132, ADR-0041).
+export { ProbeDomLive as layer, } from "./internal/probe.js";
+//# sourceMappingURL=DomProbe.js.map

package/dist/DomProbe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomProbe.js","sourceRoot":"","sources":["../src/DomProbe.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,2CAA2C;AAC3C,OAAO,EACL,YAAY,IAAI,KAAK,GACtB,MAAM,qBAAqB,CAAA"}

package/dist/DomProjectionSystem.d.ts

@@ -0,0 +1,28 @@
+/**
+ * The DOM's Projection system: `layer` builds it, writing through the Environment's
+ * `FlushGate`, and `make` builds it over any sink, for a binding that wires it itself. Only a binding's
+ * layout feature imports it, so a page that never lays out ships none of it. Closing its Scope stops the
+ * engine: its run, its observers and listeners, and what it forked. Built after the gate, it ends before
+ * it.
+ *
+ * @example
+ * import * as DomProjectionSystem from "@wardic/dom/DomProjectionSystem"
+ *
+ * const layout = DomProjectionSystem.layer().pipe(Layer.provide(FlushGate.layer({ batch: (apply) => apply() })))
+ */
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import type * as Scope from "effect/Scope";
+import * as FlushGate from "./FlushGate.ts";
+import { PassEnds } from "./internal/pass-ends.ts";
+import { ProjectionSystem, type Options, type Services, type Sink } from "./ProjectionSystem.ts";
+/**
+ * Build the engine over `sink`, the context's Frame loop and Renderer, in the current Scope: what
+ * it forks runs in that Scope, and closing it ends the engine. It's the `ProjectionSystem` in the
+ * context it gives, beside what a Reorder controller over it needs.
+ */
+export declare const make: (sink: Sink, options?: Options) => Effect.Effect<Context.Context<ProjectionSystem | PassEnds>, never, Services | Scope.Scope>;
+/** The engine as a Layer, writing through the Environment's `FlushGate`: built by `make`, ended by the Layer's Scope. */
+export declare const layer: (options?: Options) => Layer.Layer<ProjectionSystem | PassEnds, never, FlushGate.FlushGate | Services>;
+//# sourceMappingURL=DomProjectionSystem.d.ts.map

package/dist/DomProjectionSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DomProjectionSystem.d.ts","sourceRoot":"","sources":["../src/DomProjectionSystem.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAGH,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAA;AAC1C,OAAO,KAAK,SAAS,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAGlD,OAAO,EAAE,gBAAgB,EAAE,KAAK,OAAO,EAAE,KAAK,QAAQ,EAAc,KAAK,IAAI,EAAE,MAAM,uBAAuB,CAAA;AAE5G;;;;GAIG;AAKH,eAAO,MAAM,IAAI,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,gBAAgB,GAAG,QAAQ,CAAC,EAAE,KAAK,EAAE,QAAQ,GAAG,KAAK,CAAC,KAAK,CAM3I,CAAA;AAEJ,yHAAyH;AACzH,eAAO,MAAM,KAAK,aAAa,OAAO,KAAQ,KAAK,CAAC,KAAK,CAAC,gBAAgB,GAAG,QAAQ,EAAE,KAAK,EAAE,SAAS,CAAC,SAAS,GAAG,QAAQ,CACnB,CAAA"}