siphon-library 1.1.0 → 1.2.0

package/out/code_reference.d.ts

@@ -0,0 +1,11 @@
+interface CodeReference {
+    fileName: string;
+    contractName: string;
+    functionName: string;
+    lines?: {
+        start: number;
+        end: number;
+    };
+}
+declare function createCodeReference(code: string, fileName: string, contractName: string, functionName: string): CodeReference;
+export { createCodeReference, CodeReference };

package/out/code_reference.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCodeReference = createCodeReference;
+function createCodeReference(code, fileName, contractName, functionName) {
+    const linesArray = code.split("\n");
+    let contractLine = -1;
+    for (let i = 0; i < linesArray.length; i++) {
+        if (linesArray[i].includes(`contract ${contractName}`)) {
+            contractLine = i + 1;
+            break;
+        }
+    }
+    if (contractLine === -1) {
+        console.log(`Contract "${contractName}" not found in the code.`);
+        return { fileName, contractName, functionName };
+    }
+    let functionStartLine = -1;
+    let functionEndLine = -1;
+    for (let i = contractLine; i < linesArray.length; i++) {
+        if (linesArray[i].includes(`function ${functionName}(`)) {
+            functionStartLine = i + 1;
+            let openBraces = 0;
+            let foundOpening = false;
+            for (let j = i; j < linesArray.length; j++) {
+                const line = linesArray[j];
+                for (const char of line) {
+                    if (char === "{") {
+                        openBraces++;
+                        foundOpening = true;
+                    }
+                    else if (char === "}") {
+                        openBraces--;
+                    }
+                }
+                if (foundOpening && openBraces === 0) {
+                    functionEndLine = j + 1;
+                    break;
+                }
+            }
+            break;
+        }
+    }
+    const codeReference = {
+        fileName,
+        contractName,
+        functionName,
+    };
+    if (functionEndLine !== -1) {
+        codeReference.lines = {
+            start: functionStartLine,
+            end: functionEndLine,
+        };
+    }
+    return codeReference;
+}
+//# sourceMappingURL=code_reference.js.map

package/out/code_reference.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"code_reference.js","sourceRoot":"","sources":["../src/code_reference.ts"],"names":[],"mappings":";;AA2ES,kDAAmB;AAjE5B,SAAS,mBAAmB,CAC1B,IAAY,EACZ,QAAgB,EAChB,YAAoB,EACpB,YAAoB;IAEpB,MAAM,UAAU,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAEpC,IAAI,YAAY,GAAG,CAAC,CAAC,CAAC;IACtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3C,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,YAAY,YAAY,EAAE,CAAC,EAAE,CAAC;YACvD,YAAY,GAAG,CAAC,GAAG,CAAC,CAAC;YACrB,MAAM;QACR,CAAC;IACH,CAAC;IAED,IAAI,YAAY,KAAK,CAAC,CAAC,EAAE,CAAC;QACxB,OAAO,CAAC,GAAG,CAAC,aAAa,YAAY,0BAA0B,CAAC,CAAC;QACjE,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,YAAY,EAAE,CAAC;IAClD,CAAC;IAED,IAAI,iBAAiB,GAAG,CAAC,CAAC,CAAC;IAC3B,IAAI,eAAe,GAAG,CAAC,CAAC,CAAC;IAEzB,KAAK,IAAI,CAAC,GAAG,YAAY,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtD,IAAI,UAAU,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,YAAY,YAAY,GAAG,CAAC,EAAE,CAAC;YACxD,iBAAiB,GAAG,CAAC,GAAG,CAAC,CAAC;YAC1B,IAAI,UAAU,GAAG,CAAC,CAAC;YACnB,IAAI,YAAY,GAAG,KAAK,CAAC;YACzB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC3C,MAAM,IAAI,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;gBAE3B,KAAK,MAAM,IAAI,IAAI,IAAI,EAAE,CAAC;oBACxB,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;wBACjB,UAAU,EAAE,CAAC;wBACb,YAAY,GAAG,IAAI,CAAC;oBACtB,CAAC;yBAAM,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;wBACxB,UAAU,EAAE,CAAC;oBACf,CAAC;gBACH,CAAC;gBAED,IAAI,YAAY,IAAI,UAAU,KAAK,CAAC,EAAE,CAAC;oBACrC,eAAe,GAAG,CAAC,GAAG,CAAC,CAAC;oBACxB,MAAM;gBACR,CAAC;YACH,CAAC;YACD,MAAM;QACR,CAAC;IACH,CAAC;IAED,MAAM,aAAa,GAAkB;QACnC,QAAQ;QACR,YAAY;QACZ,YAAY;KACb,CAAC;IAEF,IAAI,eAAe,KAAK,CAAC,CAAC,EAAE,CAAC;QAC3B,aAAa,CAAC,KAAK,GAAG;YACpB,KAAK,EAAE,iBAAiB;YACxB,GAAG,EAAE,eAAe;SACrB,CAAC;IACJ,CAAC;IACD,OAAO,aAAa,CAAC;AACvB,CAAC"}

