@harmoniclabs/pebble 0.1.0-dev0

package/dist/tokenizer/TokenizerState.d.ts

@@ -0,0 +1,17 @@
+import { Token } from "./Token.js";
+/** Tokenizer state as returned by {@link Tokenizer#mark} and consumed by {@link Tokenizer#reset}. */
+export declare class TokenizerState {
+    /** Current position. */
+    pos: number;
+    /** Current token. */
+    token: Token;
+    /** Current token's position. */
+    tokenPos: number;
+    constructor(
+    /** Current position. */
+    pos: number, 
+    /** Current token. */
+    token: Token, 
+    /** Current token's position. */
+    tokenPos: number);
+}

package/dist/tokenizer/TokenizerState.js

@@ -0,0 +1,17 @@
+/** Tokenizer state as returned by {@link Tokenizer#mark} and consumed by {@link Tokenizer#reset}. */
+export class TokenizerState {
+    pos;
+    token;
+    tokenPos;
+    constructor(
+    /** Current position. */
+    pos, 
+    /** Current token. */
+    token, 
+    /** Current token's position. */
+    tokenPos) {
+        this.pos = pos;
+        this.token = token;
+        this.tokenPos = tokenPos;
+    }
+}

package/dist/tokenizer/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./Token.js";
+export * from "./Tokenizer.js";

package/dist/tokenizer/index.js

@@ -0,0 +1,2 @@
+export * from "./Token.js";
+export * from "./Tokenizer.js";

package/dist/tokenizer/utils/isIllegalVariableIdentifier.d.ts

@@ -0,0 +1 @@
+export declare function isIllegalVariableIdentifier(name: string): boolean;

package/dist/tokenizer/utils/isIllegalVariableIdentifier.js

@@ -0,0 +1,12 @@
+export function isIllegalVariableIdentifier(name) {
+    if (name.length === 0)
+        return true;
+    switch (name.charCodeAt(0)) {
+        case 100 /* CharCode.d */: return name === "delete";
+        case 102 /* CharCode.f */: return name === "for";
+        case 105 /* CharCode.i */: return name === "instanceof";
+        case 110 /* CharCode.n */: return name === "undefined";
+        case 118 /* CharCode.v */: return name === "void";
+    }
+    return false;
+}

package/dist/tokenizer/utils/operatorTokenToString.d.ts

@@ -0,0 +1,2 @@
+import { Token } from "../Token.js";
+export declare function operatorTokenToString(token: Token): string;

package/dist/tokenizer/utils/operatorTokenToString.js

@@ -0,0 +1,57 @@
+import { Token } from "../Token.js";
+export function operatorTokenToString(token) {
+    switch (token) {
+        // case Token.Delete: return "delete";
+        // case Token.In: return "in";
+        // case Token.InstanceOf: return "instanceof";
+        case Token.Is: return "is";
+        // case Token.New: return "new";
+        // case Token.TypeOf: return "typeof";
+        case Token.Void: return "void";
+        // case Token.Yield: return "yield";
+        case Token.Dot_Dot_Dot: return "...";
+        case Token.Comma: return ",";
+        case Token.LessThan: return "<";
+        case Token.GreaterThan: return ">";
+        case Token.LessThan_Equals: return "<=";
+        case Token.GreaterThan_Equals: return ">=";
+        case Token.Equals_Equals: return "==";
+        case Token.Exclamation_Equals: return "!=";
+        case Token.Equals_Equals_Equals: return "===";
+        case Token.Exclamation_Equals_Equals: return "!==";
+        case Token.Plus: return "+";
+        case Token.Minus: return "-";
+        case Token.Asterisk_Asterisk: return "**";
+        case Token.Asterisk: return "*";
+        case Token.Slash: return "/";
+        case Token.Percent: return "%";
+        case Token.Plus_Plus: return "++";
+        case Token.Minus_Minus: return "--";
+        case Token.LessThan_LessThan: return "<<";
+        case Token.GreaterThan_GreaterThan: return ">>";
+        case Token.GreaterThan_GreaterThan_GreaterThan: return ">>>";
+        case Token.Ampersand: return "&";
+        case Token.Bar: return "|";
+        case Token.Caret: return "^";
+        case Token.Exclamation: return "!";
+        case Token.Tilde: return "~";
+        case Token.Ampersand_Ampersand: return "&&";
+        case Token.Bar_Bar: return "||";
+        case Token.Equals: return "=";
+        case Token.Plus_Equals: return "+=";
+        case Token.Minus_Equals: return "-=";
+        case Token.Asterisk_Equals: return "*=";
+        case Token.Asterisk_Asterisk_Equals: return "**=";
+        case Token.Slash_Equals: return "/=";
+        case Token.Percent_Equals: return "%=";
+        case Token.LessThan_LessThan_Equals: return "<<=";
+        case Token.GreaterThan_GreaterThan_Equals: return ">>=";
+        case Token.GreaterThan_GreaterThan_GreaterThan_Equals: return ">>>=";
+        case Token.Ampersand_Equals: return "&=";
+        case Token.Bar_Equals: return "|=";
+        case Token.Caret_Equals: return "^=";
+        default: {
+            throw new Error(`Unexpected operator token: ${Token[token]}`);
+        }
+    }
+}

