scats 1.4.0-dev → 1.4.1-dev

package/dist/hashmap.js

@@ -1,22 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HashMap = void 0;
-const index_1 = require("./index");
-const abstract_map_1 = require("./abstract-map");
-class HashMap extends abstract_map_1.AbstractMap {
+import { mutable } from './index.js';
+import { AbstractMap } from './abstract-map.js';
+export class HashMap extends AbstractMap {
+    map;
+    fromArray(array) {
+        return HashMap.of(...array);
+    }
     constructor(map) {
         super(map);
         this.map = map;
     }
-    fromArray(array) {
-        return HashMap.of(...array);
-    }
     static of(...values) {
         return new HashMap(new Map(values));
     }
     static from(values) {
         return HashMap.of(...Array.from(values));
     }
+    static empty = new HashMap(new Map());
     appendedAll(map) {
         return this.concat(map);
     }
@@ -66,8 +65,6 @@ class HashMap extends abstract_map_1.AbstractMap {
         };
     }
     get toMutable() {
-        return index_1.mutable.HashMap.of(...Array.from(this.map.entries()));
+        return mutable.HashMap.of(...Array.from(this.map.entries()));
     }
 }
-exports.HashMap = HashMap;
-HashMap.empty = new HashMap(new Map());

package/dist/hashset.d.ts

