ballerina-core 1.0.200 → 1.0.201

package/bin/src/infinite-data-stream/coroutines/infiniteLoader.js

@@ -1,27 +1,54 @@
 import { AsyncState } from "../../async/state";
 import { replaceWith } from "../../fun/domains/updater/domains/replaceWith/state";
-import { InfiniteStreamState, StreamPosition, } from "../state";
+import { InfiniteStreamState, StreamPosition } from "../state";
 import { StreamCo } from "./builder";
 export const InfiniteStreamLoader = (maxRetries = 3) => {
-    const Co = StreamCo();
-    const updaters = InfiniteStreamState().Updaters;
-    const attemptLoad = (retryCount = 0) => Co.GetState().then((current) => {
-        if (current.loadingMore.kind === "loaded") {
-            return Co.Return(true);
-        }
-        return Co.Await(() => current.getChunk([current.position]), () => "error").then((apiResult) => apiResult.kind === "l"
-            ? Co.SetState(updaters.Core.loadingMore(replaceWith(AsyncState.Default.loaded({}))).then(updaters.Coroutine.addLoadedChunk(current.position.chunkIndex, apiResult.value).then(updaters.Core.position(StreamPosition.Updaters.Core.shouldLoad(replaceWith(false))))))
-            : retryCount < maxRetries
-                ? Co.Wait(500).then(() => attemptLoad(retryCount + 1))
-                : Co.Return(false));
+  const Co = StreamCo();
+  const updaters = InfiniteStreamState().Updaters;
+  const attemptLoad = (retryCount = 0) =>
+    Co.GetState().then((current) => {
+      if (current.loadingMore.kind === "loaded") {
+        return Co.Return(true);
+      }
+      return Co.Await(
+        () => current.getChunk([current.position]),
+        () => "error",
+      ).then((apiResult) =>
+        apiResult.kind === "l"
+          ? Co.SetState(
+              updaters.Core.loadingMore(
+                replaceWith(AsyncState.Default.loaded({})),
+              ).then(
+                updaters.Coroutine.addLoadedChunk(
+                  current.position.chunkIndex,
+                  apiResult.value,
+                ).then(
+                  updaters.Core.position(
+                    StreamPosition.Updaters.Core.shouldLoad(replaceWith(false)),
+                  ),
+                ),
+              ),
+            )
+          : retryCount < maxRetries
+            ? Co.Wait(500).then(() => attemptLoad(retryCount + 1))
+            : Co.Return(false),
+      );
     });
-    return Co.Seq([
-        Co.SetState(updaters.Core.loadingMore(replaceWith(AsyncState.Default.loading()))),
-        attemptLoad(),
-        Co.GetState().then((current) => current.loadingMore.kind !== "loaded"
-            ? Co.SetState(updaters.Core.loadingMore(replaceWith(AsyncState.Default.error("max retries reached"))))
-            : Co.Wait(0)),
-    ]);
+  return Co.Seq([
+    Co.SetState(
+      updaters.Core.loadingMore(replaceWith(AsyncState.Default.loading())),
+    ),
+    attemptLoad(),
+    Co.GetState().then((current) =>
+      current.loadingMore.kind !== "loaded"
+        ? Co.SetState(
+            updaters.Core.loadingMore(
+              replaceWith(AsyncState.Default.error("max retries reached")),
+            ),
+          )
+        : Co.Wait(0),
+    ),
+  ]);
 };
 export const Loader = InfiniteStreamLoader;
-//# sourceMappingURL=infiniteLoader.js.map
+//# sourceMappingURL=infiniteLoader.js.map

package/bin/src/infinite-data-stream/coroutines/runner.d.ts

@@ -1,5 +1,13 @@
 import { InfiniteStreamWritableState } from "../state";
-export declare const StreamDataLoader: <Element extends {
+export declare const StreamDataLoader: <
+  Element extends {
     Id: string;
-}, foreignMutations>() => import("../../template/state").Template<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, foreignMutations, import("../../../main").Unit>;
-//# sourceMappingURL=runner.d.ts.map
+  },
+  foreignMutations,
+>() => import("../../template/state").Template<
+  InfiniteStreamWritableState<Element>,
+  InfiniteStreamWritableState<Element>,
+  foreignMutations,
+  import("../../../main").Unit
+>;
+//# sourceMappingURL=runner.d.ts.map

package/bin/src/infinite-data-stream/coroutines/runner.js

@@ -1,11 +1,11 @@
-import { InfiniteStreamState, } from "../state";
+import { InfiniteStreamState } from "../state";
 import { StreamCo } from "./builder";
 import { Loader } from "./infiniteLoader";
 export const StreamDataLoader = () => {
-    const operations = InfiniteStreamState().Operations;
-    const LoaderTemplate = StreamCo().Template(Loader(), {
-        runFilter: (props) => operations.shouldCoroutineRun(props.context),
-    });
-    return LoaderTemplate.mapContext((_) => _);
+  const operations = InfiniteStreamState().Operations;
+  const LoaderTemplate = StreamCo().Template(Loader(), {
+    runFilter: (props) => operations.shouldCoroutineRun(props.context),
+  });
+  return LoaderTemplate.mapContext((_) => _);
 };
-//# sourceMappingURL=runner.js.map
+//# sourceMappingURL=runner.js.map

package/bin/src/infinite-data-stream/state.d.ts

@@ -5,73 +5,106 @@ import { Unit } from "../fun/domains/unit/state";
 import { BasicFun } from "../fun/state";
 export type StreamingStatus = "reload" | "loadMore" | false;
 type Identifiable = {
-    Id: string;
+  Id: string;
 };
 export type StreamPosition = {
-    chunkSize: number;
-    chunkIndex: number;
-    shouldLoad: StreamingStatus;
-    lastModifiedTime: number;
+  chunkSize: number;
+  chunkIndex: number;
+  shouldLoad: StreamingStatus;
+  lastModifiedTime: number;
 };
 export declare const StreamPosition: {
-    Default: (initialChunkSize: number, shouldLoad?: StreamingStatus) => StreamPosition;
-    Updaters: {
-        Template: {
-            loadInitial: () => Updater<StreamPosition>;
-            changeChunkSize: (chunkSize: number) => Updater<StreamPosition>;
-            reload: () => Updater<StreamPosition>;
-            loadMore: () => Updater<StreamPosition>;
-        };
-        Core: {
-            chunkSize: import("../../main").Widening<StreamPosition, "chunkSize">;
-            chunkIndex: import("../../main").Widening<StreamPosition, "chunkIndex">;
-            shouldLoad: import("../../main").Widening<StreamPosition, "shouldLoad">;
-            lastModifiedTime: import("../../main").Widening<StreamPosition, "lastModifiedTime">;
-        };
-        Coroutine: {};
+  Default: (
+    initialChunkSize: number,
+    shouldLoad?: StreamingStatus,
+  ) => StreamPosition;
+  Updaters: {
+    Template: {
+      loadInitial: () => Updater<StreamPosition>;
+      changeChunkSize: (chunkSize: number) => Updater<StreamPosition>;
+      reload: () => Updater<StreamPosition>;
+      loadMore: () => Updater<StreamPosition>;
+    };
+    Core: {
+      chunkSize: import("../../main").Widening<StreamPosition, "chunkSize">;
+      chunkIndex: import("../../main").Widening<StreamPosition, "chunkIndex">;
+      shouldLoad: import("../../main").Widening<StreamPosition, "shouldLoad">;
+      lastModifiedTime: import("../../main").Widening<
+        StreamPosition,
+        "lastModifiedTime"
+      >;
     };
+    Coroutine: {};
+  };
 };
 export type Chunk<Element extends Identifiable> = {
-    hasMoreValues: boolean;
-    data: OrderedMap<Element["Id"], Element>;
+  hasMoreValues: boolean;
+  data: OrderedMap<Element["Id"], Element>;
 };
 export declare const Chunk: <Element extends Identifiable>() => {
-    Default: (hasMoreValues: boolean, data: OrderedMap<Element["Id"], Element>) => Chunk<Element>;
+  Default: (
+    hasMoreValues: boolean,
+    data: OrderedMap<Element["Id"], Element>,
+  ) => Chunk<Element>;
 };
 export type InfiniteStreamState<Element extends Identifiable> = {
-    loadingMore: AsyncState<Unit>;
-    loadedElements: OrderedMap<StreamPosition["chunkIndex"], Chunk<Element>>;
-    position: StreamPosition;
-    getChunk: BasicFun<[StreamPosition], Promise<Chunk<Element>>>;
+  loadingMore: AsyncState<Unit>;
+  loadedElements: OrderedMap<StreamPosition["chunkIndex"], Chunk<Element>>;
+  position: StreamPosition;
+  getChunk: BasicFun<[StreamPosition], Promise<Chunk<Element>>>;
 };
 export declare const InfiniteStreamState: <Element extends Identifiable>() => {
-    Default: (initialChunkSize: number, getChunk: InfiniteStreamState<Element>["getChunk"], shouldLoad?: StreamingStatus) => InfiniteStreamState<Element>;
-    Operations: {
-        shouldCoroutineRun: (current: InfiniteStreamState<Element>) => boolean;
-        loadNextPage: (current: InfiniteStreamState<Element>) => boolean;
+  Default: (
+    initialChunkSize: number,
+    getChunk: InfiniteStreamState<Element>["getChunk"],
+    shouldLoad?: StreamingStatus,
+  ) => InfiniteStreamState<Element>;
+  Operations: {
+    shouldCoroutineRun: (current: InfiniteStreamState<Element>) => boolean;
+    loadNextPage: (current: InfiniteStreamState<Element>) => boolean;
+  };
+  Updaters: {
+    Coroutine: {
+      addLoadedChunk: (
+        chunkIndex: number,
+        newChunk: Chunk<Element>,
+      ) => Updater<InfiniteStreamState<Element>>;
+    };
+    Core: {
+      whenNotAlreadyLoading: (
+        _: BasicUpdater<InfiniteStreamState<Element>>,
+      ) => Updater<InfiniteStreamState<Element>>;
+      position: (
+        positionUpdater: Updater<InfiniteStreamState<Element>["position"]>,
+      ) => Updater<InfiniteStreamState<Element>>;
+      clearLoadedElements: () => Updater<InfiniteStreamState<Element>>;
+      loadedElements: import("../../main").Widening<
+        InfiniteStreamState<Element>,
+        "loadedElements"
+      >;
+      loadingMore: import("../../main").Widening<
+        InfiniteStreamState<Element>,
+        "loadingMore"
+      >;
+      getChunk: import("../../main").Widening<
+        InfiniteStreamState<Element>,
+        "getChunk"
+      >;
     };
-    Updaters: {
-        Coroutine: {
-            addLoadedChunk: (chunkIndex: number, newChunk: Chunk<Element>) => Updater<InfiniteStreamState<Element>>;
-        };
-        Core: {
-            whenNotAlreadyLoading: (_: BasicUpdater<InfiniteStreamState<Element>>) => Updater<InfiniteStreamState<Element>>;
-            position: (positionUpdater: Updater<InfiniteStreamState<Element>["position"]>) => Updater<InfiniteStreamState<Element>>;
-            clearLoadedElements: () => Updater<InfiniteStreamState<Element>>;
-            loadedElements: import("../../main").Widening<InfiniteStreamState<Element>, "loadedElements">;
-            loadingMore: import("../../main").Widening<InfiniteStreamState<Element>, "loadingMore">;
-            getChunk: import("../../main").Widening<InfiniteStreamState<Element>, "getChunk">;
-        };
-        Template: {
-            loadInitial: () => Updater<InfiniteStreamState<Element>>;
-            reload: (getChunk: InfiniteStreamState<Element>["getChunk"]) => Updater<InfiniteStreamState<Element>>;
-            loadMore: () => Updater<InfiniteStreamState<Element>>;
-        };
+    Template: {
+      loadInitial: () => Updater<InfiniteStreamState<Element>>;
+      reload: (
+        getChunk: InfiniteStreamState<Element>["getChunk"],
+      ) => Updater<InfiniteStreamState<Element>>;
+      loadMore: () => Updater<InfiniteStreamState<Element>>;
     };
+  };
 };
 export type InfiniteStreamReadonlyState = Unit;
-export type InfiniteStreamWritableState<Element extends {
+export type InfiniteStreamWritableState<
+  Element extends {
     Id: string;
-}> = InfiniteStreamState<Element>;
+  },
+> = InfiniteStreamState<Element>;
 export {};
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/infinite-data-stream/state.js

@@ -4,73 +4,137 @@ import { replaceWith } from "../fun/domains/updater/domains/replaceWith/state";
 import { simpleUpdater } from "../fun/domains/updater/domains/simpleUpdater/state";
 import { AsyncState } from "../async/state";
 export const StreamPosition = {
-    Default: (initialChunkSize, shouldLoad = false) => ({
-        chunkSize: initialChunkSize,
-        chunkIndex: 0,
-        shouldLoad,
-        lastModifiedTime: Date.now(),
-    }),
-    Updaters: {
-        Template: {
-            loadInitial: () => StreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now())).then(StreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore"))),
-            changeChunkSize: (chunkSize) => StreamPosition.Updaters.Core.chunkSize(replaceWith(chunkSize)).then(StreamPosition.Updaters.Template.reload()),
-            reload: () => StreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now()))
-                .then(StreamPosition.Updaters.Core.shouldLoad(replaceWith("reload")))
-                .then(StreamPosition.Updaters.Core.chunkIndex(replaceWith(0))),
-            loadMore: () => StreamPosition.Updaters.Core.chunkIndex((_) => _ + 1).then(StreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now())).then(StreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore")))),
-        },
-        Core: Object.assign(Object.assign(Object.assign(Object.assign({}, simpleUpdater()("lastModifiedTime")), simpleUpdater()("shouldLoad")), simpleUpdater()("chunkIndex")), simpleUpdater()("chunkSize")),
-        Coroutine: {},
+  Default: (initialChunkSize, shouldLoad = false) => ({
+    chunkSize: initialChunkSize,
+    chunkIndex: 0,
+    shouldLoad,
+    lastModifiedTime: Date.now(),
+  }),
+  Updaters: {
+    Template: {
+      loadInitial: () =>
+        StreamPosition.Updaters.Core.lastModifiedTime(
+          replaceWith(Date.now()),
+        ).then(
+          StreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore")),
+        ),
+      changeChunkSize: (chunkSize) =>
+        StreamPosition.Updaters.Core.chunkSize(replaceWith(chunkSize)).then(
+          StreamPosition.Updaters.Template.reload(),
+        ),
+      reload: () =>
+        StreamPosition.Updaters.Core.lastModifiedTime(replaceWith(Date.now()))
+          .then(StreamPosition.Updaters.Core.shouldLoad(replaceWith("reload")))
+          .then(StreamPosition.Updaters.Core.chunkIndex(replaceWith(0))),
+      loadMore: () =>
+        StreamPosition.Updaters.Core.chunkIndex((_) => _ + 1).then(
+          StreamPosition.Updaters.Core.lastModifiedTime(
+            replaceWith(Date.now()),
+          ).then(
+            StreamPosition.Updaters.Core.shouldLoad(replaceWith("loadMore")),
+          ),
+        ),
     },
+    Core: Object.assign(
+      Object.assign(
+        Object.assign(
+          Object.assign({}, simpleUpdater()("lastModifiedTime")),
+          simpleUpdater()("shouldLoad"),
+        ),
+        simpleUpdater()("chunkIndex"),
+      ),
+      simpleUpdater()("chunkSize"),
+    ),
+    Coroutine: {},
+  },
 };
 export const Chunk = () => ({
-    Default: (hasMoreValues, data) => ({
-        hasMoreValues,
-        data,
-    }),
+  Default: (hasMoreValues, data) => ({
+    hasMoreValues,
+    data,
+  }),
 });
 export const InfiniteStreamState = () => ({
-    Default: (initialChunkSize, getChunk, shouldLoad) => ({
-        loadingMore: AsyncState.Default.unloaded(),
-        loadedElements: OrderedMap(),
-        position: StreamPosition.Default(initialChunkSize, shouldLoad),
-        getChunk,
-    }),
-    Operations: {
-        shouldCoroutineRun: (current) => current.position.shouldLoad != false,
-        loadNextPage: (current) => {
-            var _a;
-            return current.position.shouldLoad !== false &&
-                ((_a = current.loadedElements.last()) === null || _a === void 0 ? void 0 : _a.hasMoreValues) !== false;
-        },
+  Default: (initialChunkSize, getChunk, shouldLoad) => ({
+    loadingMore: AsyncState.Default.unloaded(),
+    loadedElements: OrderedMap(),
+    position: StreamPosition.Default(initialChunkSize, shouldLoad),
+    getChunk,
+  }),
+  Operations: {
+    shouldCoroutineRun: (current) => current.position.shouldLoad != false,
+    loadNextPage: (current) => {
+      var _a;
+      return (
+        current.position.shouldLoad !== false &&
+        ((_a = current.loadedElements.last()) === null || _a === void 0
+          ? void 0
+          : _a.hasMoreValues) !== false
+      );
     },
-    Updaters: {
-        Coroutine: {
-            addLoadedChunk: (chunkIndex, newChunk) => InfiniteStreamState().Updaters.Core.loadedElements((_) => _.set(chunkIndex, newChunk)),
-        },
-        Core: Object.assign(Object.assign(Object.assign(Object.assign({}, simpleUpdater()("getChunk")), simpleUpdater()("loadingMore")), simpleUpdater()("loadedElements")), { whenNotAlreadyLoading: (_) => {
-                return Updater((current) => {
-                    if (InfiniteStreamState().Operations.loadNextPage(current)) {
-                        return current;
-                    }
-                    return _(current);
-                });
-            }, position: (positionUpdater) => Updater((current) => {
-                const newPosition = positionUpdater(current.position);
-                let newState = current;
-                if (newPosition.chunkSize != current.position.chunkSize)
-                    newState =
-                        InfiniteStreamState().Updaters.Core.clearLoadedElements()(newState);
-                return Object.assign(Object.assign({}, newState), { position: newPosition });
-            }), clearLoadedElements: () => InfiniteStreamState().Updaters.Core.loadedElements((_) => OrderedMap()) }),
-        Template: {
-            loadInitial: () => InfiniteStreamState().Updaters.Core.position(StreamPosition.Updaters.Template.loadInitial()),
-            reload: (getChunk) => InfiniteStreamState()
-                .Updaters.Core.position(StreamPosition.Updaters.Template.reload())
-                .then(InfiniteStreamState().Updaters.Core.clearLoadedElements())
-                .then(InfiniteStreamState().Updaters.Core.getChunk(replaceWith(getChunk))),
-            loadMore: () => InfiniteStreamState().Updaters.Core.whenNotAlreadyLoading(InfiniteStreamState().Updaters.Core.position(StreamPosition.Updaters.Template.loadMore())),
+  },
+  Updaters: {
+    Coroutine: {
+      addLoadedChunk: (chunkIndex, newChunk) =>
+        InfiniteStreamState().Updaters.Core.loadedElements((_) =>
+          _.set(chunkIndex, newChunk),
+        ),
+    },
+    Core: Object.assign(
+      Object.assign(
+        Object.assign(
+          Object.assign({}, simpleUpdater()("getChunk")),
+          simpleUpdater()("loadingMore"),
+        ),
+        simpleUpdater()("loadedElements"),
+      ),
+      {
+        whenNotAlreadyLoading: (_) => {
+          return Updater((current) => {
+            if (InfiniteStreamState().Operations.loadNextPage(current)) {
+              return current;
+            }
+            return _(current);
+          });
         },
+        position: (positionUpdater) =>
+          Updater((current) => {
+            const newPosition = positionUpdater(current.position);
+            let newState = current;
+            if (newPosition.chunkSize != current.position.chunkSize)
+              newState =
+                InfiniteStreamState().Updaters.Core.clearLoadedElements()(
+                  newState,
+                );
+            return Object.assign(Object.assign({}, newState), {
+              position: newPosition,
+            });
+          }),
+        clearLoadedElements: () =>
+          InfiniteStreamState().Updaters.Core.loadedElements((_) =>
+            OrderedMap(),
+          ),
+      },
+    ),
+    Template: {
+      loadInitial: () =>
+        InfiniteStreamState().Updaters.Core.position(
+          StreamPosition.Updaters.Template.loadInitial(),
+        ),
+      reload: (getChunk) =>
+        InfiniteStreamState()
+          .Updaters.Core.position(StreamPosition.Updaters.Template.reload())
+          .then(InfiniteStreamState().Updaters.Core.clearLoadedElements())
+          .then(
+            InfiniteStreamState().Updaters.Core.getChunk(replaceWith(getChunk)),
+          ),
+      loadMore: () =>
+        InfiniteStreamState().Updaters.Core.whenNotAlreadyLoading(
+          InfiniteStreamState().Updaters.Core.position(
+            StreamPosition.Updaters.Template.loadMore(),
+          ),
+        ),
     },
+  },
 });
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/infinite-data-stream/template.d.ts

@@ -1,7 +1,14 @@
 import { Unit } from "../fun/domains/unit/state";
 import { Template } from "../template/state";
 import { InfiniteStreamWritableState } from "./state";
-export declare const InfiniteStreamTemplate: <Element extends {
+export declare const InfiniteStreamTemplate: <
+  Element extends {
     Id: string;
-}>() => Template<InfiniteStreamWritableState<Element>, InfiniteStreamWritableState<Element>, Unit, Unit>;
-//# sourceMappingURL=template.d.ts.map
+  },
+>() => Template<
+  InfiniteStreamWritableState<Element>,
+  InfiniteStreamWritableState<Element>,
+  Unit,
+  Unit
+>;
+//# sourceMappingURL=template.d.ts.map

package/bin/src/infinite-data-stream/template.js

@@ -1,5 +1,6 @@
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
 import { Template } from "../template/state";
 import { StreamDataLoader } from "./coroutines/runner";
-export const InfiniteStreamTemplate = () => Template.Default((_props) => _jsx(_Fragment, {})).any([StreamDataLoader()]);
-//# sourceMappingURL=template.js.map
+export const InfiniteStreamTemplate = () =>
+  Template.Default((_props) => _jsx(_Fragment, {})).any([StreamDataLoader()]);
+//# sourceMappingURL=template.js.map

package/bin/src/math/domains/DOMRect/state.d.ts

@@ -1,6 +1,6 @@
 export declare const DomRectRepo: {
-    Operations: {
-        rectanglesIntersect: (r1: DOMRect, r2: DOMRect) => boolean;
-    };
+  Operations: {
+    rectanglesIntersect: (r1: DOMRect, r2: DOMRect) => boolean;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/math/domains/DOMRect/state.js

@@ -1,11 +1,13 @@
 export const DomRectRepo = {
-    Operations: {
-        rectanglesIntersect: (r1, r2) => {
-            return !(r2.left > r1.right ||
-                r2.right < r1.left ||
-                r2.top > r1.bottom ||
-                r2.bottom < r1.top);
-        },
+  Operations: {
+    rectanglesIntersect: (r1, r2) => {
+      return !(
+        r2.left > r1.right ||
+        r2.right < r1.left ||
+        r2.top > r1.bottom ||
+        r2.bottom < r1.top
+      );
     },
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/math/domains/number/state.d.ts

@@ -1,7 +1,7 @@
 export declare const numberRepo: {
-    Operations: {
-        lerp: (a: number, min: number, max: number) => number;
-        clamp: (a: number, min: number, max: number) => number;
-    };
+  Operations: {
+    lerp: (a: number, min: number, max: number) => number;
+    clamp: (a: number, min: number, max: number) => number;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/math/domains/number/state.js

@@ -1,7 +1,7 @@
 export const numberRepo = {
-    Operations: {
-        lerp: (a, min, max) => min + (max - min) * a,
-        clamp: (a, min, max) => Math.max(Math.min(a, max), min),
-    },
+  Operations: {
+    lerp: (a, min, max) => min + (max - min) * a,
+    clamp: (a, min, max) => Math.max(Math.min(a, max), min),
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/math/domains/rect/state.d.ts

@@ -1,13 +1,13 @@
 import { Visibility } from "../../../visibility/state";
 export type Rect = {
-    top: number;
-    left: number;
-    bottom: number;
-    right: number;
+  top: number;
+  left: number;
+  bottom: number;
+  right: number;
 };
 export declare const Rect: {
-    Operations: {
-        IsElementInViewport(rect: Rect, windowRect: Rect): Visibility;
-    };
+  Operations: {
+    IsElementInViewport(rect: Rect, windowRect: Rect): Visibility;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/math/domains/rect/state.js

@@ -1,18 +1,19 @@
 export const Rect = {
-    Operations: {
-        IsElementInViewport(rect, windowRect) {
-            return rect.top >= 0 &&
-                // rect.left >= 0 &&
-                rect.bottom <= windowRect.bottom // &&
-                ? // rect.right <= windowRect.right
-                    "fully-visible"
-                : !(
-                //windowRect.left > rect.right ||
-                // windowRect.right < rect.left ||
-                (windowRect.top > rect.bottom || windowRect.bottom < rect.top))
-                    ? "partially-visible"
-                    : "fully-invisible";
-        },
+  Operations: {
+    IsElementInViewport(rect, windowRect) {
+      return rect.top >= 0 &&
+        // rect.left >= 0 &&
+        rect.bottom <= windowRect.bottom // &&
+        ? // rect.right <= windowRect.right
+          "fully-visible"
+        : !(
+              //windowRect.left > rect.right ||
+              // windowRect.right < rect.left ||
+              (windowRect.top > rect.bottom || windowRect.bottom < rect.top)
+            )
+          ? "partially-visible"
+          : "fully-invisible";
     },
+  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map