package/dist/tokenizer/utils/tokenFromKeyword.d.ts

@@ -0,0 +1,2 @@
+import { Token } from "../Token.js";
+export declare function tokenFromKeyword(text: string): Token;

package/dist/tokenizer/utils/tokenFromKeyword.js

@@ -0,0 +1,222 @@
+import { Token } from "../Token.js";
+export function tokenFromKeyword(text) {
+    const len = text.length;
+    if (len <= 0)
+        return Token.Invalid;
+    switch (text.charCodeAt(0)) {
+        case 97 /* CharCode.a */: {
+            // if (len === 5) {
+            //     if (text === "async") return Token.Async;
+            //     if (text === "await") return Token.Await;
+            //     break;
+            // }
+            if (text === "assert")
+                return Token.Assert;
+            if (text === "as")
+                return Token.As;
+            // if( text === "abstract" ) return Token.Abstract;
+            break;
+        }
+        case 98 /* CharCode.b */: {
+            if (text === "break")
+                return Token.Break;
+            break;
+        }
+        case 99 /* CharCode.c */: {
+            // if (text === "catch") return Token.Catch;
+            // if (text === "class") return Token.Class;
+            if (text === "case")
+                return Token.Case;
+            if (text === "const")
+                return Token.Const;
+            if (text === "continue")
+                return Token.Continue;
+            // if (text === "constructor") return Token.Constructor;
+            break;
+        }
+        case 100 /* CharCode.d */: {
+            // if (len === 7) {
+            //     if (text === "default") return Token.Default;
+            //     if (text === "declare") return Token.Declare;
+            //     break;
+            // }
+            // if (text === "do") return Token.Do;
+            // if (text === "delete") return Token.Delete;
+            if (text === "debugger")
+                return Token.Debugger;
+            break;
+        }
+        case 101 /* CharCode.e */: {
+            if (len === 4) {
+                if (text === "else")
+                    return Token.Else;
+                if (text === "enum")
+                    return Token.Enum;
+                break;
+            }
+            if (text === "export")
+                return Token.Export;
+            if (text === "extends")
+                return Token.Extends;
+            break;
+        }
+        case 102 /* CharCode.f */: {
+            if (len <= 5) {
+                if (text === "fail")
+                    return Token.Fail;
+                if (text === "false")
+                    return Token.False;
+                if (text === "for")
+                    return Token.For;
+                if (text === "from")
+                    return Token.From;
+                break;
+            }
+            if (text === "function")
+                return Token.Function;
+            if (text === "finally")
+                return Token.Finally;
+            break;
+        }
+        // case CharCode.g: {
+        //     if (text === "get") return Token.Get;
+        //     break;
+        // }
+        case 105 /* CharCode.i */: {
+            if (len === 2) {
+                if (text === "if")
+                    return Token.If;
+                // if (text === "in") return Token.In;
+                if (text === "is")
+                    return Token.Is;
+                break;
+            }
+            if (text === "int")
+                return Token.Int;
+            switch (text.charCodeAt(3)) {
+                case 108 /* CharCode.l */: {
+                    if (text === "implements")
+                        return Token.Implements;
+                    break;
+                }
+                case 111 /* CharCode.o */: {
+                    if (text === "import")
+                        return Token.Import;
+                    break;
+                }
+                // case CharCode.t: {
+                //     if (text === "instanceof") return Token.InstanceOf;
+                //     break;
+                // }
+                case 101 /* CharCode.e */: {
+                    if (text === "interface")
+                        return Token.Interface;
+                    break;
+                }
+            }
+            break;
+        }
+        // case CharCode.k: {
+        //     if (text === "keyof") return Token.KeyOf;
+        //     break;
+        // }
+        case 108 /* CharCode.l */: {
+            if (text === "let")
+                return Token.Let;
+            break;
+        }
+        case 109 /* CharCode.m */: {
+            // if (text === "module") return Token.Module;
+            if (text === "match")
+                return Token.Match;
+            break;
+        }
+        case 110 /* CharCode.n */: {
+            // if (text === "new") return Token.New;
+            // if (text === "undefined") return Token.Null;
+            // if (text === "namespace") return Token.Namespace;
+            // replaced by "int"
+            // if (text === "number") return Token.Number;
+            break;
+        }
+        case 111 /* CharCode.o */: {
+            if (text === "of")
+                return Token.Of;
+            // if (text === "override") return Token.Override;
+            break;
+        }
+        // case CharCode.p: {
+        //     if (len === 7) {
+        //         if (text === "private") return Token.Private;
+        //         if (text === "package") return Token.Package;
+        //         break;
+        //     }
+        //     if (text === "public") return Token.Public;
+        //     if (text === "protected") return Token.Protected;
+        //     break;
+        // }
+        case 114 /* CharCode.r */: {
+            if (text === "return")
+                return Token.Return;
+            if (text === "readonly")
+                return Token.Readonly;
+            break;
+        }
+        case 115 /* CharCode.s */: {
+            if (len === 6) {
+                // if (text === "switch") return Token.Switch;
+                if (text === "static")
+                    return Token.Static;
+                if (text === "struct")
+                    return Token.Struct;
+                break;
+            }
+            // if (text === "set") return Token.Set;
+            // if (text === "super") return Token.Super;
+            break;
+        }
+        case 116 /* CharCode.t */: {
+            if (len === 4) {
+                if (text === "true")
+                    return Token.True;
+                if (text === "this")
+                    return Token.This;
+                if (text === "type")
+                    return Token.Type;
+                break;
+            }
+            // if (text === "try") return Token.Try;
+            // if (text === "throw") return Token.Throw;
+            // if (text === "typeof") return Token.TypeOf;
+            break;
+        }
+        case 117 /* CharCode.u */: {
+            if (text === "undefined")
+                return Token.Undefined;
+            if (text === "using")
+                return Token.Using;
+            break;
+        }
+        case 118 /* CharCode.v */: {
+            if (text === "var")
+                return Token.Var;
+            if (text === "void")
+                return Token.Void;
+            break;
+        }
+        case 119 /* CharCode.w */: {
+            if (text === "while")
+                return Token.While;
+            if (text === "when")
+                return Token.When;
+            // if (text === "with") return Token.With;
+            break;
+        }
+        // case CharCode.y: {
+        //     if (text === "yield") return Token.Yield;
+        //     break;
+        // }
+        default: break;
+    }
+    return Token.Invalid;
+}

