starlight-fsharp-oracle 0.1.0 → 0.1.2

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

@@ -0,0 +1,283 @@
+import { Exception } from "./Util.js";
+import { class_type } from "./Reflection.js";
+import { SR_Arg_ArgumentOutOfRangeException, SR_ArgumentNull_Generic, SR_Arg_ArgumentException, SR_Arg_ParamName_Name, SR_Arg_TimeoutException, SR_Arg_StackOverflowException, SR_Arg_RankException, SR_Arg_OverflowException, SR_Arg_OutOfMemoryException, SR_Arg_NullReferenceException, SR_Arg_NotSupportedException, SR_Arg_NotImplementedException, SR_Arg_NotFiniteNumberException, SR_Arg_InvalidOperationException, SR_Arg_IndexOutOfRangeException, SR_Arg_FormatException, SR_Arg_DivideByZero, SR_Arg_ArithmeticException, SR_Arg_ApplicationException, SR_Arg_SystemException } from "./Global.js";
+import { isNullOrEmpty } from "./String.js";
+export class SystemException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function SystemException_$reflection() {
+    return class_type("System.SystemException", undefined, SystemException, class_type("System.Exception"));
+}
+export function SystemException_$ctor_Z721C83C5(message) {
+    return new SystemException(message);
+}
+export function SystemException_$ctor() {
+    return SystemException_$ctor_Z721C83C5(SR_Arg_SystemException);
+}
+export class ApplicationException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function ApplicationException_$reflection() {
+    return class_type("System.ApplicationException", undefined, ApplicationException, class_type("System.Exception"));
+}
+export function ApplicationException_$ctor_Z721C83C5(message) {
+    return new ApplicationException(message);
+}
+export function ApplicationException_$ctor() {
+    return ApplicationException_$ctor_Z721C83C5(SR_Arg_ApplicationException);
+}
+export class ArithmeticException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function ArithmeticException_$reflection() {
+    return class_type("System.ArithmeticException", undefined, ArithmeticException, class_type("System.Exception"));
+}
+export function ArithmeticException_$ctor_Z721C83C5(message) {
+    return new ArithmeticException(message);
+}
+export function ArithmeticException_$ctor() {
+    return ArithmeticException_$ctor_Z721C83C5(SR_Arg_ArithmeticException);
+}
+export class DivideByZeroException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function DivideByZeroException_$reflection() {
+    return class_type("System.DivideByZeroException", undefined, DivideByZeroException, class_type("System.Exception"));
+}
+export function DivideByZeroException_$ctor_Z721C83C5(message) {
+    return new DivideByZeroException(message);
+}
+export function DivideByZeroException_$ctor() {
+    return DivideByZeroException_$ctor_Z721C83C5(SR_Arg_DivideByZero);
+}
+export class FormatException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function FormatException_$reflection() {
+    return class_type("System.FormatException", undefined, FormatException, class_type("System.Exception"));
+}
+export function FormatException_$ctor_Z721C83C5(message) {
+    return new FormatException(message);
+}
+export function FormatException_$ctor() {
+    return FormatException_$ctor_Z721C83C5(SR_Arg_FormatException);
+}
+export class IndexOutOfRangeException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function IndexOutOfRangeException_$reflection() {
+    return class_type("System.IndexOutOfRangeException", undefined, IndexOutOfRangeException, class_type("System.Exception"));
+}
+export function IndexOutOfRangeException_$ctor_Z721C83C5(message) {
+    return new IndexOutOfRangeException(message);
+}
+export function IndexOutOfRangeException_$ctor() {
+    return IndexOutOfRangeException_$ctor_Z721C83C5(SR_Arg_IndexOutOfRangeException);
+}
+export class InvalidOperationException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function InvalidOperationException_$reflection() {
+    return class_type("System.InvalidOperationException", undefined, InvalidOperationException, class_type("System.Exception"));
+}
+export function InvalidOperationException_$ctor_Z721C83C5(message) {
+    return new InvalidOperationException(message);
+}
+export function InvalidOperationException_$ctor() {
+    return InvalidOperationException_$ctor_Z721C83C5(SR_Arg_InvalidOperationException);
+}
+export class NotFiniteNumberException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function NotFiniteNumberException_$reflection() {
+    return class_type("System.NotFiniteNumberException", undefined, NotFiniteNumberException, class_type("System.Exception"));
+}
+export function NotFiniteNumberException_$ctor_Z721C83C5(message) {
+    return new NotFiniteNumberException(message);
+}
+export function NotFiniteNumberException_$ctor() {
+    return NotFiniteNumberException_$ctor_Z721C83C5(SR_Arg_NotFiniteNumberException);
+}
+export class NotImplementedException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function NotImplementedException_$reflection() {
+    return class_type("System.NotImplementedException", undefined, NotImplementedException, class_type("System.Exception"));
+}
+export function NotImplementedException_$ctor_Z721C83C5(message) {
+    return new NotImplementedException(message);
+}
+export function NotImplementedException_$ctor() {
+    return NotImplementedException_$ctor_Z721C83C5(SR_Arg_NotImplementedException);
+}
+export class NotSupportedException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function NotSupportedException_$reflection() {
+    return class_type("System.NotSupportedException", undefined, NotSupportedException, class_type("System.Exception"));
+}
+export function NotSupportedException_$ctor_Z721C83C5(message) {
+    return new NotSupportedException(message);
+}
+export function NotSupportedException_$ctor() {
+    return NotSupportedException_$ctor_Z721C83C5(SR_Arg_NotSupportedException);
+}
+export class NullReferenceException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function NullReferenceException_$reflection() {
+    return class_type("System.NullReferenceException", undefined, NullReferenceException, class_type("System.Exception"));
+}
+export function NullReferenceException_$ctor_Z721C83C5(message) {
+    return new NullReferenceException(message);
+}
+export function NullReferenceException_$ctor() {
+    return NullReferenceException_$ctor_Z721C83C5(SR_Arg_NullReferenceException);
+}
+export class OutOfMemoryException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function OutOfMemoryException_$reflection() {
+    return class_type("System.OutOfMemoryException", undefined, OutOfMemoryException, class_type("System.Exception"));
+}
+export function OutOfMemoryException_$ctor_Z721C83C5(message) {
+    return new OutOfMemoryException(message);
+}
+export function OutOfMemoryException_$ctor() {
+    return OutOfMemoryException_$ctor_Z721C83C5(SR_Arg_OutOfMemoryException);
+}
+export class OverflowException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function OverflowException_$reflection() {
+    return class_type("System.OverflowException", undefined, OverflowException, class_type("System.Exception"));
+}
+export function OverflowException_$ctor_Z721C83C5(message) {
+    return new OverflowException(message);
+}
+export function OverflowException_$ctor() {
+    return OverflowException_$ctor_Z721C83C5(SR_Arg_OverflowException);
+}
+export class RankException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function RankException_$reflection() {
+    return class_type("System.RankException", undefined, RankException, class_type("System.Exception"));
+}
+export function RankException_$ctor_Z721C83C5(message) {
+    return new RankException(message);
+}
+export function RankException_$ctor() {
+    return RankException_$ctor_Z721C83C5(SR_Arg_RankException);
+}
+export class StackOverflowException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function StackOverflowException_$reflection() {
+    return class_type("System.StackOverflowException", undefined, StackOverflowException, class_type("System.Exception"));
+}
+export function StackOverflowException_$ctor_Z721C83C5(message) {
+    return new StackOverflowException(message);
+}
+export function StackOverflowException_$ctor() {
+    return StackOverflowException_$ctor_Z721C83C5(SR_Arg_StackOverflowException);
+}
+export class TimeoutException extends Exception {
+    constructor(message) {
+        super(message);
+    }
+}
+export function TimeoutException_$reflection() {
+    return class_type("System.TimeoutException", undefined, TimeoutException, class_type("System.Exception"));
+}
+export function TimeoutException_$ctor_Z721C83C5(message) {
+    return new TimeoutException(message);
+}
+export function TimeoutException_$ctor() {
+    return TimeoutException_$ctor_Z721C83C5(SR_Arg_TimeoutException);
+}
+export class ArgumentException extends Exception {
+    constructor(message, paramName) {
+        super(isNullOrEmpty(paramName) ? message : (((message + SR_Arg_ParamName_Name) + paramName) + "\')"));
+        this.paramName = paramName;
+    }
+}
+export function ArgumentException_$reflection() {
+    return class_type("System.ArgumentException", undefined, ArgumentException, class_type("System.Exception"));
+}
+export function ArgumentException_$ctor_Z384F8060(message, paramName) {
+    return new ArgumentException(message, paramName);
+}
+export function ArgumentException_$ctor() {
+    return ArgumentException_$ctor_Z384F8060(SR_Arg_ArgumentException, "");
+}
+export function ArgumentException_$ctor_Z721C83C5(message) {
+    return ArgumentException_$ctor_Z384F8060(message, "");
+}
+export function ArgumentException__get_ParamName(_) {
+    return _.paramName;
+}
+export class ArgumentNullException extends ArgumentException {
+    constructor(paramName, message) {
+        super(message, paramName);
+    }
+}
+export function ArgumentNullException_$reflection() {
+    return class_type("System.ArgumentNullException", undefined, ArgumentNullException, ArgumentException_$reflection());
+}
+export function ArgumentNullException_$ctor_Z384F8060(paramName, message) {
+    return new ArgumentNullException(paramName, message);
+}
+export function ArgumentNullException_$ctor_Z721C83C5(paramName) {
+    return ArgumentNullException_$ctor_Z384F8060(paramName, SR_ArgumentNull_Generic);
+}
+export function ArgumentNullException_$ctor() {
+    return ArgumentNullException_$ctor_Z721C83C5("");
+}
+export class ArgumentOutOfRangeException extends ArgumentException {
+    constructor(paramName, message) {
+        super(message, paramName);
+    }
+}
+export function ArgumentOutOfRangeException_$reflection() {
+    return class_type("System.ArgumentOutOfRangeException", undefined, ArgumentOutOfRangeException, ArgumentException_$reflection());
+}
+export function ArgumentOutOfRangeException_$ctor_Z384F8060(paramName, message) {
+    return new ArgumentOutOfRangeException(paramName, message);
+}
+export function ArgumentOutOfRangeException_$ctor_Z721C83C5(paramName) {
+    return ArgumentOutOfRangeException_$ctor_Z384F8060(paramName, SR_Arg_ArgumentOutOfRangeException);
+}
+export function ArgumentOutOfRangeException_$ctor() {
+    return ArgumentOutOfRangeException_$ctor_Z721C83C5("");
+}

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