package/out/pattern.d.ts

@@ -0,0 +1,17 @@
+export declare enum PatternType {
+    RedundantCode = "REDUNDANT_CODE",
+    OpaquePredicates = "OPAQUE_PREDICATES",
+    ExpensiveOperationsInsideLoop = "EXPENSIVE_OPERATIONS_INSIDE_LOOP",
+    LoopInvariantOperations = "LOOP_INVARIANT_OPERATIONS",
+    LoopInvariantConditions = "LOOP_INVARIANT_CONDITIONS"
+}
+export type Severity = "low" | "medium" | "high" | "critical";
+export interface PatternInfo {
+    name: string;
+    description: string;
+    severity: Severity;
+}
+export declare const PatternDefinitions: Record<PatternType, PatternInfo>;
+export interface DetectedPattern extends PatternInfo {
+    type: PatternType;
+}

package/out/pattern.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PatternDefinitions = exports.PatternType = void 0;
+// Define an enum for pattern types.
+var PatternType;
+(function (PatternType) {
+    PatternType["RedundantCode"] = "REDUNDANT_CODE";
+    PatternType["OpaquePredicates"] = "OPAQUE_PREDICATES";
+    PatternType["ExpensiveOperationsInsideLoop"] = "EXPENSIVE_OPERATIONS_INSIDE_LOOP";
+    PatternType["LoopInvariantOperations"] = "LOOP_INVARIANT_OPERATIONS";
+    PatternType["LoopInvariantConditions"] = "LOOP_INVARIANT_CONDITIONS";
+})(PatternType || (exports.PatternType = PatternType = {}));
+// This constant maps each PatternType to its corresponding info.
+exports.PatternDefinitions = {
+    [PatternType.RedundantCode]: {
+        name: "Redundant Code",
+        description: "Identifies unreachable code branches that can be eliminated to reduce bytecode size.",
+        severity: "low",
+    },
+    [PatternType.OpaquePredicates]: {
+        name: "Opaque Predicates",
+        description: "Detects conditions that always evaluate to the same value regardless of input.",
+        severity: "low",
+    },
+    [PatternType.ExpensiveOperationsInsideLoop]: {
+        name: "Expensive Operations Inside Loop",
+        description: "Flags high-cost operations (e.g., storage accesses) performed inside loops.",
+        severity: "high",
+    },
+    [PatternType.LoopInvariantOperations]: {
+        name: "Loop Invariant Operations",
+        description: "Identifies operations inside loops that yield the same result on every iteration.",
+        severity: "medium",
+    },
+    [PatternType.LoopInvariantConditions]: {
+        name: "Loop Invariant Conditions",
+        description: "Recognizes condition checks in loops that remain constant across iterations.",
+        severity: "medium",
+    },
+};
+//# sourceMappingURL=pattern.js.map

