starlight-fsharp-oracle 0.1.0 → 0.1.2

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

@@ -0,0 +1,138 @@
+const littleEndian = true;
+export function isLittleEndian() {
+    return littleEndian;
+}
+export function getBytesBoolean(value) {
+    const bytes = new Uint8Array(1);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setUint8(0, value ? 1 : 0);
+    return bytes;
+}
+export function getBytesChar(value) {
+    const bytes = new Uint8Array(2);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setUint16(0, value.charCodeAt(0), littleEndian);
+    return bytes;
+}
+export function getBytesInt16(value) {
+    const bytes = new Uint8Array(2);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setInt16(0, value, littleEndian);
+    return bytes;
+}
+export function getBytesInt32(value) {
+    const bytes = new Uint8Array(4);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setInt32(0, value, littleEndian);
+    return bytes;
+}
+export function getBytesInt64(value) {
+    const bytes = new Uint8Array(8);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setBigInt64(0, value, littleEndian);
+    return bytes;
+}
+export function getBytesUInt16(value) {
+    const bytes = new Uint8Array(2);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setUint16(0, value, littleEndian);
+    return bytes;
+}
+export function getBytesUInt32(value) {
+    const bytes = new Uint8Array(4);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setUint32(0, value, littleEndian);
+    return bytes;
+}
+export function getBytesUInt64(value) {
+    const bytes = new Uint8Array(8);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setBigUint64(0, value, littleEndian);
+    return bytes;
+}
+export function getBytesSingle(value) {
+    const bytes = new Uint8Array(4);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setFloat32(0, value, littleEndian);
+    return bytes;
+}
+export function getBytesDouble(value) {
+    const bytes = new Uint8Array(8);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    view.setFloat64(0, value, littleEndian);
+    return bytes;
+}
+export function int64BitsToDouble(value) {
+    const buffer = new ArrayBuffer(8);
+    const view = new DataView(buffer);
+    view.setBigInt64(0, value, littleEndian);
+    return view.getFloat64(0, littleEndian);
+}
+export function doubleToInt64Bits(value) {
+    const buffer = new ArrayBuffer(8);
+    const view = new DataView(buffer);
+    view.setFloat64(0, value, littleEndian);
+    return view.getBigInt64(0, littleEndian);
+}
+export function toBoolean(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getUint8(offset) === 1 ? true : false;
+}
+export function toChar(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    const code = view.getUint16(offset, littleEndian);
+    return String.fromCharCode(code);
+}
+export function toInt16(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getInt16(offset, littleEndian);
+}
+export function toInt32(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getInt32(offset, littleEndian);
+}
+export function toInt64(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getBigInt64(offset, littleEndian);
+}
+export function toUInt16(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getUint16(offset, littleEndian);
+}
+export function toUInt32(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getUint32(offset, littleEndian);
+}
+export function toUInt64(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getBigUint64(offset, littleEndian);
+}
+export function toSingle(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getFloat32(offset, littleEndian);
+}
+export function toDouble(bytes, offset) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    const view = new DataView(array.buffer, array.byteOffset, array.byteLength);
+    return view.getFloat64(offset, littleEndian);
+}
+export function toString(bytes, offset, count) {
+    const array = ArrayBuffer.isView(bytes) ? bytes : Uint8Array.from(bytes);
+    let buffer = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
+    if (offset != null && count != null) {
+        buffer = buffer.subarray(offset, offset + count);
+    }
+    else if (offset != null) {
+        buffer = buffer.subarray(offset);
+    }
+    return Array.from(buffer).map((b) => ("0" + b.toString(16)).slice(-2)).join("-");
+}

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

