vviinn-widgets 2.25.2 → 2.26.0

package/dist/cjs/{imageSearch.store-cc9b4a68.js → imageSearch.store-070ddd94.js}

@@ -1,7 +1,6 @@
 'use strict';
 
 const index = require('./index-a4becaff.js');
-const Handler = require('./Handler-de64afa5.js');
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
@@ -11442,6 +11441,104 @@ const trackingStore = {
 
 const { state: state$1, onChange: onChange$1 } = createStore(Object.assign({ fallbackStyles: "", pricePrefix: null, currencySign: null, apiPath: null, token: null, locale: "de-DE" }, trackingStore));
 
+var __spreadArray = (undefined && undefined.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+/**
+ * @since 2.0.0
+ */
+function identity(a) {
+    return a;
+}
+/**
+ * @since 2.0.0
+ */
+function tuple() {
+    var t = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        t[_i] = arguments[_i];
+    }
+    return t;
+}
+function pipe(a, ab, bc, cd, de, ef, fg, gh, hi) {
+    switch (arguments.length) {
+        case 1:
+            return a;
+        case 2:
+            return ab(a);
+        case 3:
+            return bc(ab(a));
+        case 4:
+            return cd(bc(ab(a)));
+        case 5:
+            return de(cd(bc(ab(a))));
+        case 6:
+            return ef(de(cd(bc(ab(a)))));
+        case 7:
+            return fg(ef(de(cd(bc(ab(a))))));
+        case 8:
+            return gh(fg(ef(de(cd(bc(ab(a)))))));
+        case 9:
+            return hi(gh(fg(ef(de(cd(bc(ab(a))))))));
+        default: {
+            var ret = arguments[0];
+            for (var i = 1; i < arguments.length; i++) {
+                ret = arguments[i](ret);
+            }
+            return ret;
+        }
+    }
+}
+/** @internal */
+var dual = function (arity, body) {
+    var isDataFirst = typeof arity === 'number' ? function (args) { return args.length >= arity; } : arity;
+    return function () {
+        var args = Array.from(arguments);
+        if (isDataFirst(arguments)) {
+            return body.apply(this, args);
+        }
+        return function (self) { return body.apply(void 0, __spreadArray([self], args, false)); };
+    };
+};
+
+// -------------------------------------------------------------------------------------
+// Option
+// -------------------------------------------------------------------------------------
+/** @internal */
+var isNone$1 = function (fa) { return fa._tag === 'None'; };
+/** @internal */
+var isSome = function (fa) { return fa._tag === 'Some'; };
+/** @internal */
+var none$1 = { _tag: 'None' };
+/** @internal */
+var some$1 = function (a) { return ({ _tag: 'Some', value: a }); };
+// -------------------------------------------------------------------------------------
+// Either
+// -------------------------------------------------------------------------------------
+/** @internal */
+var isLeft$1 = function (ma) { return ma._tag === 'Left'; };
+/** @internal */
+var left$1 = function (e) { return ({ _tag: 'Left', left: e }); };
+/** @internal */
+var right$1 = function (a) { return ({ _tag: 'Right', right: a }); };
+// -------------------------------------------------------------------------------------
+// Record
+// -------------------------------------------------------------------------------------
+/** @internal */
+var has = Object.prototype.hasOwnProperty;
+/** @internal */
+var flatMapTask$1 = function (F, M) {
+    /*#__PURE__*/ return dual(2, function (self, f) {
+        return M.flatMap(self, function (a) { return F.fromTask(f(a)); });
+    });
+};
+
 /**
  * A `Functor` is a type constructor which supports a mapping operation `map`.
  *
@@ -11465,7 +11562,7 @@ function map$5(F, G) {
  * @since 2.10.0
  */
 function fromOption$2(F) {
-    return function (onNone) { return function (ma) { return F.fromEither(Handler.isNone(ma) ? Handler.left(onNone()) : Handler.right(ma.value)); }; };
+    return function (onNone) { return function (ma) { return F.fromEither(isNone$1(ma) ? left$1(onNone()) : right$1(ma.value)); }; };
 }
 
 // -------------------------------------------------------------------------------------
@@ -11478,7 +11575,7 @@ function fromOption$2(F) {
  * @category constructors
  * @since 2.0.0
  */
-var left = Handler.left;
+var left = left$1;
 /**
  * Constructs a new `Either` holding a `Right` value. This usually represents a successful value due to the right bias
  * of this structure.
@@ -11486,14 +11583,14 @@ var left = Handler.left;
  * @category constructors
  * @since 2.0.0
  */
-var right = Handler.right;
+var right = right$1;
 /**
  * @category sequencing
  * @since 2.14.0
  */
-var flatMap$4 = /*#__PURE__*/ Handler.dual(2, function (ma, f) { return (isLeft(ma) ? ma : f(ma.right)); });
-var _map$1 = function (fa, f) { return Handler.pipe(fa, map$4(f)); };
-var _ap = function (fab, fa) { return Handler.pipe(fab, ap$1(fa)); };
+var flatMap$4 = /*#__PURE__*/ dual(2, function (ma, f) { return (isLeft(ma) ? ma : f(ma.right)); });
+var _map$1 = function (fa, f) { return pipe(fa, map$4(f)); };
+var _ap = function (fab, fa) { return pipe(fab, ap$1(fa)); };
 /**
  * @category type lambdas
  * @since 2.0.0
@@ -11552,7 +11649,7 @@ var mapLeft$1 = function (f) { return function (fa) {
  */
 var FromEither$1 = {
     URI: URI$2,
-    fromEither: Handler.identity
+    fromEither: identity
 };
 // -------------------------------------------------------------------------------------
 // conversions
@@ -11592,7 +11689,7 @@ var fromOption$1 =
  * @category refinements
  * @since 2.0.0
  */
-var isLeft = Handler.isLeft;
+var isLeft = isLeft$1;
 /**
  * Less strict version of [`match`](#match).
  *
@@ -11669,6 +11766,115 @@ var fromNullable$1 = function (e) {
  */
 var chain$2 = flatMap$4;
 
+/**
+ * If a type `A` can form a `Semigroup` it has an **associative** binary operation.
+ *
+ * ```ts
+ * interface Semigroup<A> {
+ *   readonly concat: (x: A, y: A) => A
+ * }
+ * ```
+ *
+ * Associativity means the following equality must hold for any choice of `x`, `y`, and `z`.
+ *
+ * ```ts
+ * concat(x, concat(y, z)) = concat(concat(x, y), z)
+ * ```
+ *
+ * A common example of a semigroup is the type `string` with the operation `+`.
+ *
+ * ```ts
+ * import { Semigroup } from 'fp-ts/Semigroup'
+ *
+ * const semigroupString: Semigroup<string> = {
+ *   concat: (x, y) => x + y
+ * }
+ *
+ * const x = 'x'
+ * const y = 'y'
+ * const z = 'z'
+ *
+ * semigroupString.concat(x, y) // 'xy'
+ *
+ * semigroupString.concat(x, semigroupString.concat(y, z)) // 'xyz'
+ *
+ * semigroupString.concat(semigroupString.concat(x, y), z) // 'xyz'
+ * ```
+ *
+ * *Adapted from https://typelevel.org/cats*
+ *
+ * @since 2.0.0
+ */
+/**
+ * Given a struct of semigroups returns a semigroup for the struct.
+ *
+ * @example
+ * import { struct } from 'fp-ts/Semigroup'
+ * import * as N from 'fp-ts/number'
+ *
+ * interface Point {
+ *   readonly x: number
+ *   readonly y: number
+ * }
+ *
+ * const S = struct<Point>({
+ *   x: N.SemigroupSum,
+ *   y: N.SemigroupSum
+ * })
+ *
+ * assert.deepStrictEqual(S.concat({ x: 1, y: 2 }, { x: 3, y: 4 }), { x: 4, y: 6 })
+ *
+ * @since 2.10.0
+ */
+var struct = function (semigroups) { return ({
+    concat: function (first, second) {
+        var r = {};
+        for (var k in semigroups) {
+            if (has.call(semigroups, k)) {
+                r[k] = semigroups[k].concat(first[k], second[k]);
+            }
+        }
+        return r;
+    }
+}); };
+// -------------------------------------------------------------------------------------
+// instances
+// -------------------------------------------------------------------------------------
+/**
+ * Always return the first argument.
+ *
+ * @example
+ * import * as S from 'fp-ts/Semigroup'
+ *
+ * assert.deepStrictEqual(S.first<number>().concat(1, 2), 1)
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+var first = function () { return ({ concat: identity }); };
+/**
+ * Always return the last argument.
+ *
+ * @example
+ * import * as S from 'fp-ts/Semigroup'
+ *
+ * assert.deepStrictEqual(S.last<number>().concat(1, 2), 2)
+ *
+ * @category instances
+ * @since 2.10.0
+ */
+var last = function () { return ({ concat: function (_, y) { return y; } }); };
+/**
+ * Use [`SemigroupSum`](./number.ts.html#SemigroupSum) instead.
+ *
+ * @category zone of death
+ * @since 2.0.0
+ * @deprecated
+ */
+var semigroupSum = {
+    concat: function (x, y) { return x + y; }
+};
+
 // -------------------------------------------------------------------------------------
 // constructors
 // -------------------------------------------------------------------------------------
@@ -11678,14 +11884,14 @@ var chain$2 = flatMap$4;
  * @category constructors
  * @since 2.0.0
  */
-var none = Handler.none;
+var none = none$1;
 /**
  * Constructs a `Some`. Represents an optional value that exists.
  *
  * @category constructors
  * @since 2.0.0
  */
-var some = Handler.some;
+var some = some$1;
 /**
  * Monoid returning the left-most non-`None` value. If both operands are `Some`s then the inner values are
  * concatenated using the provided `Semigroup`
@@ -11725,7 +11931,7 @@ var map$3 = function (f) { return function (fa) {
  * @category sequencing
  * @since 2.14.0
  */
-var flatMap$3 = /*#__PURE__*/ Handler.dual(2, function (ma, f) { return (isNone(ma) ? none : f(ma.value)); });
+var flatMap$3 = /*#__PURE__*/ dual(2, function (ma, f) { return (isNone(ma) ? none : f(ma.value)); });
 /**
  * Returns `true` if the option is `None`, `false` otherwise.
  *
@@ -11885,7 +12091,7 @@ var chain$1 = flatMap$3;
  * @since 2.0.0
  * @deprecated
  */
-var getFirstMonoid = function () { return getMonoid(Handler.first()); };
+var getFirstMonoid = function () { return getMonoid(first()); };
 
 function rightF(F) {
     return function (fa) { return F.map(fa, right); };
@@ -11914,8 +12120,8 @@ function mapError$1(F) {
  *
  * @since 2.0.0
  */
-var _map = function (fa, f) { return Handler.pipe(fa, map$1(f)); };
-var _apPar = function (fab, fa) { return Handler.pipe(fab, ap(fa)); };
+var _map = function (fa, f) { return pipe(fa, map$1(f)); };
+var _apPar = function (fab, fa) { return pipe(fab, ap(fa)); };
 /**
  * `map` can be used to turn functions `(a: A) => B` into functions `(fa: F<A>) => F<B>` whose argument and return types
  * use the type constructor `F` to represent some computational context.
@@ -11944,7 +12150,7 @@ var of = function (a) { return function () { return Promise.resolve(a); }; };
  * @category sequencing
  * @since 2.14.0
  */
-var flatMap$1 = /*#__PURE__*/ Handler.dual(2, function (ma, f) {
+var flatMap$1 = /*#__PURE__*/ dual(2, function (ma, f) {
     return function () {
         return Promise.resolve()
             .then(ma)
@@ -12018,7 +12224,7 @@ var map = /*#__PURE__*/ map$2(Functor);
  * @category error handling
  * @since 2.16.0
  */
-var mapError = /*#__PURE__*/ Handler.dual(2, mapError$1(Functor));
+var mapError = /*#__PURE__*/ dual(2, mapError$1(Functor));
 /**
  * Alias of `mapError`.
  *
@@ -12030,7 +12236,7 @@ var mapLeft = mapError;
  * @category sequencing
  * @since 2.14.0
  */
-var flatMap = /*#__PURE__*/ Handler.dual(2, flatMap$2(Monad));
+var flatMap = /*#__PURE__*/ dual(2, flatMap$2(Monad));
 /**
  * @category type lambdas
  * @since 2.0.0
@@ -12062,7 +12268,7 @@ var _FromTask = {
  * @category sequencing
  * @since 2.16.0
  */
-var flatMapTask = /*#__PURE__*/ Handler.flatMapTask(_FromTask, _FlatMap);
+var flatMapTask = /*#__PURE__*/ flatMapTask$1(_FromTask, _FlatMap);
 /**
  * Alias of `flatMapTask`.
  *
@@ -16230,7 +16436,7 @@ const emptyApiPathError = {
 };
 
 const stringMonoid = getMonoid(Monoid);
-const getApiPath = () => Handler.pipe(getFirstMonoid().concat(fromNullable(state$1.apiPath), fromNullable(`${"https://api.vviinn.com"}`)), fromOption$1(() => emptyApiPathError));
+const getApiPath = () => pipe(getFirstMonoid().concat(fromNullable(state$1.apiPath), fromNullable(`${"https://api.vviinn.com"}`)), fromOption$1(() => emptyApiPathError));
 const headersSemigroupSum = {
   concat: (x, y) => {
     const result = new Headers();
@@ -16241,14 +16447,14 @@ const headersSemigroupSum = {
     return result;
   },
 };
-const mergeInitRequests = Handler.struct({
+const mergeInitRequests = struct({
   method: {
     concat: (a, b) => {
       const method = stringMonoid.concat(fromNullable(a), fromNullable(b));
-      return Handler.pipe(method, getOrElse(() => "GET"));
+      return pipe(method, getOrElse(() => "GET"));
     },
   },
-  body: Handler.last(),
+  body: last(),
   headers: headersSemigroupSum,
 });
 const createBasicRequest = (method) => {
@@ -16278,7 +16484,7 @@ const makeRequest = (path, init) => ([apiPath, options,]) => {
 
 const isEmpty = (x) => x.length === 0;
 const checkEmpty = (x) => isEmpty(x) ? left("entity is empty") : right(x);
-const existAndNotEmpty = (x) => Handler.pipe(x, fromNullable$1("entity not exist"), chain$2(checkEmpty));
+const existAndNotEmpty = (x) => pipe(x, fromNullable$1("entity not exist"), chain$2(checkEmpty));
 const arrayToQueryString = (params) => params.length ? `?${params.join("&")}` : "";
 const parseExcluded = (value) => value
   .split(";")
@@ -16288,8 +16494,8 @@ const parseExcluded = (value) => value
 const createBearerHeaders = (token) => new Headers({
   Authorization: `Bearer ${token}`,
 });
-const checkToken = (token) => Handler.pipe(token, existAndNotEmpty, Either.mapLeft(() => invalidTokenError));
-const processBearerToken = (token) => Handler.pipe(token, checkToken, Either.map(createBearerHeaders));
+const checkToken = (token) => pipe(token, existAndNotEmpty, Either.mapLeft(() => invalidTokenError));
+const processBearerToken = (token) => pipe(token, checkToken, Either.map(createBearerHeaders));
 
 const sequenceToEither = Apply$1.sequenceT(Either.Apply);
 
@@ -16354,47 +16560,59 @@ const foldValueObject = (i) => {
   }
 };
 
-const getLink = (item, path) => Handler.pipe(item.links, fromNullable, chain$1((linksObject) => fromNullable(linksObject[path])));
-const linkRequest = (link) => (data) => Handler.pipe(sequenceToEither(getApiPath(), createRequestFromMethod(link.method)), fromEither, chainW(makeRequest(link.href, data)));
+const getLink = (item, path) => pipe(item.links, fromNullable, chain$1((linksObject) => fromNullable(linksObject[path])));
+const linkRequest = (link) => (data) => pipe(sequenceToEither(getApiPath(), createRequestFromMethod(link.method)), fromEither, chainW(makeRequest(link.href, data)));
 
-const move = (origin, position) => {
-  const originPosition = Handler.fromRectangle(origin);
-  const newPosition = Handler.pointSumSemigroup.concat(originPosition, position);
-  return Object.assign(Object.assign({}, newPosition), { width: origin.width, height: origin.height });
-};
-const transformNorthEast = (origin, handler) => {
-  const newPosition = Handler.pointSumSemigroup.concat(Handler.fromRectangle(origin), {
-    x: 0,
-    y: handler.position.y,
-  });
-  return Object.assign(Object.assign({}, newPosition), { width: origin.width + handler.position.x, height: origin.height - handler.position.y });
-};
-const transformNorthWest = (origin, handler) => {
-  const newPosition = Handler.pointSumSemigroup.concat(Handler.fromRectangle(origin), handler.position);
-  return Object.assign(Object.assign({}, newPosition), { width: origin.width - handler.position.x, height: origin.height - handler.position.y });
-};
-const transformSouthEast = (origin, handler) => {
-  return Object.assign(Object.assign({}, origin), { width: origin.width + handler.position.x, height: origin.height + handler.position.y });
-};
-const transformSouthWest = (origin, handler) => {
-  const newPosition = Handler.pointSumSemigroup.concat(Handler.fromRectangle(origin), {
-    x: handler.position.x,
-    y: 0,
-  });
-  return Object.assign(Object.assign({}, newPosition), { width: origin.width - handler.position.x, height: origin.height + handler.position.y });
-};
-const transform = (origin, handler) => {
-  switch (handler.direction) {
-    case Handler.HandlerDirection.NorthEast:
-      return transformNorthEast(origin, handler);
-    case Handler.HandlerDirection.NorthWest:
-      return transformNorthWest(origin, handler);
-    case Handler.HandlerDirection.SouthEast:
-      return transformSouthEast(origin, handler);
-    case Handler.HandlerDirection.SouthWest:
-      return transformSouthWest(origin, handler);
-  }
+const fromRectangle$1 = ({ x, y }) => {
+  return {
+    x,
+    y,
+  };
 };
+const pointSumSemigroup = struct({
+  x: semigroupSum,
+  y: semigroupSum,
+});
+
+var HandlerDirection;
+(function (HandlerDirection) {
+  HandlerDirection[HandlerDirection["East"] = 0] = "East";
+  HandlerDirection[HandlerDirection["North"] = 1] = "North";
+  HandlerDirection[HandlerDirection["NorthEast"] = 2] = "NorthEast";
+  HandlerDirection[HandlerDirection["NorthWest"] = 3] = "NorthWest";
+  HandlerDirection[HandlerDirection["South"] = 4] = "South";
+  HandlerDirection[HandlerDirection["SouthEast"] = 5] = "SouthEast";
+  HandlerDirection[HandlerDirection["SouthWest"] = 6] = "SouthWest";
+  HandlerDirection[HandlerDirection["West"] = 7] = "West";
+})(HandlerDirection || (HandlerDirection = {}));
+const fromRectangle = (r) => [
+  {
+    position: fromRectangle$1(r),
+    direction: HandlerDirection.NorthWest,
+  },
+  {
+    position: pointSumSemigroup.concat(fromRectangle$1(r), {
+      x: r.width,
+      y: 0,
+    }),
+    direction: HandlerDirection.NorthEast,
+  },
+  {
+    position: pointSumSemigroup.concat(fromRectangle$1(r), {
+      x: 0,
+      y: r.height,
+    }),
+    direction: HandlerDirection.SouthWest,
+  },
+  {
+    position: pointSumSemigroup.concat(fromRectangle$1(r), {
+      x: r.width,
+      y: r.height,
+    }),
+    direction: HandlerDirection.SouthEast,
+  },
+];
+
 const fromImage = (image) => {
   return {
     x: 0,
@@ -16529,11 +16747,11 @@ var findFirstMap$1 = function (f) {
     return function (as) {
         for (var i = 0; i < as.length; i++) {
             var out = f(as[i]);
-            if (Handler.isSome(out)) {
+            if (isSome(out)) {
                 return out;
             }
         }
-        return Handler.none;
+        return none$1;
     };
 };
 
@@ -17036,7 +17254,7 @@ const optionalResize = (image, size) => image.naturalWidth > size ? resizeImage(
 const resizeFileTo = (size) => (file) => _function.pipe(file, imageFromFileTask, Task.map((image) => optionalResize(image, size)), Task.chain(convertB64toFileTask));
 
 const RESIZED_IMAGE_WIDTH = 500;
-const makeAuthorizedRequest = (token) => Handler.pipe(token, processBearerToken, map$4((headers) => {
+const makeAuthorizedRequest = (token) => pipe(token, processBearerToken, map$4((headers) => {
   return {
     headers,
   };
@@ -17067,7 +17285,7 @@ const updateState = async (response) => {
   state.loading = false;
 };
 const makeLinkRequest = (link) => {
-  return Handler.pipe(makeAuthorizedRequest(state.token), fromEither, chainW(linkRequest(link)));
+  return pipe(makeAuthorizedRequest(state.token), fromEither, chainW(linkRequest(link)));
 };
 const detectObjects = async (data) => {
   state.objectDetectionInProgress = true;
@@ -17075,7 +17293,7 @@ const detectObjects = async (data) => {
     kind: "server",
     inner: "Can not get a link for objects detection",
   };
-  await Handler.pipe(getLink(data, "detectedObjects"), fromOption(() => error), chain(makeLinkRequest), map((objects) => (state.detectedObjects = foldValueObject(objects))))();
+  await pipe(getLink(data, "detectedObjects"), fromOption(() => error), chain(makeLinkRequest), map((objects) => (state.detectedObjects = foldValueObject(objects))))();
   state.objectDetectionInProgress = false;
 };
 const uploadHiresFile = async (sessionResponse, file) => {
@@ -17084,11 +17302,11 @@ const uploadHiresFile = async (sessionResponse, file) => {
     image: ionFile,
   };
   const form = sessionResponse.uploadHighResolutionImage;
-  await Handler.pipe(makeAuthorizedRequest(state.token), fromEither, chainW(formRequest(form, formPayload)))();
+  await pipe(makeAuthorizedRequest(state.token), fromEither, chainW(formRequest(form, formPayload)))();
 };
 const makeRectangularSearchRequest = async () => {
   state.loading = true;
-  Handler.pipe(sequenceToOption(state.imageBounds, state.searchArea), Option.map(async ([bounds, searchArea]) => {
+  pipe(sequenceToOption(state.imageBounds, state.searchArea), Option.map(async ([bounds, searchArea]) => {
     const scaled = divideOnSized(bounds)(searchArea);
     const searchRectangle = {
       width: scaled.width,
@@ -17096,14 +17314,14 @@ const makeRectangularSearchRequest = async () => {
       left: scaled.x,
       top: scaled.y,
     };
-    return await Handler.pipe(makeAuthorizedRequest(state.token), fromEither, chainW(formRequest(state.rectangleSearchForm, searchRectangle)), map(updateState))();
+    return await pipe(makeAuthorizedRequest(state.token), fromEither, chainW(formRequest(state.rectangleSearchForm, searchRectangle)), map(updateState))();
   }));
 };
 const uploadFile = (file) => {
   state.loading = true;
   const fileForm = imageFormFromFile(file);
   const tokenWithFile = sequenceToEither(processBearerToken(state.token), right(fileForm));
-  return Handler.pipe(tokenWithFile, map$4(([headers, body]) => {
+  return pipe(tokenWithFile, map$4(([headers, body]) => {
     return {
       headers,
       body,
@@ -17125,7 +17343,7 @@ onChange("activeIonLink", async (newLink) => {
   if (!link)
     return;
   state.loading = true;
-  await Handler.pipe(makeAuthorizedRequest(state.token), fromEither, chainW(linkRequest(link)), map(updateState), mapLeft((error) => {
+  await pipe(makeAuthorizedRequest(state.token), fromEither, chainW(linkRequest(link)), map(updateState), mapLeft((error) => {
     return {
       kind: "network error",
       inner: error,
@@ -17133,8 +17351,8 @@ onChange("activeIonLink", async (newLink) => {
   }))();
 });
 onChange("searchArea", (newSearchArea) => {
-  Handler.pipe(newSearchArea, Option.map((area) => {
-    state.cropperHandlers = Handler.fromRectangle$1(area);
+  pipe(newSearchArea, Option.map((area) => {
+    state.cropperHandlers = fromRectangle(area);
   }));
 });
 onChange("serverError", () => {
@@ -17147,10 +17365,10 @@ const setSelectedImage = (image) => {
 const processSelectedFile = async (file) => {
   const originFile = checkFileWithExtention(file);
   const fileResizer = resizeFileTo(RESIZED_IMAGE_WIDTH);
-  const resizeFileTask = Handler.pipe(originFile, fromEither, chainTaskK(fileResizer));
-  const session = await Handler.pipe(resizeFileTask, chain(uploadFile))();
-  Handler.pipe(sequenceToEither(session, originFile), map$4(([sessionObject, file]) => uploadHiresFile(sessionObject, file)));
-  await Handler.pipe(resizeFileTask, chainTaskK(imageFromFileTask), map(setSelectedImage))();
+  const resizeFileTask = pipe(originFile, fromEither, chainTaskK(fileResizer));
+  const session = await pipe(resizeFileTask, chain(uploadFile))();
+  pipe(sequenceToEither(session, originFile), map$4(([sessionObject, file]) => uploadHiresFile(sessionObject, file)));
+  await pipe(resizeFileTask, chainTaskK(imageFromFileTask), map(setSelectedImage))();
   return session;
 };
 
@@ -17176,6 +17394,7 @@ exports.fromAlt = fromAlt;
 exports.fromEither = fromEither;
 exports.fromImage = fromImage;
 exports.getApiPath = getApiPath;
+exports.has = has;
 exports.imageSearchState = imageSearchState;
 exports.isEmpty = isEmpty$1;
 exports.makeRectangularSearchRequest = makeRectangularSearchRequest;
@@ -17183,12 +17402,12 @@ exports.makeRequest = makeRequest;
 exports.map = map$3;
 exports.match = match;
 exports.match$1 = match$1;
-exports.move = move;
 exports.parseExcluded = parseExcluded;
+exports.pipe = pipe;
 exports.processSelectedFile = processSelectedFile;
 exports.scaleByLargestSide = scaleByLargestSide;
 exports.scaleWithSized = scaleWithSized;
 exports.sequenceToOption = sequenceToOption;
 exports.state = state$1;
 exports.toFile = toFile;
-exports.transform = transform;
+exports.tuple = tuple;

package/dist/cjs/{index-fef7ae7e.js → index-64803798.js}

@@ -1,6 +1,6 @@
 'use strict';
 
-const imageSearch_store = require('./imageSearch.store-cc9b4a68.js');
+const imageSearch_store = require('./imageSearch.store-070ddd94.js');
 
 // Unique ID creation requires a high quality random # generator. In the browser we therefore
 // require the crypto API and do not support built-in fallback to lower quality random number