compostjs 0.0.11 → 0.1.0

package/dist/fable_modules/fable-library-js.4.28.0/MapUtil.d.ts

@@ -0,0 +1,12 @@
+import { IMap, IMapOrWeakMap, ISet } from "./Util.js";
+import { FSharpRef } from "./Types.js";
+export declare function keyValueList(fields: Iterable<any>, caseRule?: number): {
+    [k: string]: any;
+};
+export declare function containsValue<K, V>(v: V, map: IMap<K, V>): boolean;
+export declare function tryGetValue<K, V>(map: IMapOrWeakMap<K, V>, key: K, defaultValue: FSharpRef<V>): boolean;
+export declare function addToSet<T>(v: T, set: ISet<T>): boolean;
+export declare function tryAddToDict<K, V>(dict: IMapOrWeakMap<K, V>, k: K, v: V): boolean;
+export declare function addToDict<K, V>(dict: IMapOrWeakMap<K, V>, k: K, v: V): void;
+export declare function getItemFromDict<K, V>(map: IMap<K, V>, key: K): V;
+export declare function getItemFromDictOrCreate<K, V>(map: IMapOrWeakMap<K, V>, key: K, createValue: (key: K) => V): V;

package/dist/fable_modules/fable-library-js.4.28.0/MapUtil.js

@@ -0,0 +1,127 @@
+import { equals } from "./Util.js";
+import { Union } from "./Types.js";
+const CaseRules = {
+    None: 0,
+    LowerFirst: 1,
+    SnakeCase: 2,
+    SnakeCaseAllCaps: 3,
+    KebabCase: 4,
+};
+function dashify(str, separator) {
+    return str.replace(/[a-z]?[A-Z]/g, (m) => m.length === 1
+        ? m.toLowerCase()
+        : m.charAt(0) + separator + m.charAt(1).toLowerCase());
+}
+function changeCase(str, caseRule) {
+    switch (caseRule) {
+        case CaseRules.LowerFirst:
+            return str.charAt(0).toLowerCase() + str.slice(1);
+        case CaseRules.SnakeCase:
+            return dashify(str, "_");
+        case CaseRules.SnakeCaseAllCaps:
+            return dashify(str, "_").toUpperCase();
+        case CaseRules.KebabCase:
+            return dashify(str, "-");
+        case CaseRules.None:
+        default:
+            return str;
+    }
+}
+export function keyValueList(fields, caseRule = CaseRules.None) {
+    const obj = {};
+    const definedCaseRule = caseRule;
+    function fail(kvPair) {
+        throw new Error("Cannot infer key and value of " + String(kvPair));
+    }
+    function assign(key, caseRule, value) {
+        key = changeCase(key, caseRule);
+        obj[key] = value;
+    }
+    for (let kvPair of fields) {
+        let caseRule = CaseRules.None;
+        if (kvPair == null) {
+            fail(kvPair);
+        }
+        // Deflate unions and use the defined case rule
+        if (kvPair instanceof Union) {
+            const name = kvPair.cases()[kvPair.tag];
+            kvPair = kvPair.fields.length === 0 ? name : [name].concat(kvPair.fields);
+            caseRule = definedCaseRule;
+        }
+        if (Array.isArray(kvPair)) {
+            switch (kvPair.length) {
+                case 0:
+                    fail(kvPair);
+                    break;
+                case 1:
+                    assign(kvPair[0], caseRule, true);
+                    break;
+                case 2:
+                    const value = kvPair[1];
+                    assign(kvPair[0], caseRule, value);
+                    break;
+                default:
+                    assign(kvPair[0], caseRule, kvPair.slice(1));
+            }
+        }
+        else if (typeof kvPair === "string") {
+            assign(kvPair, caseRule, true);
+        }
+        else {
+            fail(kvPair);
+        }
+    }
+    return obj;
+}
+// TODO: Move these methods to Map and Set modules
+export function containsValue(v, map) {
+    for (const kv of map) {
+        if (equals(v, kv[1])) {
+            return true;
+        }
+    }
+    return false;
+}
+export function tryGetValue(map, key, defaultValue) {
+    if (map.has(key)) {
+        defaultValue.contents = map.get(key);
+        return true;
+    }
+    return false;
+}
+export function addToSet(v, set) {
+    if (set.has(v)) {
+        return false;
+    }
+    set.add(v);
+    return true;
+}
+export function tryAddToDict(dict, k, v) {
+    if (dict.has(k)) {
+        return false;
+    }
+    dict.set(k, v);
+    return true;
+}
+export function addToDict(dict, k, v) {
+    if (dict.has(k)) {
+        throw new Error("An item with the same key has already been added. Key: " + k);
+    }
+    dict.set(k, v);
+}
+export function getItemFromDict(map, key) {
+    if (map.has(key)) {
+        return map.get(key);
+    }
+    else {
+        throw new Error(`The given key '${key}' was not present in the dictionary.`);
+    }
+}
+export function getItemFromDictOrCreate(map, key, createValue) {
+    if (map.has(key)) {
+        return map.get(key);
+    }
+    const value = createValue(key);
+    map.set(key, value);
+    return value;
+}