@@ -0,0 +1,122 @@
+import { hours, minutes, seconds, milliseconds } from "./TimeSpan.js";
+import { Exception, DateTimeKind, padWithZeros } from "./Util.js";
+const millisecondsPerDay = 86400000;
+export function create(h = 0, m = 0, s = 0, ms = 0) {
+    if (h < 0 || m < 0 || s < 0 || ms < 0)
+        throw new Exception("The parameters describe an unrepresentable TimeOnly.");
+    return h * 3600000 + m * 60000 + s * 1000 + ms;
+}
+export function fromTicks(ticks) {
+    return Number(BigInt(ticks) / 10000n);
+}
+export function fromTimeSpan(timeSpan) {
+    if (timeSpan < 0 || timeSpan >= millisecondsPerDay)
+        throw new Exception("The TimeSpan describes an unrepresentable TimeOnly.");
+    return timeSpan;
+}
+export function fromDateTime(d) {
+    return d.kind === DateTimeKind.Utc
+        ? create(d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds())
+        : create(d.getHours(), d.getMinutes(), d.getSeconds(), d.getMilliseconds());
+}
+export function maxValue() {
+    // This is "23:59:59.999"
+    return millisecondsPerDay - 1;
+}
+export function add(t, ts, wrappedDays) {
+    if (wrappedDays === undefined) {
+        const t2 = (t + ts) % millisecondsPerDay;
+        return t2 < 0 ? millisecondsPerDay + t2 : t2;
+    }
+    wrappedDays.contents = ts / millisecondsPerDay;
+    let newMs = t + ts % millisecondsPerDay;
+    if (newMs < 0) {
+        wrappedDays.contents--;
+        newMs += millisecondsPerDay;
+    }
+    else {
+        if (newMs >= millisecondsPerDay) {
+            wrappedDays.contents++;
+            newMs -= millisecondsPerDay;
+        }
+    }
+    return newMs;
+}
+export function addHours(t, h) {
+    return add(t, h * 3600000);
+}
+export function addMinutes(t, m) {
+    return add(t, m * 60000);
+}
+export function isBetween(t, start, end) {
+    return start <= end
+        ? (start <= t && end > t)
+        : (start <= t || end > t);
+}
+export function toString(t, format = "t", _provider) {
+    if (["r", "R", "o", "O", "t", "T"].indexOf(format) === -1) {
+        throw new Exception("Custom formats are not supported");
+    }
+    const base = `${padWithZeros(hours(t), 2)}:${padWithZeros(minutes(t), 2)}`;
+    if (format === "t")
+        return base;
+    const s = padWithZeros(seconds(t), 2);
+    // We're limited to millisecond precision, so the last 4 digits will always be 0
+    return `${base}${format === "o" || format === "O" ? `:${s}.${padWithZeros(milliseconds(t), 3)}0000` : `:${s}`}`;
+}
+export function parse(str) {
+    // Allowed format types:
+    // hh:mm
+    // hh:mm:ss
+    // hh:mm:ss.fffffff
+    const r = /^\s*([0-1]?\d|2[0-3])\s*:\s*([0-5]?\d)(\s*:\s*([0-5]?\d)(\.(\d+))?)?\s*$/.exec(str);
+    if (r != null && r[1] != null && r[2] != null) {
+        let ms = 0;
+        let s = 0;
+        const h = +r[1];
+        const m = +r[2];
+        if (r[4] != null) {
+            s = +r[4];
+        }
+        if (r[6] != null) {
+            // Depending on the number of decimals passed, we need to adapt the numbers
+            switch (r[6].length) {
+                case 1:
+                    ms = +r[6] * 100;
+                    break;
+                case 2:
+                    ms = +r[6] * 10;
+                    break;
+                case 3:
+                    ms = +r[6];
+                    break;
+                case 4:
+                    ms = +r[6] / 10;
+                    break;
+                case 5:
+                    ms = +r[6] / 100;
+                    break;
+                case 6:
+                    ms = +r[6] / 1000;
+                    break;
+                default:
+                    ms = +r[6].substring(0, 7) / 10000;
+                    break;
+            }
+        }
+        return create(h, m, s, Math.trunc(ms));
+    }
+    throw new Exception(`String '${str}' was not recognized as a valid TimeOnly.`);
+}
+export function tryParse(v, defValue) {
+    try {
+        defValue.contents = parse(v);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function op_Subtraction(left, right) {
+    return add(left, -right);
+}

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

@@ -0,0 +1,180 @@
+import { Exception, comparePrimitives, padLeftAndRightWithZeros, padWithZeros } from "./Util.js";
+import { toInt64, fromFloat64 } from "./BigInt.js";
+/**
+ * Calls:
+ * - `Math.ceil` if the `value` is **negative**
+ * - `Math.floor` if the `value` is **positive**
+ * @param value Value to round
+ */
+function signedRound(value) {
+    return value < 0 ? Math.ceil(value) : Math.floor(value);
+}
+export function create(d = 0, h = 0, m = 0, s = 0, ms = 0) {
+    switch (arguments.length) {
+        case 1:
+            // ticks
+            return fromTicks(arguments[0]);
+        case 3:
+            // h,m,s
+            d = 0, h = arguments[0], m = arguments[1], s = arguments[2], ms = 0;
+            break;
+        default:
+            // d,h,m,s,ms
+            break;
+    }
+    return d * 86400000 + h * 3600000 + m * 60000 + s * 1000 + ms;
+}
+export function fromTicks(ticks) {
+    return Number(BigInt(ticks) / 10000n);
+}
+export function fromDays(d, h = 0, m = 0n, s = 0n, ms = 0n) {
+    return create(d, h, Number(m), Number(s), Number(ms));
+}
+export function fromHours(h, m = 0n, s = 0n, ms = 0n) {
+    return create(0, h, Number(m), Number(s), Number(ms));
+}
+export function fromMinutes(m, s = 0n, ms = 0n) {
+    return create(0, 0, Number(m), Number(s), Number(ms));
+}
+export function fromSeconds(s, ms = 0n) {
+    return create(0, 0, 0, Number(s), Number(ms));
+}
+export function fromMilliseconds(ms) {
+    return Number(ms);
+}
+export function days(ts) {
+    return signedRound(ts / 86400000);
+}
+export function hours(ts) {
+    return signedRound(ts % 86400000 / 3600000);
+}
+export function minutes(ts) {
+    return signedRound(ts % 3600000 / 60000);
+}
+export function seconds(ts) {
+    return signedRound(ts % 60000 / 1000);
+}
+export function milliseconds(ts) {
+    return signedRound(ts % 1000);
+}
+export function ticks(ts) {
+    return toInt64(fromFloat64(ts * 10000));
+}
+export function totalDays(ts) {
+    return ts / 86400000;
+}
+export function totalHours(ts) {
+    return ts / 3600000;
+}
+export function totalMinutes(ts) {
+    return ts / 60000;
+}
+export function totalSeconds(ts) {
+    return ts / 1000;
+}
+export function negate(ts) {
+    return ts * -1;
+}
+export function add(ts1, ts2) {
+    return ts1 + ts2;
+}
+export function subtract(ts1, ts2) {
+    return ts1 - ts2;
+}
+export function multiply(ts, factor) {
+    return ts * factor;
+}
+export function divide(ts, b) {
+    return ts / b;
+}
+export const op_Addition = add;
+export const op_Subtraction = subtract;
+export const op_Multiply = multiply;
+export const op_Division = divide;
+export const compare = comparePrimitives;
+export const compareTo = comparePrimitives;
+export function duration(x) {
+    return Math.abs(x);
+}
+export function toString(ts, format = "c", _provider) {
+    if (["c", "g", "G"].indexOf(format) === -1) {
+        throw new Exception("Custom formats are not supported");
+    }
+    const d = Math.abs(days(ts));
+    const h = Math.abs(hours(ts));
+    const m = Math.abs(minutes(ts));
+    const s = Math.abs(seconds(ts));
+    const ms = Math.abs(milliseconds(ts));
+    const sign = ts < 0 ? "-" : "";
+    return `${sign}${d === 0 && (format === "c" || format === "g") ? "" : format === "c" ? d + "." : d + ":"}${format === "g" ? h : padWithZeros(h, 2)}:${padWithZeros(m, 2)}:${padWithZeros(s, 2)}${ms === 0 && (format === "c" || format === "g") ? "" : format === "g" ? "." + padWithZeros(ms, 3) : "." + padLeftAndRightWithZeros(ms, 3, 7)}`;
+}
+export function parse(str) {
+    const firstDot = str.search("\\.");
+    const firstColon = str.search("\\:");
+    if (firstDot === -1 && firstColon === -1) { // There is only a day ex: 4
+        const d = parseInt(str, 0);
+        if (isNaN(d)) {
+            throw new Exception(`String '${str}' was not recognized as a valid TimeSpan.`);
+        }
+        else {
+            return create(d, 0, 0, 0, 0);
+        }
+    }
+    if (firstColon > 0) { // process time part
+        // WIP: (-?)(((\d+)\.)?([0-9]|0[0-9]|1[0-9]|2[0-3]):(\d+)(:\d+(\.\d{1,7})?)?|\d+(?:(?!\.)))
+        const r = /^(-?)((\d+)\.)?(?:0*)([0-9]|0[0-9]|1[0-9]|2[0-3]):(?:0*)([0-5][0-9]|[0-9])(:(?:0*)([0-5][0-9]|[0-9]))?\.?(\d+)?$/.exec(str);
+        if (r != null && r[4] != null && r[5] != null) {
+            let d = 0;
+            let ms = 0;
+            let s = 0;
+            const sign = r[1] != null && r[1] === "-" ? -1 : 1;
+            const h = +r[4];
+            const m = +r[5];
+            if (r[3] != null) {
+                d = +r[3];
+            }
+            if (r[7] != null) {
+                s = +r[7];
+            }
+            if (r[8] != null) {
+                // Depending on the number of decimals passed, we need to adapt the numbers
+                switch (r[8].length) {
+                    case 1:
+                        ms = +r[8] * 100;
+                        break;
+                    case 2:
+                        ms = +r[8] * 10;
+                        break;
+                    case 3:
+                        ms = +r[8];
+                        break;
+                    case 4:
+                        ms = +r[8] / 10;
+                        break;
+                    case 5:
+                        ms = +r[8] / 100;
+                        break;
+                    case 6:
+                        ms = +r[8] / 1000;
+                        break;
+                    case 7:
+                        ms = +r[8] / 10000;
+                        break;
+                    default:
+                        throw new Exception(`String '${str}' was not recognized as a valid TimeSpan.`);
+                }
+            }
+            return sign * create(d, h, m, s, ms);
+        }
+    }
+    throw new Exception(`String '${str}' was not recognized as a valid TimeSpan.`);
+}
+export function tryParse(v, defValue) {
+    try {
+        defValue.contents = parse(v);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,67 @@
+import { Event } from "./Event.js";
+export class Timer {
+    constructor(interval) {
+        this._enabled = false;
+        this._isDisposed = false;
+        this._intervalId = 0;
+        this._timeoutId = 0;
+        this.Interval = interval && interval > 0 ? interval : 100;
+        this.AutoReset = true;
+        this._elapsed = new Event();
+    }
+    Elapsed() {
+        return this._elapsed.Publish;
+    }
+    get Enabled() {
+        return this._enabled;
+    }
+    set Enabled(x) {
+        if (!this._isDisposed && this._enabled !== x) {
+            this._enabled = x;
+            if (this._enabled) {
+                if (this.AutoReset) {
+                    this._intervalId = setInterval(() => {
+                        if (!this.AutoReset) {
+                            this.Enabled = false;
+                        }
+                        this._elapsed.Trigger(new Date());
+                    }, this.Interval);
+                }
+                else {
+                    this._timeoutId = setTimeout(() => {
+                        this.Enabled = false;
+                        this._timeoutId = 0;
+                        if (this.AutoReset) {
+                            this.Enabled = true;
+                        }
+                        this._elapsed.Trigger(new Date());
+                    }, this.Interval);
+                }
+            }
+            else {
+                if (this._timeoutId) {
+                    clearTimeout(this._timeoutId);
+                    this._timeoutId = 0;
+                }
+                if (this._intervalId) {
+                    clearInterval(this._intervalId);
+                    this._intervalId = 0;
+                }
+            }
+        }
+    }
+    Dispose() {
+        this.Enabled = false;
+        this._isDisposed = true;
+    }
+    Close() {
+        this.Dispose();
+    }
+    Start() {
+        this.Enabled = true;
+    }
+    Stop() {
+        this.Enabled = false;
+    }
+}
+export default Timer;