package/dist/tokenizer/utils/tokenIsAlsoIdentifier.d.ts

@@ -0,0 +1,2 @@
+import { Token } from "../Token.js";
+export declare function tokenIsAlsoIdentifier(token: Token): boolean;

package/dist/tokenizer/utils/tokenIsAlsoIdentifier.js

@@ -0,0 +1,24 @@
+import { Token } from "../Token.js";
+export function tokenIsAlsoIdentifier(token) {
+    switch (token) {
+        // case Token.Abstract:
+        case Token.As:
+        // case Token.Constructor:
+        // case Token.Declare:
+        // case Token.Delete:
+        case Token.From:
+        // case Token.For:  // not allowed
+        // case Token.Get:
+        // case Token.Set:
+        // case Token.InstanceOf:  // not allowed
+        case Token.Is:
+        // case Token.KeyOf:
+        // case Token.Module:
+        // case Token.Namespace:
+        // case Token.Null:
+        case Token.Readonly:
+        // case Token.Type: // we don't allow it in pebble
+        case Token.Void: return true;
+        default: return false;
+    }
+}

package/dist/utils/BasePlutsError.d.ts

@@ -0,0 +1,2 @@
+export declare class BasePlutsError extends Error {
+}

package/dist/utils/BasePlutsError.js