package/dist/fable_modules/fable-library-js.4.28.0/MutableMap.d.ts

@@ -0,0 +1,52 @@
+import { IEqualityComparer, IMap, IEnumerator } from "./Util.js";
+import { Option } from "./Option.js";
+import { int32 } from "./Int32.js";
+import { FSharpRef } from "./Types.js";
+import { TypeInfo } from "./Reflection.js";
+export declare class Dictionary<Key, Value> implements IMap<Key, Value>, Iterable<[Key, Value]>, Iterable<[Key, Value]> {
+    readonly comparer: IEqualityComparer<Key>;
+    readonly hashMap: IMap<int32, [Key, Value][]>;
+    "init@9": int32;
+    constructor(pairs: Iterable<[Key, Value]>, comparer: IEqualityComparer<Key>);
+    get [Symbol.toStringTag](): string;
+    toJSON(): any;
+    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
+    GetEnumerator(): IEnumerator<[Key, Value]>;
+    [Symbol.iterator](): Iterator<[Key, Value]>;
+    "System.Collections.Generic.ICollection`1.Add2B595"(item: [Key, Value]): void;
+    "System.Collections.Generic.ICollection`1.Clear"(): void;
+    "System.Collections.Generic.ICollection`1.Contains2B595"(item: [Key, Value]): boolean;
+    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array: [Key, Value][], arrayIndex: int32): void;
+    "System.Collections.Generic.ICollection`1.get_Count"(): int32;
+    "System.Collections.Generic.ICollection`1.get_IsReadOnly"(): boolean;
+    "System.Collections.Generic.ICollection`1.Remove2B595"(item: [Key, Value]): boolean;
+    "System.Collections.Generic.IDictionary`2.Add5BDDA1"(key: Key, value: Value): void;
+    "System.Collections.Generic.IDictionary`2.ContainsKey2B595"(key: Key): boolean;
+    "System.Collections.Generic.IDictionary`2.get_Item2B595"(key: Key): Value;
+    "System.Collections.Generic.IDictionary`2.set_Item5BDDA1"(key: Key, v: Value): void;
+    "System.Collections.Generic.IDictionary`2.get_Keys"(): Iterable<Key>;
+    "System.Collections.Generic.IDictionary`2.Remove2B595"(key: Key): boolean;
+    "System.Collections.Generic.IDictionary`2.TryGetValue6DC89625"(key: Key, value: FSharpRef<Value>): boolean;
+    "System.Collections.Generic.IDictionary`2.get_Values"(): Iterable<Value>;
+    get size(): int32;
+    clear(): void;
+    delete(k: Key): boolean;
+    entries(): Iterable<[Key, Value]>;
+    get(k: Key): Value;
+    has(k: Key): boolean;
+    keys(): Iterable<Key>;
+    set(k: Key, v: Value): IMap<Key, Value>;
+    values(): Iterable<Value>;
+    forEach(f: ((arg0: Value, arg1: Key, arg2: IMap<Key, Value>) => void), thisArg?: Option<any>): void;
+}
+export declare function Dictionary_$reflection(gen0: TypeInfo, gen1: TypeInfo): TypeInfo;
+export declare function Dictionary_$ctor_6623D9B3<Key, Value>(pairs: Iterable<[Key, Value]>, comparer: IEqualityComparer<Key>): Dictionary<Key, Value>;
+export declare function Dictionary__TryFind_2B595<Key, Value>(this$: Dictionary<Key, Value>, k: Key): Option<[Key, Value]>;
+export declare function Dictionary__get_Comparer<Key, Value>(this$: Dictionary<Key, Value>): IEqualityComparer<Key>;
+export declare function Dictionary__Clear<Key, Value>(this$: Dictionary<Key, Value>): void;
+export declare function Dictionary__get_Count<Key, Value>(this$: Dictionary<Key, Value>): int32;
+export declare function Dictionary__get_Item_2B595<Key, Value>(this$: Dictionary<Key, Value>, k: Key): Value;
+export declare function Dictionary__set_Item_5BDDA1<Key, Value>(this$: Dictionary<Key, Value>, k: Key, v: Value): void;
+export declare function Dictionary__Add_5BDDA1<Key, Value>(this$: Dictionary<Key, Value>, k: Key, v: Value): void;
+export declare function Dictionary__ContainsKey_2B595<Key, Value>(this$: Dictionary<Key, Value>, k: Key): boolean;
+export declare function Dictionary__Remove_2B595<Key, Value>(this$: Dictionary<Key, Value>, k: Key): boolean;