package/out/pattern.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern.js","sourceRoot":"","sources":["../src/pattern.ts"],"names":[],"mappings":";;;AAAA,oCAAoC;AACpC,IAAY,WAMX;AAND,WAAY,WAAW;IACrB,+CAAgC,CAAA;IAChC,qDAAsC,CAAA;IACtC,iFAAkE,CAAA;IAClE,oEAAqD,CAAA;IACrD,oEAAqD,CAAA;AACvD,CAAC,EANW,WAAW,2BAAX,WAAW,QAMtB;AAYD,iEAAiE;AACpD,QAAA,kBAAkB,GAAqC;IAClE,CAAC,WAAW,CAAC,aAAa,CAAC,EAAE;QAC3B,IAAI,EAAE,gBAAgB;QACtB,WAAW,EACT,sFAAsF;QACxF,QAAQ,EAAE,KAAK;KAChB;IACD,CAAC,WAAW,CAAC,gBAAgB,CAAC,EAAE;QAC9B,IAAI,EAAE,mBAAmB;QACzB,WAAW,EACT,gFAAgF;QAClF,QAAQ,EAAE,KAAK;KAChB;IACD,CAAC,WAAW,CAAC,6BAA6B,CAAC,EAAE;QAC3C,IAAI,EAAE,kCAAkC;QACxC,WAAW,EACT,6EAA6E;QAC/E,QAAQ,EAAE,MAAM;KACjB;IACD,CAAC,WAAW,CAAC,uBAAuB,CAAC,EAAE;QACrC,IAAI,EAAE,2BAA2B;QACjC,WAAW,EACT,mFAAmF;QACrF,QAAQ,EAAE,QAAQ;KACnB;IACD,CAAC,WAAW,CAAC,uBAAuB,CAAC,EAAE;QACrC,IAAI,EAAE,2BAA2B;QACjC,WAAW,EACT,8EAA8E;QAChF,QAAQ,EAAE,QAAQ;KACnB;CACF,CAAC"}

package/out/siphon_client.d.ts

@@ -0,0 +1,38 @@
+export interface PatternDiagnostic {
+    contract: string;
+    function: string;
+    pattern_name: string;
+    pattern_id: number;
+    block_id: number;
+    contract_start_line: number | null;
+    contract_end_line: number | null;
+    function_start_line: number | null;
+    function_end_line: number | null;
+    pattern_start_line: number | null;
+    pattern_end_line: number | null;
+    source: string | null;
+    message: string | null;
+    suggestion: string | null;
+}
+export declare class SiphonWS {
+    private ws;
+    private pending;
+    constructor(url: string);
+    private _onMessage;
+    private _rpc;
+    /** One-off pattern analysis */
+    analyze(code: string): Promise<PatternDiagnostic[]>;
+    /** One-off optimize from scratch (does its own analysis under the hood) */
+    optimize(code: string): Promise<{
+        patches: any[];
+        newCode: string;
+    }>;
+    /**
+     * Analyze once, store patterns server-side, then optimize re-using those patterns.
+     * Falls back to server's internal analyzeOptimize if nothing stored.
+     */
+    analyzeThenOptimize(code: string): Promise<{
+        patches: any[];
+        newCode: string;
+    }>;
+}

package/out/siphon_client.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SiphonWS = void 0;
+class SiphonWS {
+    ws;
+    pending = new Map();
+    constructor(url) {
+        this.ws = new WebSocket(url);
+        this.ws.onmessage = evt => this._onMessage(evt.data);
+    }
+    _onMessage(raw) {
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        if (msg.id) {
+            const p = this.pending.get(msg.id);
+            if (!p)
+                return;
+            if (msg.error)
+                p.reject(msg.error);
+            else
+                p.resolve(msg.result);
+            this.pending.delete(msg.id);
+        }
+    }
+    _rpc(method, params = {}) {
+        const id = Math.random().toString(36).slice(2, 10);
+        const payload = { id, method, params };
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, { resolve, reject });
+            this.ws.send(JSON.stringify(payload));
+        });
+    }
+    /** One-off pattern analysis */
+    analyze(code) {
+        return this._rpc('analyze', { code })
+            .then(r => r.patterns);
+    }
+    /** One-off optimize from scratch (does its own analysis under the hood) */
+    optimize(code) {
+        return this._rpc('optimize', { code });
+    }
+    /**
+     * Analyze once, store patterns server-side, then optimize re-using those patterns.
+     * Falls back to server's internal analyzeOptimize if nothing stored.
+     */
+    analyzeThenOptimize(code) {
+        // first do analyze
+        return this._rpc('analyze', { code })
+            .then(r => {
+            // now optimize with stored patterns (server will detect msg_id and reuse)
+            return this._rpc('optimize', { code });
+        });
+    }
+}
+exports.SiphonWS = SiphonWS;
+//# sourceMappingURL=siphon_client.js.map

