@harmoniclabs/pebble 0.1.0-dev0

package/dist/utils/getCallStackAt/index.js

@@ -0,0 +1,295 @@
+/**
+ * `Error#captureStackTrace` is not standard;
+ *
+ * `Error#captureStackTrace` is only available in V8-based JavaScript environments like Node.js and Chrome.
+ * https://nodejs.org/api/errors.html#errorcapturestacktracetargetobject-constructoropt
+ *
+ * in theory more efficient than creating a whole `new Error()` and then getting the 'stack` property.
+**/
+const hasV8Suff = typeof Error.captureStackTrace === "function" && typeof Error.prepareStackTrace === "function";
+export const defaultGetCallStackAtOptions = Object.freeze({
+    tryGetNameAsync: false
+});
+/**
+ *
+ * @param n index of an array tha looks like this
+ * ```ts
+ *          [
+ *              "Error: ",
+ *              "    at getCallStackAt path/to/this/file.ts 10:17",
+ *              "    at someCallerFunction path/to/caller/file.ts line:column",
+ *              "    at callerCallerFunction path/to/callerCaller/file.ts line:column",
+ *              "    at just/some/path/to/some/caller.ts line:column",
+ *              "    at someOtherFunction path/to/something.ts line:column",
+ *              ...rest_of_call_stack
+ *          ]
+ * ```
+ * @returns
+ */
+export function getCallStackAt(n = 3, opts = defaultGetCallStackAtOptions) {
+    const originalStackTraceLimit = Error.stackTraceLimit;
+    Error.stackTraceLimit = n;
+    let stackTrace = undefined;
+    // `new Error().stack` still not standard in theory but widely supported
+    // (97% of browsers at time of writing)
+    // https://caniuse.com/?search=Error%3A%20stack
+    stackTrace = new Error().stack;
+    stackTrace = stackTrace?.split(/\r?\n/)[n];
+    Error.stackTraceLimit = originalStackTraceLimit;
+    if (typeof stackTrace !== "string") {
+        return undefined;
+    }
+    const [_at, name_or_path, maybe_path] = stackTrace.split(" ").filter(str => str !== "");
+    const isPathThird = canBeStackTracePath(maybe_path);
+    let inferredName = undefined;
+    let rawPath = (isPathThird ? maybe_path : name_or_path).trim();
+    if (rawPath.startsWith("("))
+        rawPath = rawPath.slice(1).trimStart();
+    if (rawPath.endsWith(")"))
+        rawPath = rawPath.slice(0, rawPath.length - 1).trimEnd();
+    const chunks = rawPath.split(":");
+    const column = tryGetSafeInt(chunks[chunks.length - 1]);
+    const line = tryGetSafeInt(chunks[chunks.length - 2]);
+    // if, for any reason, the path includes ":"
+    const path = chunks.length === 3 ? chunks[0] : chunks.slice(0, chunks.length - 2).join(":");
+    const inferredCallbacks = [];
+    if (typeof opts.onNameInferred === "function") {
+        inferredCallbacks.push(opts.onNameInferred);
+    }
+    const result = {
+        __line__: stackTrace,
+        inferredName,
+        path,
+        column,
+        line,
+        once(evt, listener) {
+            if (evt === "inferredName" && typeof listener === "function") {
+                if (typeof result.inferredName === "string")
+                    listener(result.inferredName);
+                else
+                    inferredCallbacks.push(listener);
+            }
+        },
+        dispatchEvent(evt, inferredName) {
+            if (evt === "inferredName" && typeof inferredName === "string") {
+                let cb;
+                while (cb = inferredCallbacks.shift()) {
+                    cb(inferredName);
+                }
+            }
+        }
+    };
+    // if( isPathThird && !name_or_path.includes("anonymous") ) inferredName = name_or_path
+    if (opts.tryGetNameAsync === true) {
+        // tries synchronously, fallbacks to async
+        tryGetName(result);
+    }
+    return result;
+}
+function canBeStackTracePath(thing) {
+    if (typeof thing !== "string")
+        return false;
+    return thing.split(":").length === 3;
+}
+function tryGetSafeInt(stuff) {
+    try {
+        const n = parseInt(stuff);
+        if (Number.isSafeInteger(n))
+            return n;
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+const _MAX_CACHE_SIZE = 10;
+const _cachedFiles = [];
+function swapWithPrecedent(path) {
+    const idx = _cachedFiles.indexOf(path);
+    // already first or not present
+    if (idx <= 0)
+        return;
+    const tmp = _cachedFiles[idx];
+    _cachedFiles[idx] = _cachedFiles[idx - 1];
+    _cachedFiles[idx - 1] = tmp;
+}
+const _files = {};
+const cache = {
+    has(path) {
+        return _cachedFiles.includes(path);
+    },
+    get(path) {
+        // keep the most recently used on top
+        swapWithPrecedent(path);
+        return _files[path];
+    },
+    add(path, text) {
+        if (cache.has(path))
+            return;
+        let leastUsedPath;
+        while (_cachedFiles.length >= _MAX_CACHE_SIZE) {
+            leastUsedPath = _cachedFiles.pop();
+            delete _files[leastUsedPath];
+        }
+        _cachedFiles.unshift(path);
+        _files[path] = text;
+    }
+};
+const hasGlobalWindow = (function () {
+    try {
+        const notUndef = typeof window !== "undefined";
+        return notUndef;
+    }
+    catch {
+        return false;
+    }
+})();
+/**
+ * tries to get synchronously as far as possible
+ */
+function tryGetName(result) {
+    // if we don't have a position it makes no sense to get the file
+    const { column, line } = result;
+    if (typeof column !== "number" || typeof line !== "number")
+        return;
+    const base = hasGlobalWindow && typeof window?.location?.href === "string" ? window.location.href : "";
+    const path = base + result.path;
+    const file = cache.has(path) ? cache.get(path) : tryGetFileSync(path);
+    if (!Array.isArray(file)) {
+        // necessarily async
+        tryGetNameAsync(result);
+        // we did all we could; go back;
+        // eventually result will be modified asynchronously
+        return;
+    }
+    cache.add(path, file);
+    inferNameWithFile(result, file);
+}
+const isBrowser = (function () {
+    try {
+        return globalThis === window && !globalThis.process;
+    }
+    catch {
+        return false;
+    }
+})();
+// let nodeFs: typeof import("fs") | undefined = undefined;
+function hasNodeFs() {
+    return false;
+    // return typeof nodeFs === "object" && Object.keys( nodeFs ).length > 0;
+}
+function tryGetFileSync(path) {
+    return undefined;
+    /*
+    if( isBrowser ) return undefined;
+    if( !hasNodeFs() ) return undefined;
+
+    if( !nodeFs?.existsSync( path ) ) return undefined;
+    const text = nodeFs.readFileSync( path, { encoding: "utf8" });
+
+    return text.split(/\r?\n/);
+    //*/
+}
+/**
+ * modifies asynchronously `result.inferredName` if found
+ */
+function tryGetNameAsync(result) {
+    let fileText = "";
+    let path = result.path;
+    if (isBrowser) {
+        // TODO: use fetch
+        return undefined;
+    }
+    else {
+        /*
+        if( typeof nodeFs !== "object" )
+        {
+            try {
+                import("fs").then( mod => {
+                    nodeFs = mod;
+                    
+                    if( !nodeFs?.existsSync( path ) ) return undefined;
+                    fileText = nodeFs.readFileSync( path, { encoding: "utf8" });
+
+                    if( fileText === "" ) return;
+                    const file = fileText.split(/\r?\n/);
+
+                    cache.add( path, file );
+                    inferNameWithFile( result, file );
+                });
+                return;
+            } catch {
+                return;
+            }
+        }
+        
+        if( !nodeFs?.existsSync( path ) ) return undefined;
+        fileText = nodeFs.readFileSync( path, { encoding: "utf8" });
+        //*/
+        return undefined;
+    }
+    if (fileText === "")
+        return;
+    const file = fileText.split(/\r?\n/);
+    cache.add(path, file);
+    inferNameWithFile(result, file);
+}
+const singleEqSign = /(?<!=)=(?!>)(?!=)/;
+const jsVarNameIsh_g = /\b[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*\b/g;
+function inferNameWithFile(result, file) {
+    const line = result.line;
+    if (typeof line !== "number")
+        return;
+    let l = line;
+    let eq_idx = -1;
+    for (; l >= 0; l--) {
+        eq_idx = file[l].search(singleEqSign);
+        if (eq_idx >= 0)
+            break;
+    }
+    // if no equal found just exit
+    // (this is the case if we reach the top of the file)
+    if (eq_idx < 0)
+        return;
+    const eq_line_idx = l;
+    let var_line;
+    let decl_idx = -1;
+    let mathces = null;
+    do {
+        var_line = file[l--];
+        decl_idx = Math.max(var_line.indexOf("const"), var_line.indexOf("let"), var_line.indexOf("var"));
+        if (decl_idx < 0) {
+            if (l < 0)
+                break;
+            else
+                continue;
+        }
+        mathces = var_line.match(jsVarNameIsh_g);
+        if (!mathces)
+            break;
+        decl_idx = Math.max(mathces.lastIndexOf("const"), mathces.lastIndexOf("let"), mathces.lastIndexOf("var"));
+        if (decl_idx >= mathces.length - 1) // last thing matched
+         {
+            // search in lines below
+            l++; // back to this line index (was decremented before)
+            let var_idx = -1;
+            while (l < eq_line_idx) {
+                var_line = file[l++];
+                mathces = var_line.match(jsVarNameIsh_g);
+                if (!mathces)
+                    continue;
+                result.inferredName = mathces[0];
+                result.dispatchEvent("inferredName", result.inferredName);
+                break;
+            }
+            break;
+        }
+        else {
+            result.inferredName = mathces[decl_idx + 1];
+            result.dispatchEvent("inferredName", result.inferredName);
+            break;
+        }
+    } while (!mathces && l >= 0);
+    if (!mathces)
+        return;
+}

package/dist/utils/hex.d.ts

@@ -0,0 +1 @@
+export declare function isHex(str: string): boolean;

package/dist/utils/hex.js

@@ -0,0 +1,6 @@
+const hexChars = Object.freeze(Array.from("0123456789abcdef"));
+export function isHex(str) {
+    if (!(typeof str === "string"))
+        return false;
+    return Array.from(str).every(ch => hexChars.includes(ch));
+}

package/dist/utils/ints.d.ts

@@ -0,0 +1,4 @@
+export type CanBeUInteger = bigint | number;
+export declare function canBeUInteger(something: any): something is (number | bigint);
+export declare function forceBigUInt(toForce: CanBeUInteger): bigint;
+export declare function unsafeForceUInt(toForce: CanBeUInteger): number;

package/dist/utils/ints.js

@@ -0,0 +1,19 @@
+export function canBeUInteger(something) {
+    return ((typeof something === "bigint" && something >= BigInt(0)) ||
+        (typeof something === "number" && something === Math.round(Math.abs(something))));
+}
+export function forceBigUInt(toForce) {
+    if (!canBeUInteger(toForce)) {
+        // console.error( toForce );
+        throw new Error("trying to convert an integer to an unsigned Integer, the number was negative");
+    }
+    return BigInt(toForce);
+}
+;
+export function unsafeForceUInt(toForce) {
+    if (!canBeUInteger(toForce)) {
+        // console.error( toForce );
+        throw new Error("trying to convert an integer to an unsigned Integer, the number was negative");
+    }
+    return Number(toForce);
+}

package/dist/utils/isNonEmpty.d.ts

@@ -0,0 +1 @@
+export declare function isNonEmpty<T>(arr: T[]): arr is [T, ...T[]];

package/dist/utils/isNonEmpty.js

@@ -0,0 +1,3 @@
+export function isNonEmpty(arr) {
+    return arr.length >= 1;
+}

package/dist/utils/maybeData.d.ts

@@ -0,0 +1,4 @@
+import { DataConstr, Data } from "@harmoniclabs/plutus-data";
+export declare function nothingData(): DataConstr;
+export declare function justData(someData: Data): DataConstr;
+export declare function maybeData(optionalData: Data | undefined): DataConstr;

package/dist/utils/maybeData.js

@@ -0,0 +1,10 @@
+import { DataConstr } from "@harmoniclabs/plutus-data";
+export function nothingData() {
+    return new DataConstr(1, []);
+}
+export function justData(someData) {
+    return new DataConstr(0, [someData]);
+}
+export function maybeData(optionalData) {
+    return optionalData === undefined ? nothingData() : justData(optionalData);
+}

package/dist/utils/stringify.d.ts

@@ -0,0 +1,2 @@
+export declare function mkReplacer(replacer?: (key: string, value: any) => any | null, map?: WeakMap<any, string>): (key: string, value: any) => any;
+export declare function stringify(value: any, replacer?: (key: string, value: any) => any | null | (number | string)[], space?: string | number): string;

package/dist/utils/stringify.js

@@ -0,0 +1,31 @@
+import { isObject } from "@harmoniclabs/obj-utils";
+import { toHex } from "@harmoniclabs/uint8array-utils";
+export function mkReplacer(replacer, map = new WeakMap()) {
+    if (typeof replacer !== "function")
+        replacer = (k, v) => v;
+    return function (key, value) {
+        value = replacer(key, value);
+        if (isObject(value)) {
+            if (map.has(value)) {
+                return { _circular_ref_: map.get(value) };
+            }
+            map.set(value, key);
+            if (typeof value.buffer === "object" && value.buffer instanceof ArrayBuffer) {
+                value = new Uint8Array(value.buffer);
+            }
+            if (value instanceof Uint8Array) {
+                value = toHex(value);
+            }
+        }
+        if (typeof value === "bigint") {
+            value = value.toString();
+        }
+        return value;
+    };
+}
+export function stringify(value, replacer, space = 0) {
+    if (replacer) {
+        return JSON.stringify(value, replacer, space);
+    }
+    return JSON.stringify(value, mkReplacer(replacer, new WeakMap()), space);
+}

package/dist/utils/terminal.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @fileoverview Terminal utility.
+ * @license Apache-2.0
+ */
+/** Gray terminal color code. */
+export declare const COLOR_GRAY = "\u001B[90m";
+/** Red terminal color code. */
+export declare const COLOR_RED = "\u001B[91m";
+/** Green terminal color code. */
+export declare const COLOR_GREEN = "\u001B[92m";
+/** Yellow terminal color code. */
+export declare const COLOR_YELLOW = "\u001B[93m";
+/** Blue terminal color code. */
+export declare const COLOR_BLUE = "\u001B[94m";
+/** Magenta terminal color code. */
+export declare const COLOR_MAGENTA = "\u001B[95m";
+/** Cyan terminal color code. */
+export declare const COLOR_CYAN = "\u001B[96m";
+/** White terminal color code. */
+export declare const COLOR_WHITE = "\u001B[97m";
+/** Terminal color reset code. */
+export declare const COLOR_RESET = "\u001B[0m";
+/** Checks whether terminal colors are enabled or not. */
+export declare function isColorsEnabled(): boolean;
+/** Sets whether terminal colors are enabled or not. */
+export declare function setColorsEnabled(isEnabled: boolean): boolean;
+/** Wraps the specified text in the specified terminal color code. */
+export declare function colorize(text: string, color: string): string;

package/dist/utils/terminal.js

@@ -0,0 +1,38 @@
+/**
+ * @fileoverview Terminal utility.
+ * @license Apache-2.0
+ */
+/** Gray terminal color code. */
+export const COLOR_GRAY = "\u001b[90m";
+/** Red terminal color code. */
+export const COLOR_RED = "\u001b[91m";
+/** Green terminal color code. */
+export const COLOR_GREEN = "\u001b[92m";
+/** Yellow terminal color code. */
+export const COLOR_YELLOW = "\u001b[93m";
+/** Blue terminal color code. */
+export const COLOR_BLUE = "\u001b[94m";
+/** Magenta terminal color code. */
+export const COLOR_MAGENTA = "\u001b[95m";
+/** Cyan terminal color code. */
+export const COLOR_CYAN = "\u001b[96m";
+/** White terminal color code. */
+export const COLOR_WHITE = "\u001b[97m";
+/** Terminal color reset code. */
+export const COLOR_RESET = "\u001b[0m";
+/** Whether terminal colors are enabled or not. */
+let colorsEnabled = true;
+/** Checks whether terminal colors are enabled or not. */
+export function isColorsEnabled() {
+    return colorsEnabled;
+}
+/** Sets whether terminal colors are enabled or not. */
+export function setColorsEnabled(isEnabled) {
+    let wasEnabled = isEnabled;
+    colorsEnabled = isEnabled;
+    return wasEnabled;
+}
+/** Wraps the specified text in the specified terminal color code. */
+export function colorize(text, color) {
+    return colorsEnabled ? color + text + COLOR_RESET : text;
+}

package/dist/utils/text.d.ts

@@ -0,0 +1,172 @@
+/**
+ * @fileoverview Various character and text utility.
+ * @license Apache-2.0
+ */
+/** An enum of named character codes. */
+export declare const enum CharCode {
+    Null = 0,
+    LineFeed = 10,
+    CarriageReturn = 13,
+    LineSeparator = 8232,
+    ParagraphSeparator = 8233,
+    NextLine = 133,
+    Space = 32,
+    NonBreakingSpace = 160,
+    EnQuad = 8192,
+    EmQuad = 8193,
+    EnSpace = 8194,
+    EmSpace = 8195,
+    ThreePerEmSpace = 8196,
+    FourPerEmSpace = 8197,
+    SixPerEmSpace = 8198,
+    FigureSpace = 8199,
+    PunctuationSpace = 8200,
+    ThinSpace = 8201,
+    HairSpace = 8202,
+    ZeroWidthSpace = 8203,
+    NarrowNoBreakSpace = 8239,
+    IdeographicSpace = 12288,
+    MathematicalSpace = 8287,
+    Ogham = 5760,
+    _ = 95,
+    _0 = 48,
+    _1 = 49,
+    _2 = 50,
+    _3 = 51,
+    _4 = 52,
+    _5 = 53,
+    _6 = 54,
+    _7 = 55,
+    _8 = 56,
+    _9 = 57,
+    a = 97,
+    b = 98,
+    c = 99,
+    d = 100,
+    e = 101,
+    f = 102,
+    g = 103,
+    h = 104,
+    i = 105,
+    j = 106,
+    k = 107,
+    l = 108,
+    m = 109,
+    n = 110,
+    o = 111,
+    p = 112,
+    q = 113,
+    r = 114,
+    s = 115,
+    t = 116,
+    u = 117,
+    v = 118,
+    w = 119,
+    x = 120,
+    y = 121,
+    z = 122,
+    A = 65,
+    B = 66,
+    C = 67,
+    D = 68,
+    E = 69,
+    F = 70,
+    G = 71,
+    H = 72,
+    I = 73,
+    J = 74,
+    K = 75,
+    L = 76,
+    M = 77,
+    N = 78,
+    O = 79,
+    P = 80,
+    Q = 81,
+    R = 82,
+    S = 83,
+    T = 84,
+    U = 85,
+    V = 86,
+    W = 87,
+    X = 88,
+    Y = 89,
+    Z = 90,
+    Ampersand = 38,
+    Asterisk = 42,
+    At = 64,
+    Backslash = 92,
+    Backtick = 96,
+    Bar = 124,
+    Caret = 94,
+    CloseBrace = 125,
+    CloseBracket = 93,
+    CloseParen = 41,
+    Colon = 58,
+    Comma = 44,
+    Dollar = 36,
+    Dot = 46,
+    DoubleQuote = 34,
+    Equals = 61,
+    Exclamation = 33,
+    GreaterThan = 62,
+    Hash = 35,
+    LessThan = 60,
+    Minus = 45,
+    OpenBrace = 123,
+    OpenBracket = 91,
+    OpenParen = 40,
+    Percent = 37,
+    Plus = 43,
+    Question = 63,
+    Semicolon = 59,
+    SingleQuote = 39,
+    Slash = 47,
+    Tilde = 126,
+    Backspace = 8,
+    FormFeed = 12,
+    ByteOrderMark = 65279,
+    Tab = 9,
+    VerticalTab = 11
+}
+/** Tests if the specified character code is some sort of line break. */
+export declare function isLineBreak(c: number): boolean;
+/** Tests if the specified character code is some sort of white space. */
+export declare function isWhiteSpace(c: number): boolean;
+/** First high (lead) surrogate. */
+export declare const SURROGATE_HIGH = 55296;
+/** First low (trail) surrogate. */
+export declare const SURROGATE_LOW = 56320;
+/** Tests if a code unit or code point is a surrogate. */
+export declare function isSurrogate(c: number): boolean;
+/** Tests if a surrogate is a high (lead) surrogate. */
+export declare function isSurrogateHigh(c: number): boolean;
+/** Tests if a surrogate is a low (trail) surrogate. */
+export declare function isSurrogateLow(c: number): boolean;
+/** Tests if a code unit or code point is a high (lead) surrogate. */
+export declare function isHighSurrogate(c: number): boolean;
+/** Tests if a code unit or code point is a low (trail) surrogate. */
+export declare function isLowSurrogate(c: number): boolean;
+/** Converts a surrogate pair to its respective code point. */
+export declare function combineSurrogates(hi: number, lo: number): number;
+/** Gets the number of UTF-16 code units of the specified code point. */
+export declare function numCodeUnits(cp: number): number;
+export declare function isAlpha(c: number): boolean;
+/** Tests if the specified character code is a valid decimal digit. */
+export declare function isDecimal(c: number): boolean;
+/** Tests if the specified character code is a valid octal digit. */
+export declare function isOctal(c: number): boolean;
+/** Tests if the specified character code is a valid hexadecimal symbol [(a-f)|(A-F)]. */
+export declare function isHexBase(c: number): boolean;
+/** Tests if the specified character code is a valid hexadecimal digit. */
+export declare function isHexOrDecimal(c: number): boolean;
+/** Tests if the specified character code is trivially alphanumeric. */
+export declare function isAlphaOrDecimal(c: number): boolean;
+/** Tests if the specified code point is a valid start of an identifier. */
+export declare function isIdentifierStart(cp: number): boolean;
+/** Tests if the specified code point is a valid part of an identifier. */
+export declare function isIdentifierPart(cp: number): boolean;
+/** Tests if the specified string is a valid identifer. */
+export declare function isIdentifier(str: string): boolean;
+export declare function indent(sb: string[], level: number): void;
+/** Escapes a string using the specified kind of quote. */
+export declare function escapeString(str: string, quote: CharCode): string;