ballerina-core 1.0.257 → 1.0.259

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

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

@@ -1,22 +1,22 @@
 export type RGBAColor = {
-  readonly r: number;
-  readonly g: number;
-  readonly b: number;
-  readonly a: number;
+    readonly r: number;
+    readonly g: number;
+    readonly b: number;
+    readonly a: number;
 };
 export declare const RGBAColor: {
-  Default: ((r: number, g: number, b: number, a: number) => RGBAColor) & {
-    zero: () => RGBAColor;
-    fromHSL: (hue: number, sat: number, light: number) => RGBAColor;
-  };
-  Updaters: {};
-  Operations: {
-    toHsl: ({ r, g, b }: RGBAColor) => {
-      h: number;
-      s: number;
-      l: number;
+    Default: ((r: number, g: number, b: number, a: number) => RGBAColor) & {
+        zero: () => RGBAColor;
+        fromHSL: (hue: number, sat: number, light: number) => RGBAColor;
+    };
+    Updaters: {};
+    Operations: {
+        toHsl: ({ r, g, b }: RGBAColor) => {
+            h: number;
+            s: number;
+            l: number;
+        };
+        hueToRgb: (t1: number, t2: number, hue: number) => number;
     };
-    hueToRgb: (t1: number, t2: number, hue: number) => number;
-  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,80 +1,84 @@
 export const RGBAColor = {
-  Default: Object.assign((r, g, b, a) => ({ r, g, b, a }), {
-    zero: () => RGBAColor.Default(0, 0, 0, 0),
-    fromHSL: (hue, sat, light) => {
-      let t2;
-      hue = hue / 60;
-      if (light <= 0.5) {
-        t2 = light * (sat + 1);
-      } else {
-        t2 = light + sat - light * sat;
-      }
-      const t1 = light * 2 - t2;
-      const r = RGBAColor.Operations.hueToRgb(t1, t2, hue + 2) * 255;
-      const g = RGBAColor.Operations.hueToRgb(t1, t2, hue) * 255;
-      const b = RGBAColor.Operations.hueToRgb(t1, t2, hue - 2) * 255;
-      return { r: r, g: g, b: b, a: 1.0 };
+    Default: Object.assign((r, g, b, a) => ({ r, g, b, a }), {
+        zero: () => RGBAColor.Default(0, 0, 0, 0),
+        fromHSL: (hue, sat, light) => {
+            let t2;
+            hue = hue / 60;
+            if (light <= 0.5) {
+                t2 = light * (sat + 1);
+            }
+            else {
+                t2 = light + sat - light * sat;
+            }
+            const t1 = light * 2 - t2;
+            const r = RGBAColor.Operations.hueToRgb(t1, t2, hue + 2) * 255;
+            const g = RGBAColor.Operations.hueToRgb(t1, t2, hue) * 255;
+            const b = RGBAColor.Operations.hueToRgb(t1, t2, hue - 2) * 255;
+            return { r: r, g: g, b: b, a: 1.0 };
+        },
+    }),
+    Updaters: {},
+    Operations: {
+        toHsl: ({ r, g, b }) => {
+            let min, max, i, s, maxcolor, h = 0;
+            const rgb = [r / 255, g / 255, b / 255];
+            min = rgb[0];
+            max = rgb[0];
+            maxcolor = 0;
+            for (i = 0; i < rgb.length - 1; i++) {
+                if (rgb[i + 1] <= min) {
+                    min = rgb[i + 1];
+                }
+                if (rgb[i + 1] >= max) {
+                    max = rgb[i + 1];
+                    maxcolor = i + 1;
+                }
+            }
+            if (maxcolor == 0) {
+                h = (rgb[1] - rgb[2]) / (max - min);
+            }
+            if (maxcolor == 1) {
+                h = 2 + (rgb[2] - rgb[0]) / (max - min);
+            }
+            if (maxcolor == 2) {
+                h = 4 + (rgb[0] - rgb[1]) / (max - min);
+            }
+            if (isNaN(h)) {
+                h = 0;
+            }
+            h = h * 60;
+            if (h < 0) {
+                h = h + 360;
+            }
+            const l = (min + max) / 2;
+            if (min == max) {
+                s = 0;
+            }
+            else {
+                if (l < 0.5) {
+                    s = (max - min) / (max + min);
+                }
+                else {
+                    s = (max - min) / (2 - max - min);
+                }
+            }
+            s = s;
+            return { h: h, s: s, l: l };
+        },
+        hueToRgb: (t1, t2, hue) => {
+            if (hue < 0)
+                hue += 6;
+            if (hue >= 6)
+                hue -= 6;
+            if (hue < 1)
+                return (t2 - t1) * hue + t1;
+            else if (hue < 3)
+                return t2;
+            else if (hue < 4)
+                return (t2 - t1) * (4 - hue) + t1;
+            else
+                return t1;
+        },
     },
-  }),
-  Updaters: {},
-  Operations: {
-    toHsl: ({ r, g, b }) => {
-      let min,
-        max,
-        i,
-        s,
-        maxcolor,
-        h = 0;
-      const rgb = [r / 255, g / 255, b / 255];
-      min = rgb[0];
-      max = rgb[0];
-      maxcolor = 0;
-      for (i = 0; i < rgb.length - 1; i++) {
-        if (rgb[i + 1] <= min) {
-          min = rgb[i + 1];
-        }
-        if (rgb[i + 1] >= max) {
-          max = rgb[i + 1];
-          maxcolor = i + 1;
-        }
-      }
-      if (maxcolor == 0) {
-        h = (rgb[1] - rgb[2]) / (max - min);
-      }
-      if (maxcolor == 1) {
-        h = 2 + (rgb[2] - rgb[0]) / (max - min);
-      }
-      if (maxcolor == 2) {
-        h = 4 + (rgb[0] - rgb[1]) / (max - min);
-      }
-      if (isNaN(h)) {
-        h = 0;
-      }
-      h = h * 60;
-      if (h < 0) {
-        h = h + 360;
-      }
-      const l = (min + max) / 2;
-      if (min == max) {
-        s = 0;
-      } else {
-        if (l < 0.5) {
-          s = (max - min) / (max + min);
-        } else {
-          s = (max - min) / (2 - max - min);
-        }
-      }
-      s = s;
-      return { h: h, s: s, l: l };
-    },
-    hueToRgb: (t1, t2, hue) => {
-      if (hue < 0) hue += 6;
-      if (hue >= 6) hue -= 6;
-      if (hue < 1) return (t2 - t1) * hue + t1;
-      else if (hue < 3) return t2;
-      else if (hue < 4) return (t2 - t1) * (4 - hue) + t1;
-      else return t1;
-    },
-  },
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

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

@@ -1,12 +1,12 @@
 export type Size2 = {
-  readonly width: number;
-  readonly height: number;
+    readonly width: number;
+    readonly height: number;
 };
 export declare const Size2: {
-  Default: ((width: number, height: number) => Size2) & {
-    zero: () => Size2;
-  };
-  Updaters: {};
-  Operations: {};
+    Default: ((width: number, height: number) => Size2) & {
+        zero: () => Size2;
+    };
+    Updaters: {};
+    Operations: {};
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,8 +1,8 @@
 export const Size2 = {
-  Default: Object.assign((width, height) => ({ width, height }), {
-    zero: () => Size2.Default(0, 0),
-  }),
-  Updaters: {},
-  Operations: {},
+    Default: Object.assign((width, height) => ({ width, height }), {
+        zero: () => Size2.Default(0, 0),
+    }),
+    Updaters: {},
+    Operations: {},
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

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

@@ -1,14 +1,14 @@
 export type Vector2 = {
-  readonly x: number;
-  readonly y: number;
+    readonly x: number;
+    readonly y: number;
 };
 export declare const Vector2: {
-  Default: ((x: number, y: number) => Vector2) & {
-    zero: () => Vector2;
-    one_x: () => Vector2;
-    one_y: () => Vector2;
-  };
-  Updaters: {};
-  Operations: {};
+    Default: ((x: number, y: number) => Vector2) & {
+        zero: () => Vector2;
+        one_x: () => Vector2;
+        one_y: () => Vector2;
+    };
+    Updaters: {};
+    Operations: {};
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,10 +1,10 @@
 export const Vector2 = {
-  Default: Object.assign((x, y) => ({ x, y }), {
-    zero: () => Vector2.Default(0, 0),
-    one_x: () => Vector2.Default(1, 0),
-    one_y: () => Vector2.Default(0, 1),
-  }),
-  Updaters: {},
-  Operations: {},
+    Default: Object.assign((x, y) => ({ x, y }), {
+        zero: () => Vector2.Default(0, 0),
+        one_x: () => Vector2.Default(1, 0),
+        one_y: () => Vector2.Default(0, 1),
+    }),
+    Updaters: {},
+    Operations: {},
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/queue/state.d.ts

@@ -2,30 +2,10 @@ import { OrderedMap } from "immutable";
 import { Guid, Unit, SynchronizationOperationResult } from "../../main";
 import { Coroutine } from "../coroutines/state";
 import { BasicFun } from "../fun/state";
-export declare const QueueCoroutine: <
-  Context,
-  State,
-  OperationResult extends
-    SynchronizationOperationResult = SynchronizationOperationResult,
->(
-  removeItem: BasicFun<Guid, Coroutine<Context & State, State, Unit>>,
-  getItemsToProcess: BasicFun<
-    Context & State,
-    OrderedMap<
-      Guid,
-      {
-        preprocess: Coroutine<Context & State, State, Unit>;
-        operation: Coroutine<Context & State, State, OperationResult>;
-        postprocess: BasicFun<
-          OperationResult,
-          Coroutine<Context & State, State, Unit>
-        >;
-        reenqueue: BasicFun<
-          OperationResult,
-          Coroutine<Context & State, State, Unit>
-        >;
-      }
-    >
-  >,
-) => Coroutine<Context & State, State, Unit>;
-//# sourceMappingURL=state.d.ts.map
+export declare const QueueCoroutine: <Context, State, OperationResult extends SynchronizationOperationResult = SynchronizationOperationResult>(removeItem: BasicFun<Guid, Coroutine<Context & State, State, Unit>>, getItemsToProcess: BasicFun<Context & State, OrderedMap<Guid, {
+    preprocess: Coroutine<Context & State, State, Unit>;
+    operation: Coroutine<Context & State, State, OperationResult>;
+    postprocess: BasicFun<OperationResult, Coroutine<Context & State, State, Unit>>;
+    reenqueue: BasicFun<OperationResult, Coroutine<Context & State, State, Unit>>;
+}>>) => Coroutine<Context & State, State, Unit>;
+//# sourceMappingURL=state.d.ts.map

package/bin/src/queue/state.js

@@ -1,28 +1,21 @@
 import { CoTypedFactory } from "../coroutines/builder";
 export const QueueCoroutine = (removeItem, getItemsToProcess) => {
-  const Co = CoTypedFactory();
-  return Co.Repeat(
-    Co.GetState().then((current) => {
-      let operations = getItemsToProcess(current);
-      return Co.Seq([
-        Co.All(
-          operations.toArray().map(([id, k]) =>
-            k.preprocess
-              .then(() => k.operation)
-              .then((_) =>
-                k.postprocess(_).then(() => {
-                  if (_.kind == "should be enqueued again") {
+    const Co = CoTypedFactory();
+    return Co.Repeat(Co.GetState().then((current) => {
+        let operations = getItemsToProcess(current);
+        return Co.Seq([
+            Co.All(operations.toArray().map(([id, k]) => k.preprocess
+                .then(() => k.operation)
+                .then((_) => k.postprocess(_).then(() => {
+                if (_.kind == "should be enqueued again") {
                     return k.reenqueue(_);
-                  } else {
+                }
+                else {
                     return Co.Return({});
-                  }
-                }),
-              )
-              .then(() => removeItem(id)),
-          ),
-        ),
-      ]);
-    }),
-  );
+                }
+            }))
+                .then(() => removeItem(id)))),
+        ]);
+    }));
 };
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/state/domains/repository/state.d.ts

@@ -2,20 +2,14 @@ import { ForeignMutationsInput } from "../../../foreignMutations/state";
 import { Unit } from "../../../fun/domains/unit/state";
 import { BasicFun } from "../../../fun/state";
 export type Updaters = {
-  Core: Unit;
-  Template: Unit;
-  Coroutine: Unit;
+    Core: Unit;
+    Template: Unit;
+    Coroutine: Unit;
 };
-export type Repository<
-  Context,
-  State,
-  Input,
-  ActualUpdaters extends Updaters,
-  Operations = Unit,
-> = {
-  Default: BasicFun<Input, State>;
-  Updaters: ActualUpdaters;
-  Operations: Operations;
-  ForeignMutations: BasicFun<ForeignMutationsInput<Context, State>, Unit>;
+export type Repository<Context, State, Input, ActualUpdaters extends Updaters, Operations = Unit> = {
+    Default: BasicFun<Input, State>;
+    Updaters: ActualUpdaters;
+    Operations: Operations;
+    ForeignMutations: BasicFun<ForeignMutationsInput<Context, State>, Unit>;
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

package/bin/src/state/domains/repository/state.js

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=state.js.map
+//# sourceMappingURL=state.js.map

package/bin/src/template/state.d.ts

@@ -1,168 +1,60 @@
 import { BasicFun } from "../fun/state";
 import { BasicUpdater } from "../fun/domains/updater/state";
 import { Unit } from "../../main";
-export type View<context, state, foreignMutations, embeddedChildren = Unit> = (
-  props: HeadlessTemplateProps<context, state, foreignMutations> &
-    embeddedChildren,
-) => JSX.Element;
+export type View<context, state, foreignMutations, embeddedChildren = Unit> = (props: HeadlessTemplateProps<context, state, foreignMutations> & embeddedChildren) => JSX.Element;
 export type HeadlessTemplateProps<context, state, foreignMutations> = {
-  context: context;
-  setState: BasicFun<BasicUpdater<state>, void>;
-  foreignMutations: foreignMutations;
+    context: context;
+    setState: BasicFun<BasicUpdater<state>, void>;
+    foreignMutations: foreignMutations;
 };
 export type TemplateChildren = JSX.Element | JSX.Element[];
-export type Wrapper = BasicFun<
-  {
+export type Wrapper = BasicFun<{
     children?: TemplateChildren;
-  },
-  JSX.Element
->;
+}, JSX.Element>;
 export type TemplateProps<context, state, foreignMutations, view = Unit> = {
-  context: context;
-  setState: BasicFun<BasicUpdater<state>, void>;
-  foreignMutations: foreignMutations;
-  view: view;
-  children?: TemplateChildren;
+    context: context;
+    setState: BasicFun<BasicUpdater<state>, void>;
+    foreignMutations: foreignMutations;
+    view: view;
+    children?: TemplateChildren;
 };
-type TemplateRunner<context, state, foreignMutations, view = Unit> = (
-  props: TemplateProps<context, state, foreignMutations, view>,
-) => JSX.Element;
+type TemplateRunner<context, state, foreignMutations, view = Unit> = (props: TemplateProps<context, state, foreignMutations, view>) => JSX.Element;
 export type Template<context, state, foreignMutations, view = Unit> = {
-  any: BasicFun<
-    Array<Template<context, state, foreignMutations>>,
-    Template<context, state, foreignMutations, view>
-  >;
-  wrap: (Wrapper: Wrapper) => Template<context, state, foreignMutations, view>;
-  withView: (view: view) => Template<context, state, foreignMutations, Unit>;
-  withViewFromProps: (
-    f: BasicFun<TemplateProps<context, state, foreignMutations, Unit>, view>,
-  ) => Template<context, state, foreignMutations, Unit>;
-  mapState: <newState>(
-    f: BasicFun<BasicUpdater<state>, BasicUpdater<newState>>,
-  ) => Template<context, newState, foreignMutations, view>;
-  mapStateFromProps: <newState>(
-    f: BasicFun<
-      [
+    any: BasicFun<Array<Template<context, state, foreignMutations>>, Template<context, state, foreignMutations, view>>;
+    wrap: (Wrapper: Wrapper) => Template<context, state, foreignMutations, view>;
+    withView: (view: view) => Template<context, state, foreignMutations, Unit>;
+    withViewFromProps: (f: BasicFun<TemplateProps<context, state, foreignMutations, Unit>, view>) => Template<context, state, foreignMutations, Unit>;
+    mapState: <newState>(f: BasicFun<BasicUpdater<state>, BasicUpdater<newState>>) => Template<context, newState, foreignMutations, view>;
+    mapStateFromProps: <newState>(f: BasicFun<[
         TemplateProps<context, newState, foreignMutations, view>,
-        BasicUpdater<state>,
-      ],
-      BasicUpdater<newState>
-    >,
-  ) => Template<context, newState, foreignMutations, view>;
-  mapContext: <newContext>(
-    f: BasicFun<newContext, context | undefined>,
-  ) => Template<newContext, state, foreignMutations, view>;
-  mapForeignMutations: <newForeignMutations>(
-    f: BasicFun<newForeignMutations, foreignMutations>,
-  ) => Template<context, state, newForeignMutations, view>;
-  mapContextFromProps: <newContext>(
-    f: BasicFun<
-      TemplateProps<newContext, state, foreignMutations, view>,
-      context | undefined
-    >,
-  ) => Template<newContext, state, foreignMutations, view>;
-  mapForeignMutationsFromProps: <newForeignMutations>(
-    f: BasicFun<
-      TemplateProps<context, state, newForeignMutations, view>,
-      foreignMutations
-    >,
-  ) => Template<context, state, newForeignMutations, view>;
-  mapView: <newView>(
-    f: BasicFun<newView, view>,
-  ) => Template<context, state, foreignMutations, newView>;
-  mapViewFromProps: <newView>(
-    f: BasicFun<TemplateProps<context, state, foreignMutations, newView>, view>,
-  ) => Template<context, state, foreignMutations, newView>;
+        BasicUpdater<state>
+    ], BasicUpdater<newState>>) => Template<context, newState, foreignMutations, view>;
+    mapContext: <newContext>(f: BasicFun<newContext, context | undefined>) => Template<newContext, state, foreignMutations, view>;
+    mapForeignMutations: <newForeignMutations>(f: BasicFun<newForeignMutations, foreignMutations>) => Template<context, state, newForeignMutations, view>;
+    mapContextFromProps: <newContext>(f: BasicFun<TemplateProps<newContext, state, foreignMutations, view>, context | undefined>) => Template<newContext, state, foreignMutations, view>;
+    mapForeignMutationsFromProps: <newForeignMutations>(f: BasicFun<TemplateProps<context, state, newForeignMutations, view>, foreignMutations>) => Template<context, state, newForeignMutations, view>;
+    mapView: <newView>(f: BasicFun<newView, view>) => Template<context, state, foreignMutations, newView>;
+    mapViewFromProps: <newView>(f: BasicFun<TemplateProps<context, state, foreignMutations, newView>, view>) => Template<context, state, foreignMutations, newView>;
 } & TemplateRunner<context, state, foreignMutations, view>;
-export declare const createTemplate: <context, state, foreignMutations, view>(
-  actual: TemplateRunner<context, state, foreignMutations, view>,
-) => Template<context, state, foreignMutations, view>;
+export declare const createTemplate: <context, state, foreignMutations, view>(actual: TemplateRunner<context, state, foreignMutations, view>) => Template<context, state, foreignMutations, view>;
 export declare const Template: {
-  Default: <context, state, foreignMutations, view = Unit>(
-    actual: TemplateRunner<context & state, state, foreignMutations, view>,
-  ) => Template<context & state, state, foreignMutations, view>;
-  Operations: {
-    Wrap: <context, state, foreignMutations, view>(
-      p: Template<context, state, foreignMutations, view>,
-      Wrapper: BasicFun<
-        {
-          children?: TemplateChildren;
-        },
-        JSX.Element
-      >,
-    ) => Template<context, state, foreignMutations, view>;
-    WithView: <context, state, foreignMutations, view>(
-      p: Template<context, state, foreignMutations, view>,
-      view: view,
-    ) => Template<context, state, foreignMutations, Unit>;
-    WithViewFromProps: <context, state, foreignMutations, view>(
-      p: Template<context, state, foreignMutations, view>,
-      f: BasicFun<TemplateProps<context, state, foreignMutations, Unit>, view>,
-    ) => Template<context, state, foreignMutations, Unit>;
-    MapState: <context, state, newState, foreignMutations, view>(
-      p: Template<context, state, foreignMutations, view>,
-      f: BasicFun<BasicUpdater<state>, BasicUpdater<newState>>,
-    ) => Template<context, newState, foreignMutations, view>;
-    MapStateFromProps: <context, state, newState, foreignMutations, view>(
-      p: Template<context, state, foreignMutations, view>,
-      f: BasicFun<
-        [
-          TemplateProps<context, newState, foreignMutations, view>,
-          BasicUpdater<state>,
-        ],
-        BasicUpdater<newState>
-      >,
-    ) => Template<context, newState, foreignMutations, view>;
-    MapContext: <context, newContext, state, foreignMutations, view>(
-      p: Template<context, state, foreignMutations, view>,
-      f: BasicFun<newContext, context | undefined>,
-    ) => Template<newContext, state, foreignMutations, view>;
-    MapForeignMutations: <
-      context,
-      state,
-      foreignMutations,
-      newForeignMutations,
-      view,
-    >(
-      p: Template<context, state, foreignMutations, view>,
-      f: BasicFun<newForeignMutations, foreignMutations>,
-    ) => Template<context, state, newForeignMutations, view>;
-    MapContextFromProps: <context, newContext, state, foreignMutations, view>(
-      p: Template<context, state, foreignMutations, view>,
-      f: BasicFun<
-        TemplateProps<newContext, state, foreignMutations, view>,
-        context | undefined
-      >,
-    ) => Template<newContext, state, foreignMutations, view>;
-    MapForeignMutationsFromProps: <
-      context,
-      state,
-      foreignMutations,
-      newForeignMutations,
-      view,
-    >(
-      p: Template<context, state, foreignMutations, view>,
-      f: BasicFun<
-        TemplateProps<context, state, newForeignMutations, view>,
-        foreignMutations
-      >,
-    ) => Template<context, state, newForeignMutations, view>;
-    Any: <context, state, foreignMutations, view>(
-      p: Template<context, state, foreignMutations, view>,
-      others: Array<Template<context, state, foreignMutations>>,
-    ) => Template<context, state, foreignMutations, view>;
-    MapView: <context, state, foreignMutations, newView, view>(
-      p: Template<context, state, foreignMutations, view>,
-      f: BasicFun<newView, view>,
-    ) => Template<context, state, foreignMutations, newView>;
-    MapViewFromProps: <context, state, foreignMutations, newView, view>(
-      p: Template<context, state, foreignMutations, view>,
-      f: BasicFun<
-        TemplateProps<context, state, foreignMutations, newView>,
-        view
-      >,
-    ) => Template<context, state, foreignMutations, newView>;
-  };
+    Default: <context, state, foreignMutations, view = Unit>(actual: TemplateRunner<context & state, state, foreignMutations, view>) => Template<context & state, state, foreignMutations, view>;
+    Operations: {
+        Wrap: <context, state, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, Wrapper: BasicFun<{
+            children?: TemplateChildren;
+        }, JSX.Element>) => Template<context, state, foreignMutations, view>;
+        WithView: <context, state, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, view: view) => Template<context, state, foreignMutations, Unit>;
+        WithViewFromProps: <context, state, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<TemplateProps<context, state, foreignMutations, Unit>, view>) => Template<context, state, foreignMutations, Unit>;
+        MapState: <context, state, newState, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<BasicUpdater<state>, BasicUpdater<newState>>) => Template<context, newState, foreignMutations, view>;
+        MapStateFromProps: <context, state, newState, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<[TemplateProps<context, newState, foreignMutations, view>, BasicUpdater<state>], BasicUpdater<newState>>) => Template<context, newState, foreignMutations, view>;
+        MapContext: <context, newContext, state, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<newContext, context | undefined>) => Template<newContext, state, foreignMutations, view>;
+        MapForeignMutations: <context, state, foreignMutations, newForeignMutations, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<newForeignMutations, foreignMutations>) => Template<context, state, newForeignMutations, view>;
+        MapContextFromProps: <context, newContext, state, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<TemplateProps<newContext, state, foreignMutations, view>, context | undefined>) => Template<newContext, state, foreignMutations, view>;
+        MapForeignMutationsFromProps: <context, state, foreignMutations, newForeignMutations, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<TemplateProps<context, state, newForeignMutations, view>, foreignMutations>) => Template<context, state, newForeignMutations, view>;
+        Any: <context, state, foreignMutations, view>(p: Template<context, state, foreignMutations, view>, others: Array<Template<context, state, foreignMutations>>) => Template<context, state, foreignMutations, view>;
+        MapView: <context, state, foreignMutations, newView, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<newView, view>) => Template<context, state, foreignMutations, newView>;
+        MapViewFromProps: <context, state, foreignMutations, newView, view>(p: Template<context, state, foreignMutations, view>, f: BasicFun<TemplateProps<context, state, foreignMutations, newView>, view>) => Template<context, state, foreignMutations, newView>;
+    };
 };
 export {};
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map