@@ -0,0 +1,2 @@
+export class BasePlutsError extends Error {
+}

package/dist/utils/BitUtils/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * @static
+ */
+export default class BitUtils {
+    private constructor();
+    /**
+     * @deprecated not sure it has ever made sense to have it
+     * @returns a number in range ```[ 0 , 255 ]``` ( ```[ 0b0000_0000, 0b1111_1111 ]``` ) based on the first byte
+     */
+    static getFirstByte(bits: bigint): number;
+    /**
+     * @deprecated use ```andMaskOfLength``` instead
+     */
+    static andMaskOfLengthInt(n: number): bigint;
+    /**
+     * returns a ```bigint``` of that as the last ```n``` bits setted to ones;
+     *
+     * example
+     * ```ts
+     * BitUtils.getMaskOfLength( 7 ) === Bigint( 0b0111_1111 ); // true
+     * ```
+     */
+    static andMaskOfLength(n: bigint): bigint;
+    static getNLastBits(fromNuber: bigint, nBits: bigint): bigint;
+    /**
+     * @returns the number of bits from the first setted to ```1``` on the left up until the end
+     */
+    static getNOfUsedBits(bits: bigint): number;
+    static minBytesRequired(bigint: bigint): number;
+}

package/dist/utils/BitUtils/index.js

@@ -0,0 +1,60 @@
+/**
+ * @static
+ */
+export default class BitUtils {
+    constructor() { }
+    /**
+     * @deprecated not sure it has ever made sense to have it
+     * @returns a number in range ```[ 0 , 255 ]``` ( ```[ 0b0000_0000, 0b1111_1111 ]``` ) based on the first byte
+     */
+    static getFirstByte(bits) {
+        return Number(`0x${bits.toString(16).slice(0, 2)}`);
+    }
+    /**
+     * @deprecated use ```andMaskOfLength``` instead
+     */
+    static andMaskOfLengthInt(n) {
+        n = Math.round(Math.abs(n));
+        // operatons used are valid on singed int32
+        if (n >= 30) {
+            return BitUtils.andMaskOfLength(BigInt(n));
+        }
+        return BigInt((1 << n) - 1);
+    }
+    /**
+     * returns a ```bigint``` of that as the last ```n``` bits setted to ones;
+     *
+     * example
+     * ```ts
+     * BitUtils.getMaskOfLength( 7 ) === Bigint( 0b0111_1111 ); // true
+     * ```
+     */
+    static andMaskOfLength(n) {
+        return BigInt((BigInt(1)
+            << n)
+            - BigInt(1));
+    }
+    static getNLastBits(fromNuber, nBits) {
+        return (fromNuber & BitUtils.andMaskOfLength(nBits));
+    }
+    /**
+     * @returns the number of bits from the first setted to ```1``` on the left up until the end
+     */
+    static getNOfUsedBits(bits) {
+        if (bits === BigInt(0))
+            return 0;
+        return bits.toString(2).length;
+    }
+    static minBytesRequired(bigint) {
+        if (bigint < BigInt(0))
+            throw new Error("BitUtils.minBytesRequired works for positives integers only");
+        const fullByteOnes = BigInt(255);
+        let mask = fullByteOnes;
+        let bytesRequired = 1;
+        while (bigint !== (bigint & mask)) {
+            mask = (mask << BigInt(8)) | fullByteOnes;
+            bytesRequired++;
+        }
+        return bytesRequired;
+    }
+}