@@ -1,6 +1,6 @@
-import { HashMap } from './hashmap';
-import { AbstractSet } from './abstract-set';
-import * as mutable from './mutable/hashset';
+import { HashMap } from './hashmap.js';
+import { AbstractSet } from './abstract-set.js';
+import * as mutable from './mutable/hashset.js';
 export declare class HashSet<T> extends AbstractSet<T, HashSet<T>> {
     protected constructor(items: Set<T>);
     static empty: HashSet<any>;

package/dist/hashset.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HashSet = void 0;
-const tslib_1 = require("tslib");
-const hashmap_1 = require("./hashmap");
-const abstract_set_1 = require("./abstract-set");
-const mutable = (0, tslib_1.__importStar)(require("./mutable/hashset"));
-class HashSet extends abstract_set_1.AbstractSet {
+import { HashMap } from './hashmap.js';
+import { AbstractSet } from './abstract-set.js';
+import * as mutable from './mutable/hashset.js';
+export class HashSet extends AbstractSet {
     constructor(items) {
         super(items);
     }
+    static empty = new HashSet(new Set());
     static of(...items) {
         return new HashSet(new Set(items));
     }
@@ -19,7 +16,7 @@ class HashSet extends abstract_set_1.AbstractSet {
         return HashSet.of(...array);
     }
     toMap(mapper) {
-        return hashmap_1.HashMap.of(...this.map(mapper).toArray);
+        return HashMap.of(...this.map(mapper).toArray);
     }
     map(f) {
         return HashSet.of(...Array.from(this.items).map(i => f(i)));
@@ -62,5 +59,3 @@ class HashSet extends abstract_set_1.AbstractSet {
         return mutable.HashSet.of(...this.items);
     }
 }
-exports.HashSet = HashSet;
-HashSet.empty = new HashSet(new Set());

package/dist/index.d.ts

@@ -1,9 +1,9 @@
-export * from './collection';
-export * from './either';
-export * from './hashmap';
-export * from './hashset';
-export * from './option';
-export * from './try';
-export * from './util';
-import * as mutable from './mutable';
+export * from './collection.js';
+export * from './either.js';
+export * from './hashmap.js';
+export * from './hashset.js';
+export * from './option.js';
+export * from './try.js';
+export * from './util.js';
+import * as mutable from './mutable.js';
 export { mutable };

package/dist/index.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mutable = void 0;
-const tslib_1 = require("tslib");
-(0, tslib_1.__exportStar)(require("./collection"), exports);
-(0, tslib_1.__exportStar)(require("./either"), exports);
-(0, tslib_1.__exportStar)(require("./hashmap"), exports);
-(0, tslib_1.__exportStar)(require("./hashset"), exports);
-(0, tslib_1.__exportStar)(require("./option"), exports);
-(0, tslib_1.__exportStar)(require("./try"), exports);
-(0, tslib_1.__exportStar)(require("./util"), exports);
-const mutable = (0, tslib_1.__importStar)(require("./mutable"));
-exports.mutable = mutable;
+export * from './collection.js';
+export * from './either.js';
+export * from './hashmap.js';
+export * from './hashset.js';
+export * from './option.js';
+export * from './try.js';
+export * from './util.js';
+import * as mutable from './mutable.js';
+export { mutable };

package/dist/mappable.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/dist/mutable/hashmap.d.ts

@@ -1,6 +1,6 @@
-import { Option } from '../option';
-import { AbstractMap, Tuple2 } from '../abstract-map';
-import * as immutable from '../hashmap';
+import { Option } from '../option.js';
+import { AbstractMap, Tuple2 } from '../abstract-map.js';
+import * as immutable from '../hashmap.js';
 export declare class HashMap<K, V> extends AbstractMap<K, V, HashMap<K, V>> {
     constructor(map?: Map<K, V>);
     protected fromArray(array: Tuple2<K, V>[]): HashMap<K, V>;

package/dist/mutable/hashmap.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HashMap = void 0;
-const tslib_1 = require("tslib");
-const abstract_map_1 = require("../abstract-map");
-const immutable = (0, tslib_1.__importStar)(require("../hashmap"));
-class HashMap extends abstract_map_1.AbstractMap {
+import { AbstractMap } from '../abstract-map.js';
+import * as immutable from '../hashmap.js';
+export class HashMap extends AbstractMap {
     constructor(map = new Map()) {
         super(map);
     }
@@ -115,4 +111,3 @@ class HashMap extends abstract_map_1.AbstractMap {
         return immutable.HashMap.of(...this.map.entries());
     }
 }
-exports.HashMap = HashMap;

package/dist/mutable/hashset.d.ts

@@ -1,5 +1,5 @@
-import { AbstractSet } from '../abstract-set';
-import * as immutable from '../hashset';
+import { AbstractSet } from '../abstract-set.js';
+import * as immutable from '../hashset.js';
 export declare class HashSet<T> extends AbstractSet<T, HashSet<T>> {
     constructor(items?: Set<T>);
     static of<T>(...items: T[]): HashSet<T>;

package/dist/mutable/hashset.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HashSet = void 0;
-const tslib_1 = require("tslib");
-const abstract_set_1 = require("../abstract-set");
-const immutable = (0, tslib_1.__importStar)(require("../hashset"));
-class HashSet extends abstract_set_1.AbstractSet {
+import { AbstractSet } from '../abstract-set.js';
+import * as immutable from '../hashset.js';
+export class HashSet extends AbstractSet {
     constructor(items = new Set()) {
         super(items);
     }
@@ -85,4 +81,3 @@ class HashSet extends abstract_set_1.AbstractSet {
         return immutable.HashSet.of(...this.items);
     }
 }
-exports.HashSet = HashSet;

package/dist/mutable.d.ts

@@ -1,3 +1,3 @@
-export { ArrayBuffer } from './collection';
-export { HashMap } from './mutable/hashmap';
-export { HashSet } from './mutable/hashset';
+export { ArrayBuffer } from './collection.js';
+export { HashMap } from './mutable/hashmap.js';
+export { HashSet } from './mutable/hashset.js';

package/dist/mutable.js

@@ -1,9 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.HashSet = exports.HashMap = exports.ArrayBuffer = void 0;
-var collection_1 = require("./collection");
-Object.defineProperty(exports, "ArrayBuffer", { enumerable: true, get: function () { return collection_1.ArrayBuffer; } });
-var hashmap_1 = require("./mutable/hashmap");
-Object.defineProperty(exports, "HashMap", { enumerable: true, get: function () { return hashmap_1.HashMap; } });
-var hashset_1 = require("./mutable/hashset");
-Object.defineProperty(exports, "HashSet", { enumerable: true, get: function () { return hashset_1.HashSet; } });
+export { ArrayBuffer } from './collection.js';
+export { HashMap } from './mutable/hashmap.js';
+export { HashSet } from './mutable/hashset.js';

package/dist/option.d.ts

@@ -1,9 +1,9 @@
-import { Collection } from './collection';
-import { Either } from './either';
-import { ArrayIterable } from './array-iterable';
-import { HashSet } from './hashset';
-import { HashMap } from './hashmap';
-import { Mappable } from './mappable';
+import { Collection } from './collection.js';
+import { Either } from './either.js';
+import { ArrayIterable } from './array-iterable.js';
+import { HashSet } from './hashset.js';
+import { HashMap } from './hashmap.js';
+import { Mappable } from './mappable.js';
 export interface OptionMatch<A, T> {
     some: (value: A) => T;
     none: () => T;

package/dist/option.js

@@ -1,20 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.none = exports.some = exports.option = exports.None = exports.Some = exports.Option = void 0;
-const tslib_1 = require("tslib");
-const collection_1 = require("./collection");
-const either_1 = require("./either");
-const array_iterable_1 = require("./array-iterable");
-const hashset_1 = require("./hashset");
-const hashmap_1 = require("./hashmap");
-class Option extends array_iterable_1.ArrayIterable {
+import { Collection } from './collection.js';
+import { Left, left, Right, right } from './either.js';
+import { ArrayIterable } from './array-iterable.js';
+import { HashSet } from './hashset.js';
+import { HashMap } from './hashmap.js';
+export class Option extends ArrayIterable {
     static when(cond) {
         return a => {
             if (cond) {
                 return some(a());
             }
             else {
-                return exports.none;
+                return none;
             }
         };
     }
@@ -23,7 +19,7 @@ class Option extends array_iterable_1.ArrayIterable {
     }
     fromArray(array) {
         if (array.length <= 0) {
-            return exports.none;
+            return none;
         }
         else {
             return some(array[0]);
@@ -39,39 +35,37 @@ class Option extends array_iterable_1.ArrayIterable {
     }
     filter(p) {
         if (this.isEmpty) {
-            return exports.none;
+            return none;
         }
         else {
-            return p(this.get) ? this : exports.none;
+            return p(this.get) ? this : none;
         }
     }
     filterNot(p) {
         if (this.isEmpty) {
-            return exports.none;
+            return none;
         }
         else {
-            return p(this.get) ? exports.none : this;
+            return p(this.get) ? none : this;
         }
     }
     map(f) {
-        return this.isEmpty ? exports.none : some(f(this.get));
+        return this.isEmpty ? none : some(f(this.get));
     }
     flatMap(p) {
-        return this.isEmpty ? exports.none : p(this.get);
+        return this.isEmpty ? none : p(this.get);
     }
-    mapPromise(f) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            if (this.isEmpty) {
-                return Promise.resolve(exports.none);
-            }
-            else {
-                return option(yield f(this.get));
-            }
-        });
+    async mapPromise(f) {
+        if (this.isEmpty) {
+            return Promise.resolve(none);
+        }
+        else {
+            return option(await f(this.get));
+        }
     }
     flatMapPromise(f) {
         if (this.isEmpty) {
-            return Promise.resolve(exports.none);
+            return Promise.resolve(none);
         }
         else {
             return f(this.get);
@@ -126,29 +120,29 @@ class Option extends array_iterable_1.ArrayIterable {
         return this.isEmpty ? undefined : this.get;
     }
     get toCollection() {
-        return this.isEmpty ? collection_1.Collection.empty : collection_1.Collection.of(this.get);
+        return this.isEmpty ? Collection.empty : Collection.of(this.get);
     }
     toRight(left) {
-        return this.isEmpty ? new either_1.Left(left()) : (0, either_1.right)(this.get);
+        return this.isEmpty ? new Left(left()) : right(this.get);
     }
     toLeft(right) {
-        return this.isEmpty ? new either_1.Right(right()) : (0, either_1.left)(this.get);
+        return this.isEmpty ? new Right(right()) : left(this.get);
     }
     get toArray() {
         return this.isEmpty ? [] : [this.get];
     }
     get toSet() {
-        return this.isEmpty ? hashset_1.HashSet.empty : hashset_1.HashSet.of(this.get);
+        return this.isEmpty ? HashSet.empty : HashSet.of(this.get);
     }
     match(matcher) {
         return this.isEmpty ? matcher.none() : matcher.some(this.get);
     }
     toMap(mapper) {
-        return this.isEmpty ? hashmap_1.HashMap.empty : hashmap_1.HashMap.of(...this.map(mapper).toArray);
+        return this.isEmpty ? HashMap.empty : HashMap.of(...this.map(mapper).toArray);
     }
 }
-exports.Option = Option;
-class Some extends Option {
+export class Some extends Option {
+    value;
     constructor(value) {
         super();
         this.value = value;
@@ -160,8 +154,7 @@ class Some extends Option {
         return false;
     }
 }
-exports.Some = Some;
-class None extends Option {
+export class None extends Option {
     get get() {
         throw new Error('No such element.');
     }
@@ -169,13 +162,10 @@ class None extends Option {
         return true;
     }
 }
-exports.None = None;
-function option(value) {
-    return value === null || typeof value === 'undefined' ? exports.none : some(value);
+export function option(value) {
+    return value === null || typeof value === 'undefined' ? none : some(value);
 }
-exports.option = option;
-function some(value) {
+export function some(value) {
     return new Some(value);
 }
-exports.some = some;
-exports.none = new None();
+export const none = new None();

package/dist/try.d.ts

@@ -1,6 +1,6 @@
-import { Option } from './option';
-import { Either } from './either';
-import { Mappable } from './mappable';
+import { Option } from './option.js';
+import { Either } from './either.js';
+import { Mappable } from './mappable.js';
 export interface TryMatch<T, R> {
     success: (result: T) => R;
     failure: (error: Error) => R;

package/dist/try.js

@@ -1,17 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.failure = exports.success = exports.Try = exports.Failure = exports.Success = exports.TryLike = void 0;
-const tslib_1 = require("tslib");
-const option_1 = require("./option");
-const either_1 = require("./either");
-const util_1 = require("./util");
-class TryLike {
-    mapPromise(f) {
-        return (0, tslib_1.__awaiter)(this, void 0, void 0, function* () {
-            return this.match({
-                success: r => Try.promise(() => f(r)),
-                failure: () => Promise.resolve(this)
-            });
+import { none, some } from './option.js';
+import { left, right } from './either.js';
+import { identity } from './util.js';
+export class TryLike {
+    async mapPromise(f) {
+        return this.match({
+            success: r => Try.promise(() => f(r)),
+            failure: () => Promise.resolve(this)
         });
     }
     flatMapPromise(f) {
@@ -41,24 +35,24 @@ class TryLike {
     }
     toEitherWithLeft(f) {
         return this.match({
-            success: r => (0, either_1.right)(r),
-            failure: e => (0, either_1.left)(f(e))
+            success: r => right(r),
+            failure: e => left(f(e))
         });
     }
 }
-exports.TryLike = TryLike;
-class Success extends TryLike {
+export class Success extends TryLike {
+    result;
+    isSuccess = true;
+    isFailure = false;
     constructor(result) {
         super();
         this.result = result;
-        this.isSuccess = true;
-        this.isFailure = false;
     }
     get toOption() {
-        return (0, option_1.some)(this.result);
+        return some(this.result);
     }
     get toEither() {
-        return (0, either_1.right)(this.result);
+        return right(this.result);
     }
     map(f) {
         return success(f(this.result));
@@ -120,19 +114,19 @@ class Success extends TryLike {
         return this.flatMap(s);
     }
 }
-exports.Success = Success;
-class Failure extends TryLike {
+export class Failure extends TryLike {
+    error;
+    isSuccess = false;
+    isFailure = true;
     constructor(error) {
         super();
         this.error = error;
-        this.isSuccess = false;
-        this.isFailure = true;
     }
     get toOption() {
-        return option_1.none;
+        return none;
     }
     get toEither() {
-        return (0, either_1.left)(this.error);
+        return left(this.error);
     }
     map(_) {
         return this;
@@ -178,7 +172,7 @@ class Failure extends TryLike {
         }
     }
     recoverWith(f) {
-        return this.transform(util_1.identity, f);
+        return this.transform(identity, f);
     }
     transform(s, f) {
         try {
@@ -189,8 +183,7 @@ class Failure extends TryLike {
         }
     }
 }
-exports.Failure = Failure;
-function Try(block) {
+export function Try(block) {
     try {
         return new Success(block());
     }
@@ -198,7 +191,6 @@ function Try(block) {
         return new Failure(e);
     }
 }
-exports.Try = Try;
 (function (Try) {
     function promise(block) {
         try {
@@ -211,12 +203,10 @@ exports.Try = Try;
         }
     }
     Try.promise = promise;
-})(Try = exports.Try || (exports.Try = {}));
-function success(x) {
+})(Try || (Try = {}));
+export function success(x) {
     return new Success(x);
 }
-exports.success = success;
-function failure(x) {
+export function failure(x) {
     return new Failure(x);
 }
-exports.failure = failure;

package/dist/util.d.ts

@@ -1,5 +1,5 @@
-import { Option } from './option';
-import { Mappable } from './mappable';
+import { Option } from './option.js';
+import { Mappable } from './mappable.js';
 export declare function identity<T>(x: T): T;
 export declare function toErrorConversion(x: unknown): Error;
 export declare type StepFunction<R> = (state: any) => R;