starlight-fsharp-oracle 0.1.0 → 0.1.2

package/dist/fable_modules/fable-library-js.5.0.0-rc.7/MapUtil.js

@@ -0,0 +1,130 @@
+import { Exception, equals } from "./Util.js";
+import { Union } from "./Types.js";
+const CaseRules = {
+    None: 0,
+    LowerFirst: 1,
+    SnakeCase: 2,
+    SnakeCaseAllCaps: 3,
+    KebabCase: 4,
+    LowerAll: 5,
+};
+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.LowerAll:
+            return str.toLowerCase();
+        case CaseRules.None:
+        default:
+            return str;
+    }
+}
+export function keyValueList(fields, caseRule = CaseRules.None) {
+    const obj = {};
+    const definedCaseRule = caseRule;
+    function fail(kvPair) {
+        throw new Exception("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 Exception("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 Exception(`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.5.0.0-rc.7/MutableMap.js

@@ -0,0 +1,339 @@
+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 { item as item_1, setItem } from "./Array.js";
+import { FSharpRef } from "./Types.js";
+import { class_type } from "./Reflection.js";
+import { getItemFromDict, tryGetValue } from "./MapUtil.js";
+import { KeyNotFoundException_$ctor_Z721C83C5 } from "./System.Collections.Generic.js";
+import { ArgumentException_$ctor_Z721C83C5 } from "./System.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 = undefined, pair_1 = undefined;
+        if (matchValue != null) {
+            if (equals(value_1(matchValue)[1], item[1])) {
+                matchResult = 0;
+                pair_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]);
+        let matchResult = undefined, pair_1 = undefined;
+        if (matchValue != null) {
+            if (equals(value_1(matchValue)[1], item[1])) {
+                matchResult = 0;
+                pair_1 = value_1(matchValue);
+            }
+            else {
+                matchResult = 1;
+            }
+        }
+        else {
+            matchResult = 1;
+        }
+        switch (matchResult) {
+            case 0:
+                return Dictionary__Remove_2B595(this$, item[0]);
+            default:
+                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 = undefined;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return item_1(matchValue[2], getItemFromDict(this$.hashMap, matchValue[1]));
+        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 KeyNotFoundException_$ctor_Z721C83C5("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) {
+            setItem(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 ArgumentException_$ctor_Z721C83C5(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 = undefined;
+    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 = undefined;
+    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.5.0.0-rc.7/MutableSet.js

@@ -0,0 +1,233 @@
+import { disposeSafe, defaultOf, toIterator, getEnumerator } from "./Util.js";
+import { iterate, map, iterateIndexed, concat } from "./Seq.js";
+import { item as item_1, setItem } from "./Array.js";
+import { some } from "./Option.js";
+import { FSharpRef } from "./Types.js";
+import { class_type } from "./Reflection.js";
+import { getItemFromDict, tryGetValue } from "./MapUtil.js";
+export class HashSet {
+    constructor(items, comparer) {
+        const this$ = new FSharpRef(defaultOf());
+        this.comparer = comparer;
+        this$.contents = this;
+        this.hashMap = (new Map([]));
+        this["init@9"] = 1;
+        const enumerator = getEnumerator(items);
+        try {
+            while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+                const item = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+                HashSet__Add_2B595(this$.contents, item);
+            }
+        }
+        finally {
+            disposeSafe(enumerator);
+        }
+    }
+    get [Symbol.toStringTag]() {
+        return "HashSet";
+    }
+    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;
+        HashSet__Add_2B595(this$, item);
+    }
+    "System.Collections.Generic.ICollection`1.Clear"() {
+        const this$ = this;
+        HashSet__Clear(this$);
+    }
+    "System.Collections.Generic.ICollection`1.Contains2B595"(item) {
+        const this$ = this;
+        return HashSet__Contains_2B595(this$, item);
+    }
+    "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 HashSet__get_Count(this$) | 0;
+    }
+    "System.Collections.Generic.ICollection`1.get_IsReadOnly"() {
+        return false;
+    }
+    "System.Collections.Generic.ICollection`1.Remove2B595"(item) {
+        const this$ = this;
+        return HashSet__Remove_2B595(this$, item);
+    }
+    get size() {
+        const this$ = this;
+        return HashSet__get_Count(this$) | 0;
+    }
+    add(k) {
+        const this$ = this;
+        HashSet__Add_2B595(this$, k);
+        return this$;
+    }
+    clear() {
+        const this$ = this;
+        HashSet__Clear(this$);
+    }
+    delete(k) {
+        const this$ = this;
+        return HashSet__Remove_2B595(this$, k);
+    }
+    has(k) {
+        const this$ = this;
+        return HashSet__Contains_2B595(this$, k);
+    }
+    keys() {
+        const this$ = this;
+        return map((x) => x, this$);
+    }
+    values() {
+        const this$ = this;
+        return map((x) => x, this$);
+    }
+    entries() {
+        const this$ = this;
+        return map((v) => [v, v], this$);
+    }
+    forEach(f, thisArg) {
+        const this$ = this;
+        iterate((x) => {
+            f(x, x, this$);
+        }, this$);
+    }
+}
+export function HashSet_$reflection(gen0) {
+    return class_type("Fable.Collections.HashSet", [gen0], HashSet);
+}
+export function HashSet_$ctor_Z6150332D(items, comparer) {
+    return new HashSet(items, comparer);
+}
+function HashSet__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((v_1) => this$.comparer.Equals(k, v_1))];
+    }
+    else {
+        return [false, h, -1];
+    }
+}
+function HashSet__TryFind_2B595(this$, k) {
+    const matchValue = HashSet__TryFindIndex_2B595(this$, k);
+    let matchResult = undefined;
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            matchResult = 0;
+        }
+        else {
+            matchResult = 1;
+        }
+    }
+    else {
+        matchResult = 1;
+    }
+    switch (matchResult) {
+        case 0:
+            return some(item_1(matchValue[2], getItemFromDict(this$.hashMap, matchValue[1])));
+        default:
+            return undefined;
+    }
+}
+export function HashSet__get_Comparer(this$) {
+    return this$.comparer;
+}
+export function HashSet__Clear(this$) {
+    this$.hashMap.clear();
+}
+export function HashSet__get_Count(this$) {
+    let count = 0;
+    let enumerator = getEnumerator(this$.hashMap.values());
+    try {
+        while (enumerator["System.Collections.IEnumerator.MoveNext"]()) {
+            const items = enumerator["System.Collections.Generic.IEnumerator`1.get_Current"]();
+            count = ((count + items.length) | 0);
+        }
+    }
+    finally {
+        disposeSafe(enumerator);
+    }
+    return count | 0;
+}
+export function HashSet__Add_2B595(this$, k) {
+    const matchValue = HashSet__TryFindIndex_2B595(this$, k);
+    if (matchValue[0]) {
+        if (matchValue[2] > -1) {
+            return false;
+        }
+        else {
+            const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push(k));
+            return true;
+        }
+    }
+    else {
+        this$.hashMap.set(matchValue[1], [k]);
+        return true;
+    }
+}
+export function HashSet__Contains_2B595(this$, k) {
+    const matchValue = HashSet__TryFindIndex_2B595(this$, k);
+    let matchResult = undefined;
+    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 HashSet__Remove_2B595(this$, k) {
+    const matchValue = HashSet__TryFindIndex_2B595(this$, k);
+    let matchResult = undefined;
+    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.5.0.0-rc.7/Native.js

@@ -0,0 +1,14 @@
+export function Helpers_allocateArrayFromCons(cons, len) {
+    if (cons == null) {
+        return new Array(len);
+    }
+    else {
+        const cons_1 = cons;
+        if ((typeof cons_1) === "function") {
+            return new cons_1(len);
+        }
+        else {
+            return new Array(len);
+        }
+    }
+}