package/dist/utils/CharCode.d.ts

@@ -0,0 +1,125 @@
+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
+}

package/dist/utils/CharCode.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/Cloneable.d.ts

@@ -0,0 +1,6 @@
+export interface Cloneable<T> {
+    clone: () => T;
+}
+export declare function isCloneable<T>(something: T): something is T & {
+    clone: () => T;
+};

package/dist/utils/Cloneable.js

@@ -0,0 +1,4 @@
+export function isCloneable(something) {
+    return (typeof (something["clone"]) === "function" &&
+        something["clone"].length === 0);
+}

package/dist/utils/InvalidCborFormatError.d.ts

@@ -0,0 +1,3 @@
+export declare class InvalidCborFormatError extends Error {
+    constructor(str: string, restMsg?: string);
+}

package/dist/utils/InvalidCborFormatError.js

@@ -0,0 +1,5 @@
+export class InvalidCborFormatError extends Error {
+    constructor(str, restMsg = "") {
+        super(`Invalid CBOR format for "${str}"; ${restMsg}`);
+    }
+}

package/dist/utils/IsSingleKey.d.ts

@@ -0,0 +1,7 @@
+type SingleKeyObj<K extends string | number | symbol, V = any> = {
+    [Prop in K]: (Record<Prop, V> & Record<Exclude<K, Prop>, never>) extends infer O ? {
+        [Q in keyof O]: O[Q];
+    } : never;
+}[K];
+export default SingleKeyObj;
+export type IsSingleKey<Obj extends object> = Obj extends SingleKeyObj<keyof Obj> ? true : false;

package/dist/utils/IsSingleKey.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/MaybePromise.d.ts

@@ -0,0 +1,2 @@
+export type MaybePromise<T> = T | Promise<T>;
+export declare function definitelyPromise<T>(value: MaybePromise<T>): Promise<T>;

package/dist/utils/MaybePromise.js

@@ -0,0 +1,4 @@
+export function definitelyPromise(value) {
+    return value instanceof Promise ? value : Promise.resolve(value);
+}
+;

package/dist/utils/PlutusScriptType.d.ts

@@ -0,0 +1,12 @@
+export declare const enum ScriptType {
+    NativeScript = "NativeScript",
+    PlutusV1 = "PlutusScriptV1",
+    PlutusV2 = "PlutusScriptV2"
+}
+export type PlutusScriptType = ScriptType.PlutusV1 | ScriptType.PlutusV2 | "PlutusScriptV1" | "PlutusScriptV2";
+export type LitteralScriptType = ScriptType | "NativeScript" | "PlutusScriptV1" | "PlutusScriptV2";
+export interface PlutusScriptJsonFormat<T extends PlutusScriptType = PlutusScriptType> {
+    type: T;
+    description?: string;
+    cborHex: string;
+}

package/dist/utils/PlutusScriptType.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/ToJson.d.ts

@@ -0,0 +1,4 @@
+export interface ToJson {
+    toJson: () => any;
+}
+export declare function logJson(jsonLike: ToJson, indent?: number): void;