ballerina-core 1.0.199 → 1.0.201

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;
-        };
-        hueToRgb: (t1: number, t2: number, hue: number) => 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;
+  };
 };
-//# sourceMappingURL=state.d.ts.map
+//# sourceMappingURL=state.d.ts.map

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

@@ -1,84 +1,80 @@
 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 };
-        },
-    }),
-    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;
-        },
+  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;
+    },
+  },
 };
-//# 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,10 +2,26 @@ import { OrderedMap } from "immutable";
 import { Guid, Unit, SynchronizationResult } from "../../main";
 import { Coroutine } from "../coroutines/state";
 import { BasicFun } from "../fun/state";
-export declare const QueueCoroutine: <Context, State, OperationResult = SynchronizationResult>(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: Coroutine<Context & State, State, Unit>;
-}>>) => Coroutine<Context & State, State, Unit>;
-//# sourceMappingURL=state.d.ts.map
+export declare const QueueCoroutine: <
+  Context,
+  State,
+  OperationResult = SynchronizationResult,
+>(
+  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: Coroutine<Context & State, State, Unit>;
+      }
+    >
+  >,
+) => Coroutine<Context & State, State, Unit>;
+//# sourceMappingURL=state.d.ts.map

package/bin/src/queue/state.js

@@ -1,21 +1,28 @@
 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 (_ == "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 (_ == "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,14 +2,20 @@ 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,60 +1,168 @@
 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