package/out/siphon_client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"siphon_client.js","sourceRoot":"","sources":["../src/siphon_client.ts"],"names":[],"mappings":";;;AAqBA,MAAa,QAAQ;IACX,EAAE,CAAY;IACd,OAAO,GAAG,IAAI,GAAG,EAAmB,CAAC;IAE7C,YAAY,GAAW;QACrB,IAAI,CAAC,EAAE,GAAG,IAAI,SAAS,CAAC,GAAG,CAAC,CAAC;QAC7B,IAAI,CAAC,EAAE,CAAC,SAAS,GAAG,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAc,CAAC,CAAC;IACjE,CAAC;IAEO,UAAU,CAAC,GAAW;QAC5B,IAAI,GAAqB,CAAC;QAC1B,IAAI,CAAC;YACH,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACxB,CAAC;QAAC,MAAM,CAAC;YAAC,OAAO;QAAC,CAAC;QACnB,IAAI,GAAG,CAAC,EAAE,EAAE,CAAC;YACX,MAAM,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACnC,IAAI,CAAC,CAAC;gBAAE,OAAO;YACf,IAAI,GAAG,CAAC,KAAK;gBAAE,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;;gBAC9B,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAC3B,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IAEO,IAAI,CAAI,MAAc,EAAE,SAAc,EAAE;QAC9C,MAAM,EAAE,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACnD,MAAM,OAAO,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,CAAC;QACvC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACrC,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC,CAAC;YAC1C,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC;QACxC,CAAC,CAAC,CAAC;IACL,CAAC;IAED,+BAA+B;IAC/B,OAAO,CAAC,IAAY;QAClB,OAAO,IAAI,CAAC,IAAI,CAAoC,SAAS,EAAE,EAAE,IAAI,EAAE,CAAC;aACrE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;IAC3B,CAAC;IAED,2EAA2E;IAC3E,QAAQ,CAAC,IAAY;QACnB,OAAO,IAAI,CAAC,IAAI,CAAsC,UAAU,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;IAC9E,CAAC;IAED;;;OAGG;IACH,mBAAmB,CAAC,IAAY;QAC9B,mBAAmB;QACnB,OAAO,IAAI,CAAC,IAAI,CAAoC,SAAS,EAAE,EAAE,IAAI,EAAE,CAAC;aACrE,IAAI,CAAC,CAAC,CAAC,EAAE;YACR,0EAA0E;YAC1E,OAAO,IAAI,CAAC,IAAI,CAAsC,UAAU,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC;QAC9E,CAAC,CAAC,CAAC;IACP,CAAC;CACF;AAvDD,4BAuDC"}

package/out/test.d.ts

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