package/dist/fable_modules/fable-library-js.4.28.0/MutableMap.js

@@ -0,0 +1,327 @@
+import { disposeSafe, defaultOf, equals, toIterator, getEnumerator } from "./Util.js";
+import { iterate, map, delay, toArray, iterateIndexed, concat } from "./Seq.js";
+import { value as value_1 } from "./Option.js";
+import { setItem } from "./Array.js";
+import { FSharpRef } from "./Types.js";
+import { class_type } from "./Reflection.js";
+import { getItemFromDict, tryGetValue } from "./MapUtil.js";
+import { format } from "./String.js";
+export class Dictionary {
+    constructor(pairs, comparer) {
+        const this$ = new FSharpRef(defaultOf());
+        this.comparer = comparer;
+        this$.contents = this;
+        this.hashMap = (new Map([]));
+        this["init@9"] = 1;
+        const enumerator = getEnumerator(pairs);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const pair = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                Dictionary__Add_5BDDA1(this$.contents, pair[0], pair[1]);
+            }
+        }
+        finally {
+            disposeSafe(enumerator);
+        }
+    }
+    get [Symbol.toStringTag]() {
+        return "Dictionary";
+    }
+    toJSON() {
+        const this$ = this;
+        return Array.from(this$);
+    }
+    "System.Collections.IEnumerable.GetEnumerator"() {
+        const this$ = this;
+        return getEnumerator(this$);
+    }
+    GetEnumerator() {
+        const this$ = this;
+        return getEnumerator(concat(this$.hashMap.values()));
+    }
+    [Symbol.iterator]() {
+        return toIterator(getEnumerator(this));
+    }
+    "System.Collections.Generic.ICollection`1.Add2B595"(item) {
+        const this$ = this;
+        Dictionary__Add_5BDDA1(this$, item[0], item[1]);
+    }
+    "System.Collections.Generic.ICollection`1.Clear"() {
+        const this$ = this;
+        Dictionary__Clear(this$);
+    }
+    "System.Collections.Generic.ICollection`1.Contains2B595"(item) {
+        const this$ = this;
+        const matchValue = Dictionary__TryFind_2B595(this$, item[0]);
+        let matchResult, p_1;
+        if (matchValue != null) {
+            if (equals(value_1(matchValue)[1], item[1])) {
+                matchResult = 0;
+                p_1 = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return true;
+            default:
+                return false;
+        }
+    }
+    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array, arrayIndex) {
+        const this$ = this;
+        iterateIndexed((i, e) => {
+            setItem(array, arrayIndex + i, e);
+        }, this$);
+    }
+    "System.Collections.Generic.ICollection`1.get_Count"() {
+        const this$ = this;
+        return Dictionary__get_Count(this$) | 0;
+    }
+    "System.Collections.Generic.ICollection`1.get_IsReadOnly"() {
+        return false;
+    }
+    "System.Collections.Generic.ICollection`1.Remove2B595"(item) {
+        const this$ = this;
+        const matchValue = Dictionary__TryFind_2B595(this$, item[0]);
+        if (matchValue != null) {
+            if (equals(value_1(matchValue)[1], item[1])) {
+                Dictionary__Remove_2B595(this$, item[0]);
+            }
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    "System.Collections.Generic.IDictionary`2.Add5BDDA1"(key, value) {
+        const this$ = this;
+        Dictionary__Add_5BDDA1(this$, key, value);
+    }
+    "System.Collections.Generic.IDictionary`2.ContainsKey2B595"(key) {
+        const this$ = this;
+        return Dictionary__ContainsKey_2B595(this$, key);
+    }
+    "System.Collections.Generic.IDictionary`2.get_Item2B595"(key) {
+        const this$ = this;
+        return Dictionary__get_Item_2B595(this$, key);
+    }
+    "System.Collections.Generic.IDictionary`2.set_Item5BDDA1"(key, v) {
+        const this$ = this;
+        Dictionary__set_Item_5BDDA1(this$, key, v);
+    }
+    "System.Collections.Generic.IDictionary`2.get_Keys"() {
+        const this$ = this;
+        return toArray(delay(() => map((pair) => pair[0], this$)));
+    }
+    "System.Collections.Generic.IDictionary`2.Remove2B595"(key) {
+        const this$ = this;
+        return Dictionary__Remove_2B595(this$, key);
+    }
+    "System.Collections.Generic.IDictionary`2.TryGetValue6DC89625"(key, value) {
+        const this$ = this;
+        const matchValue = Dictionary__TryFind_2B595(this$, key);
+        if (matchValue != null) {
+            const pair = value_1(matchValue);
+            value.contents = pair[1];
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    "System.Collections.Generic.IDictionary`2.get_Values"() {
+        const this$ = this;
+        return toArray(delay(() => map((pair) => pair[1], this$)));
+    }
+    get size() {
+        const this$ = this;
+        return Dictionary__get_Count(this$) | 0;
+    }
+    clear() {
+        const this$ = this;
+        Dictionary__Clear(this$);
+    }
+    delete(k) {
+        const this$ = this;
+        return Dictionary__Remove_2B595(this$, k);
+    }
+    entries() {
+        const this$ = this;
+        return map((p) => [p[0], p[1]], this$);
+    }
+    get(k) {
+        const this$ = this;
+        return Dictionary__get_Item_2B595(this$, k);
+    }
+    has(k) {
+        const this$ = this;
+        return Dictionary__ContainsKey_2B595(this$, k);
+    }
+    keys() {
+        const this$ = this;
+        return map((p) => p[0], this$);
+    }
+    set(k, v) {
+        const this$ = this;
+        Dictionary__set_Item_5BDDA1(this$, k, v);
+        return this$;
+    }
+    values() {
+        const this$ = this;
+        return map((p) => p[1], this$);
+    }
+    forEach(f, thisArg) {
+        const this$ = this;
+        iterate((p) => {
+            f(p[1], p[0], this$);
+        }, this$);
+    }
+}
+export function Dictionary_$reflection(gen0, gen1) {
+    return class_type("Fable.Collections.Dictionary", [gen0, gen1], Dictionary);
+}
+export function Dictionary_$ctor_6623D9B3(pairs, comparer) {
+    return new Dictionary(pairs, comparer);
+}
+function Dictionary__TryFindIndex_2B595(this$, k) {
+    const h = this$.comparer.GetHashCode(k) | 0;
+    let matchValue;
+    let outArg = defaultOf();
+    matchValue = [tryGetValue(this$.hashMap, h, new FSharpRef(() => outArg, (v) => {
+            outArg = v;
+        })), outArg];
+    if (matchValue[0]) {
+        return [true, h, matchValue[1].findIndex((pair) => this$.comparer.Equals(k, pair[0]))];
+    }
+    else {
+        return [false, h, -1];
+    }
+}
+export function Dictionary__TryFind_2B595(this$, k) {
+    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);
+    let matchResult;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]];
+        default:
+            return undefined;
+    }
+}
+export function Dictionary__get_Comparer(this$) {
+    return this$.comparer;
+}
+export function Dictionary__Clear(this$) {
+    this$.hashMap.clear();
+}
+export function Dictionary__get_Count(this$) {
+    let count = 0;
+    let enumerator = getEnumerator(this$.hashMap.values());
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const pairs = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            count = ((count + pairs.length) | 0);
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    return count | 0;
+}
+export function Dictionary__get_Item_2B595(this$, k) {
+    const matchValue = Dictionary__TryFind_2B595(this$, k);
+    if (matchValue != null) {
+        return value_1(matchValue)[1];
+    }
+    else {
+        throw new Error("The item was not found in collection");
+    }
+}
+export function Dictionary__set_Item_5BDDA1(this$, k, v) {
+    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]] = [k, v];
+        }
+        else {
+            const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));
+        }
+    }
+    else {
+        this$.hashMap.set(matchValue[1], [[k, v]]);
+    }
+}
+export function Dictionary__Add_5BDDA1(this$, k, v) {
+    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            throw new Error(format("An item with the same key has already been added. Key: {0}", k));
+        }
+        else {
+            const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));
+        }
+    }
+    else {
+        this$.hashMap.set(matchValue[1], [[k, v]]);
+    }
+}
+export function Dictionary__ContainsKey_2B595(this$, k) {
+    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);
+    let matchResult;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return true;
+        default:
+            return false;
+    }
+}
+export function Dictionary__Remove_2B595(this$, k) {
+    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);
+    let matchResult;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0: {
+            getItemFromDict(this$.hashMap, matchValue[1]).splice(matchValue[2], 1);
+            return true;
+        }
+        default:
+            return false;
+    }
+}

