ballerina-core 1.0.197 → 1.0.199

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

@@ -1,54 +1,27 @@
 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,13 +1,5 @@
 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,106 +5,73 @@ 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"
-      >;
+    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: {};
     };
-    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;
-  };
-  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"
-      >;
+    Default: (initialChunkSize: number, getChunk: InfiniteStreamState<Element>["getChunk"], shouldLoad?: StreamingStatus) => InfiniteStreamState<Element>;
+    Operations: {
+        shouldCoroutineRun: (current: InfiniteStreamState<Element>) => boolean;
+        loadNextPage: (current: InfiniteStreamState<Element>) => boolean;
     };
-    Template: {
-      loadInitial: () => Updater<InfiniteStreamState<Element>>;
-      reload: (
-        getChunk: InfiniteStreamState<Element>["getChunk"],
-      ) => Updater<InfiniteStreamState<Element>>;
-      loadMore: () => Updater<InfiniteStreamState<Element>>;
+    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>>;
+        };
     };
-  };
 };
 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,137 +4,73 @@ 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")),
-          ),
-        ),
+    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: {},
     },
-    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
-      );
-    },
-  },
-  Updaters: {
-    Coroutine: {
-      addLoadedChunk: (chunkIndex, newChunk) =>
-        InfiniteStreamState().Updaters.Core.loadedElements((_) =>
-          _.set(chunkIndex, newChunk),
-        ),
+    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;
+        },
     },
-    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);
-          });
+    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())),
         },
-        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,14 +1,7 @@
 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,6 +1,5 @@
 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,13 +1,11 @@
 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,19 +1,18 @@
 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