@@ -0,0 +1,22 @@
+import { FSharpRef } from "./Types.js";
+import { Exception } from "./Util.js";
+export function tryParse(str, defValue) {
+    if (str != null && str.match(/^\s*true\s*$/i)) {
+        defValue.contents = true;
+        return true;
+    }
+    else if (str != null && str.match(/^\s*false\s*$/i)) {
+        defValue.contents = false;
+        return true;
+    }
+    return false;
+}
+export function parse(str) {
+    const defValue = new FSharpRef(false);
+    if (tryParse(str, defValue)) {
+        return defValue.contents;
+    }
+    else {
+        throw new Exception(`String '${str}' was not recognized as a valid Boolean.`);
+    }
+}

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

@@ -0,0 +1,191 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## Unreleased
+
+## 2.0.0-rc.6 - 2026-04-07
+
+### Fixed
+
+* [JS/TS] Fix `Async.StartChild` with timeout always timing out even when the computation finishes before the deadline (fixes #4481) (by @MangelMaxime)
+
+## 2.0.0-rc.5 - 2026-03-31
+
+### Fixed
+
+* [JS/TS] Improve `Regex.Escape` and `Regex.Unescape` handling (by @MangelMaxime)
+* [JS/TS] Fixed quotation for union string cases (by @MangelMaxime)
+
+## 2.0.0-rc.4 - 2026-03-19
+
+### Fixed
+
+* [JS/TS] Fix `Unchecked.defaultof<char>` being emitted as `null` instead of `'\0'` (by @MangelMaxime)
+
+## 2.0.0-rc.3 - 2026-03-10
+
+### Fixed
+
+* [TS] Expose optional `stack` property on `Exception` (by @MangelMaxime)
+
+## 2.0.0-rc.2 - 2026-03-03
+
+### Fixed
+
+* [JS/TS] Allows compiling `fable-library-ts` for Browser environment (by @goswinr)
+
+## 2.0.0-rc.1 - 2026-02-26
+
+## 2.0.0-beta.7 - 2026-02-03
+
+* [JS/TS] Fix `StringBuilder.Chars` getter and setter (by @MangelMaxime)
+
+## 2.0.0-beta.6 - 2025-12-26
+
+### Fixed
+
+* [JS/TS] Fix #4305 `DateTimeOffset.Now` returns wrong time (by @ncave)
+
+## 2.0.0-beta.5 - 2025-11-19
+
+### Changed
+
+* [JS/TS] Replace the deprecated `substr` method with `slice` (by @Thorium)
+
+## 2.0.0-beta.4 - 2025-07-25
+
+### Added
+
+* [JS/TS] Initial support for Nullable Reference Types (by @ncave)
+
+## 2.0.0-beta.3 - 2025-03-14
+
+### Fixed
+
+* [JS/TS] Make `nullArgCheck` report the same error message as on .NET (by @MangelMaxime)
+
+## 2.0.0-beta.2 - 2025-03-03
+
+* [JS/TS] Fix #4049: decimal/bigint to integer conversion checks (by @ncave)
+* [JS/TS] Fix `decimal` to `char` conversion checks (by @ManngelMaxime)
+* [JS/TS] Propagate non-captured exception when running `Async.Start` or `Async.StartImmediate` (by @MangelMaxime)
+* [JS/TS] Remove `Async.RunSynchronously` (by @MangelMaxime)
+* [JS/TS] Change signature of `startWithContinuations` to always require all its arguments (by @MangelMaxime)
+* [JS/TS] Fix short `DateTime` and `DateTimeOffset` short format strings (by @MangelMaxime)
+* [JS/TS] Add `C` and `c` format for numeric types (by @MangelMaxime)
+* [JS/TS] Add `B` and `b` format for numeric types (by @MangelMaxime)
+* [JS/TS] Add `n` format for numeric types (by @MangelMaxime)
+* [JS/TS] Fix numeric formats (by @MangelMaxime)
+
+## 2.0.0-beta.1 - 2025-02-16
+
+* Compiled with Fable 5.0.0-alpha.10
+
+## 1.10.0 - 2025-01-23
+
+### Added
+
+* [JS/TS] Add `StringBuiler.Append(c: char, repeatCount: int)` overload (by @roboz0r)
+
+## 1.9.0 - 2025-01-09
+
+### Added
+
+* [JS/TS] Add new `TimSpane` overload support coming from .NET 9 (by @MangelMaxime)
+
+### Fixed
+
+* [JS/TS] Fix `DateTimeOffset.ToLocalTime` (by @MangelMaxime)
+
+## 1.8.0 - 2024-11-19
+
+* [JS/TS] Fix `h` in `DateTime.ToString` (@MangelMaxime)
+* [JS/TS] Fix `hh` in `DateTime.ToString` (@MangelMaxime)
+
+## 1.7.0 - 2024-11-19
+
+### Fixed
+
+* [JS/TS] Added missing IReadOnlyCollection helpers (#3953)
+
+## 1.6.0 - 2024-10-02
+
+### Removed
+
+* Remove `Async` (from `Async.ts`) class (by @MangelMaxime)
+
+### Changed
+
+* Renamed `IAsync` to `Async` in `AsyncBuilder.ts` (#3906) (by @ncave)
+
+## 1.5.0 - 2024-09-19
+
+### Added
+
+* [JS/TS] Add support for `OrdinalIgnoreCase` overload for `String.EndsWith` (#3892) (by @goswinr)
+* [JS/TS] Add `uri.Port`, `uri.IsDefaultPort` (by @MangelMaxime)
+
+### Fixed
+
+* [JS/TS] Fix escaping of `{` and `}` in FormattableString (#3890) (by @roboz0r)
+* [JS/TS] Fix `uri.Host` to return the host name without the port (by @MangelMaxime)
+* [JS/TS] Fix TypeScript compilation by resolving type of `jsOptions` (#3894) (by @MangelMaxime)
+
+## 1.4.3 - 2024-09-04
+
+* [JS/TS] Fixed Decimal comparisons (#3884) (by @ncave)
+
+## 1.4.2 - 2024-06-13
+
+### Fixed
+
+* [JS/TS] Fixed BigInt.ToDecimal with negative values (#3500) (by @ncave)
+
+## 1.4.1 - 2024-06-13
+
+### Fixed
+
+* [JS/TS] Fixed DateTime.MinValue, DateTime.MaxValue (#3836) (by @ncave)
+
+## 1.4.0 - 2024-03-20
+
+### Added
+
+* [JS/TS] Add `ConditionalWeakTable` (by @chkn)
+
+## 1.3.0 - 2024-03-18
+
+* [JS/TS] `Boolean.tryParse` should not crash on `null` string (@goswinr)
+
+## 1.2.0 - 2024-03-01
+
+### Fixed
+
+* [GH-3772](https://github.com/fable-compiler/Fable/pull/3772) [JS/TS] Re-implement `DateTime.ToString` custom format handling (by @MangelMaxime)
+
+    It now supports all custom format specifiers, and behave as if `CultureInfo.InvariantCulture` was used (Fable does not support Globalization).
+
+## 1.1.0 - 2024-02-20
+
+### Added
+
+#### JavaScript
+
+* [GH-3759](https://github.com/fable-compiler/Fable/issues/3759) Add `StringBuilder.Chars` (by @MangelMaxime)
+* Add `StringBuilder.AppendFormat` (by @ncave)
+* [GH-3748](https://github.com/fable-compiler/Fable/pull/3748) Add `Array.getItem` and `Array.setItem` (by @MangelMaxime)
+
+## 1.0.0 - 2024-02-13
+
+* Release stable version
+
+## 1.0.0-beta-001 - 2024-02-12
+
+### Changed
+
+* Separate `Result` from `Choice`
+* Released as part of Fable 4.12.0

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

@@ -0,0 +1,202 @@
+import * as Unicode from "./Unicode.13.0.0.js";
+import { Exception } from "./Util.js";
+function getCategoryFunc() {
+    // unpack Unicode codepoint ranges (delta encoded) and general categories
+    const offset = 35; // offsets unprintable characters
+    const a1 = [...Unicode.rangeDeltas].map((ch) => (ch.codePointAt(0) ?? 0) - offset);
+    const a2 = [...Unicode.categories].map((ch) => (ch.codePointAt(0) ?? 0) - offset);
+    const codepoints = new Uint32Array(a1);
+    const categories = new Uint8Array(a2);
+    for (let i = 1; i < codepoints.length; ++i) {
+        codepoints[i] += codepoints[i - 1];
+    }
+    // binary search in unicode ranges
+    return (cp) => {
+        let hi = codepoints.length;
+        let lo = 0;
+        while (hi - lo > 1) {
+            const mid = Math.floor((hi + lo) / 2);
+            const test = codepoints[mid];
+            if (cp < test) {
+                hi = mid;
+            }
+            else if (cp === test) {
+                hi = lo = mid;
+                break;
+            }
+            else if (test < cp) {
+                lo = mid;
+            }
+        }
+        return categories[lo];
+    };
+}
+export const UnicodeCategory = {
+    UppercaseLetter: 0,
+    LowercaseLetter: 1,
+    TitlecaseLetter: 2,
+    ModifierLetter: 3,
+    OtherLetter: 4,
+    NonSpacingMark: 5,
+    SpacingCombiningMark: 6,
+    EnclosingMark: 7,
+    DecimalDigitNumber: 8,
+    LetterNumber: 9,
+    OtherNumber: 10,
+    SpaceSeparator: 11,
+    LineSeparator: 12,
+    ParagraphSeparator: 13,
+    Control: 14,
+    Format: 15,
+    Surrogate: 16,
+    PrivateUse: 17,
+    ConnectorPunctuation: 18,
+    DashPunctuation: 19,
+    OpenPunctuation: 20,
+    ClosePunctuation: 21,
+    InitialQuotePunctuation: 22,
+    FinalQuotePunctuation: 23,
+    OtherPunctuation: 24,
+    MathSymbol: 25,
+    CurrencySymbol: 26,
+    ModifierSymbol: 27,
+    OtherSymbol: 28,
+    OtherNotAssigned: 29,
+};
+const isControlMask = 1 << UnicodeCategory.Control;
+const isDigitMask = 1 << UnicodeCategory.DecimalDigitNumber;
+const isLetterMask = 0
+    | 1 << UnicodeCategory.UppercaseLetter
+    | 1 << UnicodeCategory.LowercaseLetter
+    | 1 << UnicodeCategory.TitlecaseLetter
+    | 1 << UnicodeCategory.ModifierLetter
+    | 1 << UnicodeCategory.OtherLetter;
+const isLetterOrDigitMask = isLetterMask | isDigitMask;
+const isUpperMask = 1 << UnicodeCategory.UppercaseLetter;
+const isLowerMask = 1 << UnicodeCategory.LowercaseLetter;
+const isNumberMask = 0
+    | 1 << UnicodeCategory.DecimalDigitNumber
+    | 1 << UnicodeCategory.LetterNumber
+    | 1 << UnicodeCategory.OtherNumber;
+const isPunctuationMask = 0
+    | 1 << UnicodeCategory.ConnectorPunctuation
+    | 1 << UnicodeCategory.DashPunctuation
+    | 1 << UnicodeCategory.OpenPunctuation
+    | 1 << UnicodeCategory.ClosePunctuation
+    | 1 << UnicodeCategory.InitialQuotePunctuation
+    | 1 << UnicodeCategory.FinalQuotePunctuation
+    | 1 << UnicodeCategory.OtherPunctuation;
+const isSeparatorMask = 0
+    | 1 << UnicodeCategory.SpaceSeparator
+    | 1 << UnicodeCategory.LineSeparator
+    | 1 << UnicodeCategory.ParagraphSeparator;
+const isSymbolMask = 0
+    | 1 << UnicodeCategory.MathSymbol
+    | 1 << UnicodeCategory.CurrencySymbol
+    | 1 << UnicodeCategory.ModifierSymbol
+    | 1 << UnicodeCategory.OtherSymbol;
+const isWhiteSpaceMask = 0
+    | 1 << UnicodeCategory.SpaceSeparator
+    | 1 << UnicodeCategory.LineSeparator
+    | 1 << UnicodeCategory.ParagraphSeparator;
+const unicodeCategoryFunc = getCategoryFunc();
+function charCodeAt(s, index) {
+    if (index >= 0 && index < s.length) {
+        return s.charCodeAt(index);
+    }
+    else {
+        throw new Exception("Index out of range.");
+    }
+}
+export const getUnicodeCategory = (s) => getUnicodeCategory2(s, 0);
+export const isControl = (s) => isControl2(s, 0);
+export const isDigit = (s) => isDigit2(s, 0);
+export const isLetter = (s) => isLetter2(s, 0);
+export const isLetterOrDigit = (s) => isLetterOrDigit2(s, 0);
+export const isUpper = (s) => isUpper2(s, 0);
+export const isLower = (s) => isLower2(s, 0);
+export const isNumber = (s) => isNumber2(s, 0);
+export const isPunctuation = (s) => isPunctuation2(s, 0);
+export const isSeparator = (s) => isSeparator2(s, 0);
+export const isSymbol = (s) => isSymbol2(s, 0);
+export const isWhiteSpace = (s) => isWhiteSpace2(s, 0);
+export const isHighSurrogate = (s) => isHighSurrogate2(s, 0);
+export const isLowSurrogate = (s) => isLowSurrogate2(s, 0);
+export const isSurrogate = (s) => isSurrogate2(s, 0);
+export function getUnicodeCategory2(s, index) {
+    const cp = charCodeAt(s, index);
+    return unicodeCategoryFunc(cp);
+}
+export function isControl2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isControlMask) !== 0;
+}
+export function isDigit2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isDigitMask) !== 0;
+}
+export function isLetter2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isLetterMask) !== 0;
+}
+export function isLetterOrDigit2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isLetterOrDigitMask) !== 0;
+}
+export function isUpper2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isUpperMask) !== 0;
+}
+export function isLower2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isLowerMask) !== 0;
+}
+export function isNumber2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isNumberMask) !== 0;
+}
+export function isPunctuation2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isPunctuationMask) !== 0;
+}
+export function isSeparator2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isSeparatorMask) !== 0;
+}
+export function isSymbol2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    return (test & isSymbolMask) !== 0;
+}
+export function isWhiteSpace2(s, index) {
+    const test = 1 << getUnicodeCategory2(s, index);
+    if ((test & isWhiteSpaceMask) !== 0) {
+        return true;
+    }
+    const cp = charCodeAt(s, index);
+    return (0x09 <= cp && cp <= 0x0D) || cp === 0x85 || cp === 0xA0;
+}
+export function isHighSurrogate2(s, index) {
+    const cp = charCodeAt(s, index);
+    return (0xD800 <= cp && cp <= 0xDBFF);
+}
+export function isLowSurrogate2(s, index) {
+    const cp = charCodeAt(s, index);
+    return (0xDC00 <= cp && cp <= 0xDFFF);
+}
+export function isSurrogate2(s, index) {
+    const cp = charCodeAt(s, index);
+    return (0xD800 <= cp && cp <= 0xDFFF);
+}
+export function isSurrogatePair(s, index) {
+    return typeof index === "number"
+        ? isHighSurrogate2(s, index) && isLowSurrogate2(s, index + 1)
+        : isHighSurrogate(s) && isLowSurrogate(index);
+}
+export function parse(input) {
+    if (input.length === 1) {
+        return input[0];
+    }
+    else {
+        throw new Exception("String must be exactly one character long.");
+    }
+}