package/dist/fable_modules/fable-library-js.4.28.0/MutableSet.d.ts

@@ -0,0 +1,39 @@
+import { IMap, IEqualityComparer, ISet, IEnumerator } from "./Util.js";
+import { int32 } from "./Int32.js";
+import { Option } from "./Option.js";
+import { TypeInfo } from "./Reflection.js";
+export declare class HashSet<T> implements ISet<T>, Iterable<T>, Iterable<T> {
+    readonly comparer: IEqualityComparer<T>;
+    readonly hashMap: IMap<int32, T[]>;
+    "init@9": int32;
+    constructor(items: Iterable<T>, comparer: IEqualityComparer<T>);
+    get [Symbol.toStringTag](): string;
+    toJSON(): any;
+    "System.Collections.IEnumerable.GetEnumerator"(): IEnumerator<any>;
+    GetEnumerator(): IEnumerator<T>;
+    [Symbol.iterator](): Iterator<T>;
+    "System.Collections.Generic.ICollection`1.Add2B595"(item: T): void;
+    "System.Collections.Generic.ICollection`1.Clear"(): void;
+    "System.Collections.Generic.ICollection`1.Contains2B595"(item: T): boolean;
+    "System.Collections.Generic.ICollection`1.CopyToZ3B4C077E"(array: T[], arrayIndex: int32): void;
+    "System.Collections.Generic.ICollection`1.get_Count"(): int32;
+    "System.Collections.Generic.ICollection`1.get_IsReadOnly"(): boolean;
+    "System.Collections.Generic.ICollection`1.Remove2B595"(item: T): boolean;
+    get size(): int32;
+    add(k: T): ISet<T>;
+    clear(): void;
+    delete(k: T): boolean;
+    has(k: T): boolean;
+    keys(): Iterable<T>;
+    values(): Iterable<T>;
+    entries(): Iterable<[T, T]>;
+    forEach(f: ((arg0: T, arg1: T, arg2: ISet<T>) => void), thisArg?: Option<any>): void;
+}
+export declare function HashSet_$reflection(gen0: TypeInfo): TypeInfo;
+export declare function HashSet_$ctor_Z6150332D<T>(items: Iterable<T>, comparer: IEqualityComparer<T>): HashSet<T>;
+export declare function HashSet__get_Comparer<T>(this$: HashSet<T>): IEqualityComparer<T>;
+export declare function HashSet__Clear<T>(this$: HashSet<T>): void;
+export declare function HashSet__get_Count<T>(this$: HashSet<T>): int32;
+export declare function HashSet__Add_2B595<T>(this$: HashSet<T>, k: T): boolean;
+export declare function HashSet__Contains_2B595<T>(this$: HashSet<T>, k: T): boolean;
+export declare function HashSet__Remove_2B595<T>(this$: HashSet<T>, k: T): boolean;