package/out/test.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// test.ts
+const siphon_client_1 = require("./siphon_client");
+async function runTests() {
+    const client = new siphon_client_1.SiphonWS('ws://localhost:8000/ws');
+    await new Promise(res => setTimeout(res, 100)); // give WS a moment
+    console.log('✅ Connected to Siphon WS');
+    const codeSample = `
+    // SPDX-License-Identifier: GPL-3.0
+
+    pragma solidity >=0.8.0;
+
+    contract EvaluationPattern1 {
+        uint256 minThreshold;
+        uint256 maxThreshold;
+        uint256 scalingFactor;
+        uint256 offset;
+        bool public Error;
+
+        function pattern1(uint256 x) public {
+            minThreshold = 5;
+            maxThreshold = 10;
+            scalingFactor = maxThreshold / minThreshold;
+            offset = 2;
+
+            uint256 y;
+            uint256 z;
+            if (minThreshold < x && x < maxThreshold) {
+                y = x * scalingFactor;
+
+                if (y < maxThreshold) {
+                    Error = true;
+                }
+            } else {
+                y  = 2 * maxThreshold;
+            } 
+
+            z = y - offset;
+
+            if (z < maxThreshold) {
+                Error = true;
+            } else {
+                Error = false;
+            }
+        }
+    }
+
+    contract EvaluationPattern2 {
+        uint256 amount = 15;
+        uint256 interest = 2;
+        uint256 balance;
+        bool public Error;
+
+        function pattern2() public {
+            amount = 15;
+            interest = 2;
+
+            uint256 tentativeBalance = balance;
+            if (tentativeBalance > amount * interest) {
+                tentativeBalance -= amount * interest;
+
+                if (tentativeBalance > 0) {
+                    Error = false;
+                } else {
+                    Error = true;
+                }
+
+                balance = tentativeBalance;
+            }
+        }
+    }
+
+    contract EvaluationPattern4 {
+        uint256 numberOfTransactions;
+        address[] userList;
+        mapping(address => uint256) usersBalance;
+        address smallestBalanceIndex;
+
+        function pattern4(uint256 transactionAmount) public {
+            for(uint256 i = 0; i < userList.length; i++) {
+                    numberOfTransactions++;
+                    address userAddress = userList[i];
+
+                    usersBalance[userAddress] += transactionAmount;
+
+                    if (usersBalance[userAddress] < usersBalance[smallestBalanceIndex]) {
+                        smallestBalanceIndex = userAddress;
+                    }
+            }
+        
+        
+
+            for(uint256 i = 0; i < userList.length; i++) { 
+                    usersBalance[smallestBalanceIndex] += transactionAmount * 2;
+            }
+        }
+    }
+
+    contract EvaluationPattern5 {
+        address[] userList;
+        mapping(address => uint256) usersBalance;
+
+        function validAddress(address userAddress) public pure returns (bool) {
+            return true;
+        }
+
+        function interest(uint256 amount) public pure returns (uint256) {
+            return amount * 2;
+        }
+
+        function pattern5(uint256 amount) public {
+            for(uint256 i = 0; i < userList.length; i++) {
+                    address userAddress = userList[i];
+                    if (validAddress(userAddress)) {
+                        usersBalance[userAddress] += interest(amount);
+                    }
+            }    
+        }
+    }
+
+    contract EvaluationPattern6 {
+        address[] userList;
+        mapping(address => uint256) usersBalance;
+
+        function adjustedMinThreshold(uint256 amount) public pure returns (uint256) {
+            return (amount) / (amount + 100);
+        }
+
+        function pattern6(uint256 amount) public {
+            for(uint256 i = 0; i < userList.length; i++) {
+                    address userAddress = userList[i];
+                    uint256 value;
+                    if (amount < adjustedMinThreshold(amount)) {
+                        value = amount;
+                    } else {
+                        value = 100;
+                    }
+
+                    usersBalance[userAddress] += value;
+            }    
+        }
+    }
+`;
+    // 1) analyze
+    const patterns = await client.analyze(codeSample);
+    console.log('📝 analyze result:', patterns);
+    if (patterns.length === 0) {
+        throw new Error('Expected at least one pattern diagnostic');
+    }
+    // 2) optimize from scratch
+    const { patches, newCode } = await client.optimize(codeSample);
+    console.log('🛠 optimize result:', { patches, newCode });
+    if (typeof newCode !== 'string') {
+        throw new Error('Expected optimized code string');
+    }
+    // 3) analyzeThenOptimize
+    const result2 = await client.analyzeThenOptimize(codeSample);
+    console.log('🔄 analyzeThenOptimize result:', result2);
+    console.log('✅ All tests passed');
+}
+runTests().catch(err => {
+    console.error('❌ Test suite failed:', err);
+    process.exit(1);
+});
+//# sourceMappingURL=test.js.map

package/out/test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.js","sourceRoot":"","sources":["../src/test.ts"],"names":[],"mappings":";;AAAA,UAAU;AACV,mDAA8D;AAE9D,KAAK,UAAU,QAAQ;IACrB,MAAM,MAAM,GAAG,IAAI,wBAAQ,CAAC,wBAAwB,CAAC,CAAC;IACtD,MAAM,IAAI,OAAO,CAAO,GAAG,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,CAAE,mBAAmB;IAC1E,OAAO,CAAC,GAAG,CAAC,0BAA0B,CAAC,CAAC;IAE1C,MAAM,UAAU,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuIlB,CAAC;IAEA,aAAa;IACb,MAAM,QAAQ,GAAwB,MAAM,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IACvE,OAAO,CAAC,GAAG,CAAC,oBAAoB,EAAE,QAAQ,CAAC,CAAC;IAC5C,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC1B,MAAM,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC;IAC9D,CAAC;IAED,2BAA2B;IAC3B,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,MAAM,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IAC/D,OAAO,CAAC,GAAG,CAAC,qBAAqB,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,CAAC;IACzD,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;QAChC,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;IACpD,CAAC;IAED,yBAAyB;IACzB,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,mBAAmB,CAAC,UAAU,CAAC,CAAC;IAC7D,OAAO,CAAC,GAAG,CAAC,gCAAgC,EAAE,OAAO,CAAC,CAAC;IAEvD,OAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;AACpC,CAAC;AAED,QAAQ,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE;IACrB,OAAO,CAAC,KAAK,CAAC,sBAAsB,EAAE,GAAG,CAAC,CAAC;IAC3C,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "siphon-library",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "A library for ...",
   "main": "out/index.js",
   "types": "out/index.d.ts",