bit2 0.0.2 → 0.0.4

package/dist/src/fuse/Fuse.js

@@ -1,1436 +0,0 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Utils_1 = require("../utils/Utils");
-const Exp_1 = require("../common/Exp");
-const peval_1 = require("../partialEval/peval");
-const Print_1 = require("../partial/Print");
-const Evaluation_1 = require("../lambda/Evaluation");
-// Apply update to a TermNode and return the updated TermNode and remaining operation
-function fuse(env, operation, term) {
-    // Check if the term is a ConstNode
-    if ((term.type === "const" ||
-        term.type === "sep" ||
-        term.type === "loopfront" ||
-        term.type === "looprear") &&
-        typeof term.value === "string") {
-        // add a new arr to env
-        if (term.type === "loopfront") {
-            let exp = term.lst;
-            if (exp.name) {
-                // Ensure exp is a Variable and has a name property
-                let expName = exp.name;
-                env[expName + "_new"] = [[], []]; // Set env[expName_new] to [[], []]
-            }
-            else {
-                throw new Error("exp is not a Variable with a name property in loopfront");
-            }
-        }
-        else if (term.type === "looprear") {
-            let exp = term.lst;
-            if (exp.name) {
-                let expName = exp.name;
-                env[expName] = env[expName + "_new"]; // assign back
-            }
-            else {
-                throw new Error("exp is not a Variable with a name property in loopfront");
-            }
-        }
-        const s_c = term.value;
-        switch (operation.type) {
-            case "insert":
-                const { str, position } = operation;
-                if (s_c.length === 0) {
-                    return [
-                        { newEnv: env, newTermNode: term, remainingOperation: operation },
-                        {
-                            newEnv: env,
-                            newTermNode: Object.assign(Object.assign({}, term), { value: str }),
-                            remainingOperation: { type: "id" },
-                        },
-                    ];
-                }
-                else if (position === 0) {
-                    // 两种更新策略
-                    return [
-                        {
-                            newEnv: Object.assign({}, env),
-                            newTermNode: Object.assign(Object.assign({}, term), { value: str + s_c }),
-                            remainingOperation: { type: "id" },
-                        },
-                        {
-                            newEnv: Object.assign({}, env),
-                            newTermNode: {
-                                type: "seq",
-                                nodes: [{ type: "const", value: str }, term],
-                            },
-                            remainingOperation: { type: "id" },
-                        },
-                    ];
-                }
-                else if (position < s_c.length) {
-                    const newStr = s_c.slice(0, position) + str + s_c.slice(position);
-                    return [
-                        {
-                            newEnv: env,
-                            newTermNode: Object.assign(Object.assign({}, term), { value: newStr }),
-                            remainingOperation: { type: "id" },
-                        },
-                    ];
-                }
-                else if (position === s_c.length) {
-                    // 两种策略
-                    return [
-                        {
-                            newEnv: Object.assign({}, env),
-                            newTermNode: Object.assign(Object.assign({}, term), { value: s_c + str }),
-                            remainingOperation: { type: "id" },
-                        },
-                        {
-                            newEnv: Object.assign({}, env),
-                            newTermNode: term,
-                            remainingOperation: {
-                                type: "insert",
-                                str,
-                                position: position - s_c.length,
-                            },
-                        },
-                    ];
-                }
-                else {
-                    const newPos = position - s_c.length;
-                    return [
-                        {
-                            newEnv: env,
-                            newTermNode: term,
-                            remainingOperation: { type: "insert", str, position: newPos },
-                        },
-                    ];
-                }
-            case "delete":
-                const { str: delStr, position: delPos } = operation;
-                if (delPos === 0) {
-                    if (s_c.startsWith(delStr) && delStr.length <= s_c.length) {
-                        // 如果delStr===s_c，那么 newStr=""; 还有一个策略，即bot
-                        const newStr = s_c.slice(delStr.length);
-                        let result = [
-                            {
-                                newEnv: env,
-                                newTermNode: Object.assign(Object.assign({}, term), { value: newStr }),
-                                remainingOperation: { type: "id" },
-                            },
-                        ];
-                        if (delStr.length === s_c.length) {
-                            result.push({
-                                newEnv: Object.assign({}, env),
-                                //@ts-ignore
-                                newTermNode: { type: "bot" },
-                                remainingOperation: { type: "id" },
-                            });
-                        }
-                        //@ts-ignore
-                        return result;
-                    }
-                    else if (delStr.startsWith(s_c) && delStr.length > s_c.length) {
-                        const remainingStr = delStr.slice(s_c.length);
-                        return [
-                            {
-                                newEnv: env,
-                                newTermNode: { type: "bot" },
-                                remainingOperation: {
-                                    type: "delete",
-                                    str: remainingStr,
-                                    position: 0,
-                                },
-                            },
-                            {
-                                newEnv: Object.assign({}, env),
-                                newTermNode: Object.assign(Object.assign({}, term), { value: "" }),
-                                remainingOperation: {
-                                    type: "delete",
-                                    str: remainingStr,
-                                    position: 0,
-                                },
-                            },
-                        ];
-                    }
-                }
-                else if (delPos < s_c.length &&
-                    delPos + delStr.length <= s_c.length) {
-                    const newStr = s_c.slice(0, delPos) + s_c.slice(delPos + delStr.length);
-                    return [
-                        {
-                            newEnv: env,
-                            newTermNode: Object.assign(Object.assign({}, term), { value: newStr }),
-                            remainingOperation: { type: "id" },
-                        },
-                    ];
-                }
-                else if (delPos < s_c.length && delPos + delStr.length > s_c.length) {
-                    const remainingS_c = s_c.substring(0, delPos); // 保留s_c删除位置之前的部分
-                    const remainingDelStr = delStr.substring(s_c.length - delPos); // 剩余需要删除的字符串
-                    return [
-                        {
-                            newEnv: env,
-                            newTermNode: { type: "const", value: remainingS_c },
-                            remainingOperation: {
-                                type: "delete",
-                                str: remainingDelStr,
-                                position: 0,
-                            },
-                        },
-                    ];
-                }
-                else {
-                    const newPos = delPos - s_c.length;
-                    return [
-                        {
-                            newEnv: env,
-                            newTermNode: term,
-                            remainingOperation: {
-                                type: "delete",
-                                str: delStr,
-                                position: newPos,
-                            },
-                        },
-                    ];
-                }
-            case "replace":
-                const { str1, str2, position: repPos, } = operation;
-                if (repPos === 0) {
-                    if (s_c.startsWith(str1) && str1.length <= s_c.length) {
-                        const newStr = str2 + s_c.slice(str1.length);
-                        return [
-                            {
-                                newEnv: env,
-                                newTermNode: Object.assign(Object.assign({}, term), { value: newStr }),
-                                remainingOperation: { type: "id" },
-                            },
-                        ];
-                    }
-                    else if (str1.startsWith(s_c) && str1.length > s_c.length) {
-                        const remainingS_c = str2.slice(0, s_c.length);
-                        const remainingStr1 = str1.slice(s_c.length);
-                        const remainingStr2 = str2.slice(s_c.length);
-                        return [
-                            {
-                                newEnv: env,
-                                newTermNode: Object.assign(Object.assign({}, term), { value: remainingS_c }),
-                                remainingOperation: {
-                                    type: "replace",
-                                    str1: remainingStr1,
-                                    str2: remainingStr2,
-                                    position: 0,
-                                },
-                            },
-                        ];
-                    }
-                }
-                else if (repPos < s_c.length && repPos + str1.length <= s_c.length) {
-                    const newStr = s_c.slice(0, repPos) + str2 + s_c.slice(repPos + str1.length);
-                    return [
-                        {
-                            newEnv: env,
-                            newTermNode: Object.assign(Object.assign({}, term), { value: newStr }),
-                            remainingOperation: { type: "id" },
-                        },
-                    ];
-                }
-                else if (repPos < s_c.length && repPos + str1.length > s_c.length) {
-                    const part1 = s_c.substring(0, repPos); // 替换位置之前的部分
-                    const overlapPart = s_c.substring(repPos); // 与替换的 str1 重叠的部分
-                    const overlapStr2 = str2.substring(0, overlapPart.length);
-                    const remainingStr1 = str1.substring(overlapPart.length); // 剩余需要替换的 str1 部分
-                    const remainingStr2 = str2.substring(overlapPart.length); // 剩余替换的 str2 部分
-                    const newOperation = {
-                        type: "replace",
-                        str1: remainingStr1,
-                        str2: remainingStr2,
-                        position: 0,
-                    };
-                    const newExpression = {
-                        type: "const",
-                        value: part1 + overlapStr2,
-                    };
-                    return [
-                        {
-                            newEnv: env,
-                            newTermNode: newExpression,
-                            remainingOperation: newOperation,
-                        },
-                    ];
-                }
-                else {
-                    const newPos = repPos - s_c.length;
-                    return [
-                        {
-                            newEnv: env,
-                            newTermNode: Object.assign(Object.assign({}, term), { value: s_c }),
-                            remainingOperation: {
-                                type: "replace",
-                                str1,
-                                str2,
-                                position: newPos,
-                            },
-                        },
-                    ];
-                }
-            case "bulk":
-                return fuseBulk(env, operation, term);
-            case "id":
-                return [
-                    {
-                        newEnv: env,
-                        newTermNode: term,
-                        remainingOperation: { type: "id" },
-                    },
-                ];
-            default:
-                const exhaustiveCheck = operation;
-                throw new Error(`Unhandled operation type: ${exhaustiveCheck}`);
-        }
-    }
-    else if (term.type === "space") {
-        switch (operation.type) {
-            case "insert":
-                const { str, position } = operation;
-                // zero-width space
-                if (term.width == 0) {
-                    return [
-                        { newEnv: env, newTermNode: term, remainingOperation: operation },
-                        {
-                            newEnv: Object.assign({}, env),
-                            newTermNode: {
-                                type: "seq",
-                                nodes: [{ type: "const", value: str }, term],
-                            },
-                            remainingOperation: { type: "id" },
-                        },
-                    ];
-                }
-                else if (position == 0) {
-                    // non-zero space
-                    let resultList = [
-                        {
-                            newEnv: env,
-                            newTermNode: {
-                                type: "seq",
-                                nodes: [{ type: "const", value: str }, term],
-                            },
-                            remainingOperation: { type: "id" },
-                        },
-                    ];
-                    if (Utils_1.isWhitespace(str)) {
-                        resultList.push({
-                            newEnv: Object.assign({}, env),
-                            newTermNode: {
-                                type: "space",
-                                width: term.width + str.length,
-                            },
-                            remainingOperation: { type: "id" },
-                        });
-                    }
-                    return resultList;
-                }
-                else if (position < term.width) {
-                    if (Utils_1.isWhitespace(str)) {
-                        return [
-                            {
-                                newEnv: env,
-                                newTermNode: Object.assign(Object.assign({}, term), { width: str.length + term.width }),
-                                remainingOperation: { type: "id" },
-                            },
-                        ];
-                    }
-                    else {
-                        throw new Error(`Cannot insert non-space between space term: ${operation}`);
-                    }
-                }
-                else if (position === term.width) {
-                    // 两种策略
-                    let resultList = [
-                        { newEnv: env, newTermNode: term, remainingOperation: operation },
-                    ];
-                    if (Utils_1.isWhitespace(str)) {
-                        resultList.push({
-                            newEnv: Object.assign({}, env),
-                            newTermNode: Object.assign(Object.assign({}, term), { width: term.width + str.length }),
-                            remainingOperation: { type: "id" },
-                        });
-                    }
-                    return resultList;
-                }
-                else {
-                    const newPos = position - term.width;
-                    return [
-                        {
-                            newEnv: env,
-                            newTermNode: term,
-                            remainingOperation: { type: "insert", str, position: newPos },
-                        },
-                    ];
-                }
-            case "delete":
-                const { str: delStr, position: delPos } = operation;
-                if (delPos === 0) {
-                    if (Utils_1.isWhitespace(delStr) && delStr.length <= term.width) {
-                        // 如果delStr===s_c，还有一个策略, 即bot
-                        const newWidth = term.width - delStr.length;
-                        let result = [
-                            {
-                                newEnv: env,
-                                newTermNode: Object.assign(Object.assign({}, term), { width: newWidth }),
-                                remainingOperation: { type: "id" },
-                            },
-                        ];
-                        // if (delStr.length === term.width) {
-                        //   result.push({
-                        //     newEnv: {...env},
-                        //     //@ts-ignore
-                        //     newTermNode: { type: "bot" },
-                        //     remainingOperation: { type: "id" },
-                        //   });
-                        // }
-                        //@ts-ignore
-                        return result;
-                    }
-                    else if (delStr.length > term.width) {
-                        const remainingStr = delStr.slice(term.width);
-                        return [
-                            {
-                                newEnv: env,
-                                newTermNode: { type: "bot" },
-                                remainingOperation: {
-                                    type: "delete",
-                                    str: remainingStr,
-                                    position: 0,
-                                },
-                            },
-                            {
-                                newEnv: Object.assign({}, env),
-                                newTermNode: Object.assign(Object.assign({}, term), { width: 0 }),
-                                remainingOperation: {
-                                    type: "delete",
-                                    str: remainingStr,
-                                    position: 0,
-                                },
-                            },
-                        ];
-                    }
-                }
-                else if (delPos < term.width &&
-                    delPos + delStr.length <= term.width) {
-                    const newWidth = term.width - delStr.length;
-                    return [
-                        {
-                            newEnv: env,
-                            newTermNode: Object.assign(Object.assign({}, term), { width: newWidth }),
-                            remainingOperation: { type: "id" },
-                        },
-                    ];
-                }
-                else if (delPos < term.width && delPos + delStr.length > term.width) {
-                    const remainingWidth = delPos;
-                    const remainingDelStr = delStr.substring(term.width - delPos); // 剩余需要删除的字符串
-                    return [
-                        {
-                            newEnv: env,
-                            newTermNode: { type: "space", width: remainingWidth },
-                            remainingOperation: {
-                                type: "delete",
-                                str: remainingDelStr,
-                                position: 0,
-                            },
-                        },
-                    ];
-                }
-                else {
-                    const newPos = delPos - term.width;
-                    return [
-                        {
-                            newEnv: env,
-                            newTermNode: term,
-                            remainingOperation: {
-                                type: "delete",
-                                str: delStr,
-                                position: newPos,
-                            },
-                        },
-                    ];
-                }
-            case "replace":
-                const { str1, str2, position: repPos, } = operation;
-                if (repPos === 0) {
-                    if (str1.length <= term.width) {
-                        if (Utils_1.isWhitespace(str2)) {
-                            const newWidth = term.width - str1.length + str2.length;
-                            return [
-                                {
-                                    newEnv: env,
-                                    newTermNode: Object.assign(Object.assign({}, term), { width: newWidth }),
-                                    remainingOperation: { type: "id" },
-                                },
-                            ];
-                        }
-                        else {
-                            return [
-                                {
-                                    newEnv: env,
-                                    newTermNode: {
-                                        type: "seq",
-                                        nodes: [
-                                            { type: "const", value: str2 },
-                                            Object.assign(Object.assign({}, term), { width: term.width - str1.length }),
-                                        ],
-                                    },
-                                    remainingOperation: { type: "id" },
-                                },
-                            ];
-                        }
-                    }
-                    else if (str1.length > term.width) {
-                        const remainingS_c = str2.slice(0, term.width);
-                        const remainingStr1 = str1.slice(term.width);
-                        const remainingStr2 = str2.slice(term.width);
-                        return [
-                            {
-                                newEnv: env,
-                                newTermNode: { type: "const", value: remainingS_c },
-                                remainingOperation: {
-                                    type: "replace",
-                                    str1: remainingStr1,
-                                    str2: remainingStr2,
-                                    position: 0,
-                                },
-                            },
-                        ];
-                    }
-                }
-                else if (repPos < term.width && repPos + str1.length <= term.width) {
-                    if (Utils_1.isWhitespace(str2)) {
-                        return [
-                            {
-                                newEnv: env,
-                                newTermNode: Object.assign(Object.assign({}, term), { width: str2.length + term.width - str1.length }),
-                                remainingOperation: { type: "id" },
-                            },
-                        ];
-                    }
-                    else {
-                        const newStr = " ".repeat(repPos) +
-                            str2 +
-                            " ".repeat(term.width - (repPos + str1.length));
-                        return [
-                            {
-                                newEnv: env,
-                                newTermNode: { type: "const", value: newStr },
-                                remainingOperation: { type: "id" },
-                            },
-                        ];
-                    }
-                }
-                else if (repPos < term.width && repPos + str1.length > term.width) {
-                    const part1 = " ".repeat(repPos); // 替换位置之前的部分
-                    const overlapPartLength = term.width - repPos; // 与替换的 str1 重叠的部分
-                    const overlapStr2 = str2.substring(0, overlapPartLength);
-                    const remainingStr1 = str1.substring(overlapPartLength); // 剩余需要替换的 str1 部分
-                    const remainingStr2 = str2.substring(overlapPartLength); // 剩余替换的 str2 部分
-                    const newOperation = {
-                        type: "replace",
-                        str1: remainingStr1,
-                        str2: remainingStr2,
-                        position: 0,
-                    };
-                    const newExpression = {
-                        type: "const",
-                        value: part1 + overlapStr2,
-                    };
-                    return [
-                        {
-                            newEnv: env,
-                            newTermNode: newExpression,
-                            remainingOperation: newOperation,
-                        },
-                    ];
-                }
-                else {
-                    const newPos = repPos - term.width;
-                    return [
-                        {
-                            newEnv: env,
-                            newTermNode: term,
-                            remainingOperation: {
-                                type: "replace",
-                                str1,
-                                str2,
-                                position: newPos,
-                            },
-                        },
-                    ];
-                }
-            case "bulk":
-                return fuseBulk(env, operation, term);
-            case "id":
-                return [
-                    {
-                        newEnv: env,
-                        newTermNode: term,
-                        remainingOperation: { type: "id" },
-                    },
-                ];
-            default:
-                throw new Error(`Unhandled operation type: ${operation}`);
-        }
-    }
-    else if (term.type === "exp") {
-        const expTerm = term;
-        const binding = term.binding;
-        const exp = binding[0];
-        const val = binding[1];
-        const valStr = valToStr(val);
-        switch (operation.type) {
-            case "insert":
-                const { str, position } = operation;
-                if (position === 0) {
-                    let resultList = [];
-                    resultList.push({
-                        newEnv: env,
-                        newTermNode: {
-                            type: "seq",
-                            nodes: [{ type: "const", value: str }, term],
-                        },
-                        remainingOperation: { type: "id" },
-                    });
-                    if (!Utils_1.isWhitespace(str)) {
-                        // another choice:
-                        let newStr = str + valStr;
-                        try {
-                            let newVal = strToVal(newStr, val);
-                            let { newEnv, newExp } = fuseExp(Object.assign({}, env), newVal, exp);
-                            resultList.push({
-                                newEnv: newEnv,
-                                newTermNode: Object.assign(Object.assign({}, term), { binding: [newExp, newVal] }),
-                                remainingOperation: { type: "id" },
-                            });
-                        }
-                        catch (error) {
-                            // console.error(error);
-                        }
-                    }
-                    return resultList;
-                }
-                else if (position < valStr.length) {
-                    const newStr = valStr.slice(0, position) + str + valStr.slice(position);
-                    const newVal = strToVal(newStr, val);
-                    let { newEnv, newExp } = fuseExp(env, newVal, exp);
-                    return [
-                        {
-                            newEnv: newEnv,
-                            newTermNode: Object.assign(Object.assign({}, term), { binding: [newExp, newVal] }),
-                            remainingOperation: { type: "id" },
-                        },
-                    ];
-                }
-                else if (position == valStr.length) {
-                    let resultList = [];
-                    if (!Utils_1.isWhitespace(str)) {
-                        const newStr = valStr + str;
-                        try {
-                            const newVal = strToVal(newStr, val);
-                            let { newEnv, newExp } = fuseExp(Object.assign({}, env), newVal, exp);
-                            resultList.push({
-                                newEnv: newEnv,
-                                newTermNode: Object.assign(Object.assign({}, term), { binding: [newExp, newVal] }),
-                                remainingOperation: { type: "id" },
-                            });
-                        }
-                        catch (error) {
-                            console.error(error);
-                        }
-                    }
-                    // If the expression is a variable, them add variable's bidning to env to mark it unmodifiable.
-                    let env2 = Object.assign({}, env);
-                    if (exp.name) {
-                        let x = exp.name;
-                        env2[x] = [val, [val]]; // mark x as unmodifiable.
-                    }
-                    resultList.push({
-                        newEnv: env2,
-                        newTermNode: term,
-                        remainingOperation: Object.assign(Object.assign({}, operation), { position: 0 }),
-                    });
-                    return resultList;
-                }
-                else {
-                    const newPosition = position - valStr.length;
-                    // If the expression is a variable, them add variable's bidning to env to mark it unmodifiable.
-                    if (exp.name) {
-                        let x = exp.name;
-                        env[x] = [val, [val]]; // mark x as unmodifiable.
-                    }
-                    return [
-                        {
-                            newEnv: env,
-                            newTermNode: term,
-                            remainingOperation: Object.assign(Object.assign({}, operation), { position: newPosition }),
-                        },
-                    ];
-                }
-            case "delete":
-                const { str: delStr, position: delPos } = operation;
-                if (delPos === 0) {
-                    if (delStr.length < valStr.length) {
-                        const newValStr = valStr.slice(delStr.length);
-                        const newVal = strToVal(newValStr, val);
-                        let { newEnv, newExp } = fuseExp(env, newVal, exp);
-                        return [
-                            {
-                                newEnv: newEnv,
-                                newTermNode: Object.assign(Object.assign({}, term), { binding: [newExp, newVal] }),
-                                remainingOperation: { type: "id" },
-                            },
-                        ];
-                    }
-                    else if (delStr.length == valStr.length) {
-                        if (exp.name) {
-                            let x = exp.name;
-                            if (typeof val == "string") {
-                                // two choice: update exp to "", or delete exp
-                                let { newEnv, newExp } = fuseExp(Object.assign({}, env), "", exp);
-                                return [
-                                    {
-                                        newEnv: newEnv,
-                                        newTermNode: Object.assign(Object.assign({}, term), { binding: [newExp, ""] }),
-                                        remainingOperation: { type: "id" },
-                                    },
-                                    {
-                                        newEnv: deleteFromEnv(env, x),
-                                        newTermNode: { type: "bot" },
-                                        remainingOperation: { type: "id" },
-                                    },
-                                ];
-                            }
-                            else {
-                                // delete exp, delete from env
-                                return [
-                                    {
-                                        newEnv: deleteFromEnv(env, x),
-                                        newTermNode: { type: "bot" },
-                                        remainingOperation: { type: "id" },
-                                    },
-                                ];
-                            }
-                        }
-                        else if (exp) {
-                            let x = exp.object.name;
-                            let field = exp.field;
-                            let xVal = env[x][0];
-                            let xValUpdatedMark = env[x][1][0];
-                            if (xValUpdatedMark.fields[field].length == 0) {
-                                let newXVal = deleteField(xVal, field);
-                                let newXValUpdatedMark = deleteField(xValUpdatedMark, field);
-                                let newEnv = deleteFromEnv(env, x);
-                                newEnv[x] = [newXVal, [newXValUpdatedMark]];
-                                return [
-                                    {
-                                        newEnv: newEnv,
-                                        newTermNode: { type: "bot" },
-                                        remainingOperation: { type: "id" },
-                                    },
-                                ];
-                            }
-                            else {
-                                throw new Error(`field has been updaeted, cannot be remvoed: ${field}$`);
-                            }
-                        }
-                    }
-                    else if (delStr.length > valStr.length) {
-                        let delStr1 = delStr.slice(0, valStr.length);
-                        let delStr2 = delStr.slice(valStr.length);
-                        let op1 = {
-                            type: "delete",
-                            str: delStr1,
-                            position: 0,
-                        };
-                        let resultList = fuse(env, op1, term);
-                        let op2 = {
-                            type: "delete",
-                            str: delStr2,
-                            position: 0,
-                        };
-                        resultList.forEach((result) => {
-                            result.remainingOperation = op2;
-                        });
-                        return resultList;
-                    }
-                }
-                else if (delPos + delStr.length <= valStr.length) {
-                    const newStr = valStr.slice(0, delPos) + valStr.slice(delPos + delStr.length);
-                    const newVal = strToVal(newStr, val);
-                    let { newEnv, newExp } = fuseExp(env, newVal, exp);
-                    return [
-                        {
-                            newEnv: newEnv,
-                            newTermNode: Object.assign(Object.assign({}, term), { binding: [newExp, newVal] }),
-                            remainingOperation: { type: "id" },
-                        },
-                    ];
-                }
-                else if (delPos <= valStr.length &&
-                    delPos + delStr.length > valStr.length) {
-                    const newStr = valStr.slice(0, delPos);
-                    const remainingDelStr = delStr.slice(valStr.length - delPos);
-                    const newVal = strToVal(newStr, val);
-                    let { newEnv, newExp } = fuseExp(env, newVal, exp);
-                    return [
-                        {
-                            newEnv: newEnv,
-                            newTermNode: Object.assign(Object.assign({}, term), { binding: [newExp, newVal] }),
-                            remainingOperation: {
-                                type: "delete",
-                                str: remainingDelStr,
-                                position: 0,
-                            },
-                        },
-                    ];
-                }
-                else if (delPos > valStr.length) {
-                    const newDelPos = delPos - valStr.length;
-                    let [{ newEnv, newTermNode, remainingOperation }] = fuse(env, { type: "id" }, term);
-                    return [
-                        {
-                            newEnv: newEnv,
-                            newTermNode: newTermNode,
-                            remainingOperation: {
-                                type: "delete",
-                                str: delStr,
-                                position: newDelPos,
-                            },
-                        },
-                    ];
-                }
-            case "replace":
-                const { str1, str2, position: repPos, } = operation;
-                if (repPos === 0) {
-                    if (valStr.startsWith(str1)) {
-                        const newValStr = str2 + valStr.slice(str1.length);
-                        const newVal = strToVal(newValStr, val);
-                        let { newEnv, newExp } = fuseExp(env, newVal, exp);
-                        // console.log("fuseExp, newVal:", newVal);
-                        // console.log("newEnv:", newEnv);
-                        return [
-                            {
-                                newEnv: newEnv,
-                                newTermNode: Object.assign(Object.assign({}, term), { binding: [newExp, newVal] }),
-                                remainingOperation: { type: "id" },
-                            },
-                        ];
-                    }
-                    else {
-                        throw new Error(`unsupported replacement: ${str1}; ${valStr}`);
-                    }
-                }
-                else if (repPos > valStr.length) {
-                    const newRepPos = repPos - valStr.length;
-                    let [{ newEnv, newTermNode, remainingOperation }] = fuse(env, { type: "id" }, term);
-                    return [
-                        {
-                            newEnv: newEnv,
-                            newTermNode: newTermNode,
-                            remainingOperation: Object.assign(Object.assign({}, operation), { position: newRepPos }),
-                        },
-                    ];
-                }
-                else {
-                    throw new Error(`Unsupported replacement`);
-                }
-            case "bulk":
-                return fuseBulk(env, operation, term);
-            case "id":
-                // find variables in e, and update them in env
-                let { variables, fields } = Exp_1.findVariablesAndFields(exp);
-                variables.forEach((variable) => {
-                    env = markVariableInEnv(variable, env);
-                });
-                fields.forEach(({ variable, field }) => {
-                    env = markFieldOfObjectInEnv(field, variable, env);
-                });
-                return [
-                    {
-                        newEnv: env,
-                        newTermNode: term,
-                        remainingOperation: { type: "id" },
-                    },
-                ];
-            default:
-                throw new Error(`Unhandled operation type: ${operation}`);
-        }
-    }
-    else if (term.type === "lambda") {
-        let marker = term.marker;
-        if (marker.type === "loopitem") {
-            let varName = term.variable.name;
-            let varExp = term.binding[0];
-            let varVal = term.binding[1];
-            let env1 = Object.assign({}, env);
-            env1[varName] = [varVal, []];
-            let newArrVarName = "";
-            if (marker.lst) {
-                let expName = marker.lst.name;
-                newArrVarName = expName + "_new";
-            }
-            else {
-                throw new Error("exp is not a Variable with a name property in loopitem's marker");
-            }
-            let resultList = fuse(env1, operation, term.body);
-            return resultList.map(({ newEnv, newTermNode, remainingOperation }) => {
-                let newVarVal = newEnv[varName][0];
-                let newArrVal = env[newArrVarName][0]; // must be an array
-                newArrVal.push(newVarVal);
-                env[newArrVarName] = [newArrVal, [newArrVal]];
-                let { newEnv: updatedEnv, newExp } = fuseExp(env, newVarVal, varExp);
-                return {
-                    newEnv: updatedEnv,
-                    newTermNode: {
-                        type: "lambda",
-                        variable: term.variable,
-                        body: newTermNode,
-                        binding: [newExp, newVarVal],
-                        marker: term.marker,
-                    },
-                    remainingOperation: remainingOperation,
-                };
-            });
-        }
-        else {
-            let varName = term.variable.name;
-            let varExp = term.binding[0];
-            let varVal = term.binding[1];
-            let env1 = Object.assign({}, env);
-            env1[varName] = [varVal, []];
-            // console.log("--------lambda----------");
-            // console.log("operation:", operation);
-            // console.log("term.body:", term.body);
-            // console.log("env1:", env1);
-            let resultList = fuse(env1, operation, term.body);
-            return resultList.map(({ newEnv, newTermNode, remainingOperation }) => {
-                // console.log("newEnv:", newEnv);
-                let newVarVal = newEnv[varName][0];
-                delete newEnv[varName];
-                let updatedOldEnv = updateEnvByEnv(env, newEnv);
-                let { newEnv: updatedEnv, newExp } = fuseExp(updatedOldEnv, newVarVal, varExp);
-                // console.log("lambda, newVarVal:", newVarVal);
-                // console.log("updatedOldEnv:", updatedOldEnv);
-                // console.log("exp:", varExp);
-                // console.log("newExp:", newExp);
-                // console.log("updatedEnv:", updatedEnv);
-                return {
-                    newEnv: updatedEnv,
-                    newTermNode: {
-                        type: "lambda",
-                        variable: term.variable,
-                        body: newTermNode,
-                        binding: [newExp, newVarVal],
-                        marker: term.marker,
-                    },
-                    remainingOperation: remainingOperation,
-                };
-            });
-        }
-    }
-    else if (term.type === "branchstart" ||
-        term.type === "branchend" ||
-        term.type === "nop") {
-        let resultList = [];
-        resultList.push({
-            newEnv: env,
-            newTermNode: term,
-            remainingOperation: operation,
-        });
-        switch (operation.type) {
-            case "insert":
-                const { str, position } = operation;
-                if (position === 0) {
-                    resultList.push({
-                        newEnv: env,
-                        newTermNode: {
-                            type: "seq",
-                            nodes: [{ type: "const", value: str }, term],
-                        },
-                        remainingOperation: { type: "id" },
-                    });
-                }
-            case "delete":
-            case "replace":
-                return resultList;
-            case "bulk":
-                return fuseBulk(env, operation, term);
-            default:
-                throw new Error(`Unhandled operation type: ${operation}`);
-        }
-    }
-    else if (term.type === "seq") {
-        if (operation.type === "bulk") {
-            return fuseBulk(env, operation, term);
-        }
-        const terms = term.nodes;
-        let results = [
-            {
-                newEnv: env,
-                newTermNode: { type: "seq", nodes: [] },
-                remainingOperation: operation,
-            },
-        ];
-        for (const subTerm of terms) {
-            const newResults = [];
-            for (const result of results) {
-                // console.log("-------------seq-----------");
-                // console.log(result);
-                // console.log(subTerm);
-                const subResults = fuse(result.newEnv, result.remainingOperation, subTerm);
-                for (const subResult of subResults) {
-                    const updatedNodes = (result.newTermNode.type === "seq"
-                        ? result.newTermNode.nodes
-                        : [result.newTermNode]).concat(subResult.newTermNode.type === "seq"
-                        ? subResult.newTermNode.nodes
-                        : [subResult.newTermNode]);
-                    newResults.push({
-                        newEnv: subResult.newEnv,
-                        newTermNode: {
-                            type: "seq",
-                            nodes: updatedNodes,
-                        },
-                        remainingOperation: subResult.remainingOperation,
-                    });
-                }
-            }
-            results = newResults;
-        }
-        return results.map((result) => ({
-            newEnv: result.newEnv,
-            newTermNode: result.newTermNode.type === "seq" &&
-                result.newTermNode.nodes.length === 1
-                ? result.newTermNode.nodes[0]
-                : result.newTermNode,
-            remainingOperation: result.remainingOperation,
-        }));
-    }
-    else if (term.type === "end") {
-        let results = [{ newEnv: env, newTermNode: term, remainingOperation: operation }];
-        return results;
-    }
-    else {
-        throw new Error("Operation can only be applied to ConstNode with string value");
-    }
-}
-exports.fuse = fuse;
-function fuseExp(env, value, exp) {
-    switch (exp.type) {
-        case "constant":
-            return { newEnv: env, newExp: valueToConstantExpr(value) };
-        case "variable":
-            if (!(exp.name in env)) {
-                throw new Error(`Variable ${exp.name} not found in environment.`);
-            }
-            const [varValue, marks] = env[exp.name];
-            if (marks.length === 0) {
-                const newEnv = Object.assign({}, env);
-                newEnv[exp.name] = [value, [value]];
-                return { newEnv, newExp: exp };
-            }
-            else if (marks.length === 1 && marks[0] === value) {
-                return { newEnv: env, newExp: exp };
-            }
-            else {
-                throw new Error(`Fail, variable cannot be updated to different value ${exp.name}, previous: ${marks[0]}, new: ${value}`);
-            }
-        case "freeze":
-            let [_, evaluated] = peval_1.evaluateExpr(transformEnvironment(env), exp.expression);
-            if (evaluated !== value) {
-                throw new Error(`Fail, freezed expression cannot be changed, old: ${value}, new: ${evaluated}`);
-            }
-            else {
-                return { newEnv: env, newExp: exp };
-            }
-        case "field":
-            // Rule for field access
-            const objExp = exp.object;
-            if (objExp.type === "variable" && objExp.name in env) {
-                const [objValue, objMarks] = env[objExp.name];
-                if (objValue.type === "object") {
-                    const newFields = Object.assign(Object.assign({}, objValue.fields), { [exp.field]: value });
-                    const newObjValue = {
-                        type: "object",
-                        fields: newFields,
-                    };
-                    const newMarks = updateFieldMarkWithValue(objMarks[0], exp.field, value);
-                    const newEnv = Object.assign({}, env);
-                    newEnv[objExp.name] = [newObjValue, [newMarks]];
-                    return { newEnv, newExp: exp };
-                }
-                else {
-                    throw new Error("Field access's value is not an object");
-                }
-            }
-            else {
-                throw new Error(`Field access not start with variable.`);
-            }
-        case "binary":
-            let transformedEnv = transformEnvironment(env);
-            let [envLeft, left] = peval_1.evaluateExpr(transformedEnv, exp.left);
-            // let [envRight, right] = evaluateExpr(transformedEnv, exp.right);
-            // if(value as number){
-            // console.log("transformedEnv:", transformedEnv);
-            // console.log("left:", left);
-            // console.log("value:", value);
-            // console.log("exp:", exp);
-            if (typeof value === "number") {
-                if (typeof value !== "number" || value === null) {
-                    throw new Error("Value must be a non-null number");
-                }
-                switch (exp.operator) {
-                    case "+":
-                        let subResultForPlus = fuseExp(env, value - left, exp.right);
-                        // console.log("subResult:", subResultForPlus);
-                        return {
-                            newEnv: subResultForPlus.newEnv,
-                            newExp: Object.assign(Object.assign({}, exp), { right: subResultForPlus.newExp }),
-                        };
-                    case "-":
-                        let subResultForMinus = fuseExp(env, left - value, exp.right);
-                        return {
-                            newEnv: subResultForMinus.newEnv,
-                            newExp: Object.assign(Object.assign({}, exp), { right: subResultForMinus.newExp }),
-                        };
-                    case "*":
-                        let subResultForTimes = fuseExp(env, value / left, exp.right);
-                        return {
-                            newEnv: subResultForTimes.newEnv,
-                            newExp: Object.assign(Object.assign({}, exp), { right: subResultForTimes.newExp }),
-                        };
-                    case "/":
-                        let subResultForDivide = fuseExp(env, left / value, exp.right);
-                        return {
-                            newEnv: subResultForDivide.newEnv,
-                            newExp: Object.assign(Object.assign({}, exp), { right: subResultForDivide.newExp }),
-                        };
-                }
-                // } else if (value as boolean) {
-            }
-            else if (typeof value === "boolean") {
-                // TODO
-            }
-        case "unary":
-            // Add logic for unary operations here
-            return { newEnv: env, newExp: exp };
-        default:
-            throw new Error(`Unsupported expression type: ${exp.type}`);
-    }
-}
-exports.fuseExp = fuseExp;
-function strToVal(s, v) {
-    if (typeof v === "number") {
-        const parsedNumber = parseFloat(s);
-        if (isNaN(parsedNumber)) {
-            throw new Error("convert to number fail: ${s}");
-        }
-        else {
-            return parsedNumber;
-        }
-    }
-    else if (typeof v === "boolean") {
-        if (s === "true") {
-            return true;
-        }
-        else if (s === "false") {
-            return false;
-        }
-        else {
-            throw new Error("convert to boolean fail: ${s}");
-        }
-    }
-    else if (typeof v === "string") {
-        return s; // v is already string, return s as is
-    }
-    else {
-        throw new Error(`Unsupported type: ${typeof v}`);
-    }
-}
-function valToStr(value) {
-    if (typeof value === "number" ||
-        typeof value === "boolean" ||
-        typeof value === "string") {
-        return String(value); // Convert number, boolean, and string to string
-    }
-    else {
-        return "Unknown"; // Handle unexpected types
-    }
-}
-function deleteFromEnv(env, key) {
-    const newEnv = Object.assign({}, env); // Create a shallow copy of env
-    delete newEnv[key]; // Delete the specified key from the new environment
-    return newEnv; // Return the modified environment
-}
-/**
- * Deletes a specified field from an ObjectValue.
- * @param obj The ObjectValue from which to delete the field.
- * @param field The field to delete.
- * @returns A new ObjectValue with the specified field removed.
- */
-function deleteField(obj, field) {
-    // Destructure the fields, omitting the specified field
-    const _a = obj.fields, _b = field, _ = _a[_b], newFields = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
-    // Return a new ObjectValue with the updated fields
-    return {
-        type: "object",
-        fields: newFields,
-    };
-}
-function updateFieldMark(obj, field, objVal) {
-    // Destructure the fields, omitting the specified field
-    const _a = obj.fields, _b = field, _ = _a[_b], newFields = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
-    newFields[field] = objVal.fields[field];
-    // Return a new ObjectValue with the updated fields
-    return {
-        type: "object",
-        fields: newFields,
-    };
-}
-function updateFieldMarkWithValue(obj, field, value) {
-    // Destructure the fields, omitting the specified field
-    const _a = obj.fields, _b = field, val = _a[_b], newFields = __rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
-    newFields[field] = [value];
-    // Return a new ObjectValue with the updated fields
-    return {
-        type: "object",
-        fields: newFields,
-    };
-}
-function markVariableInEnv(variable, env) {
-    if (!(variable.name in env)) {
-        throw new Error(`Variable ${variable.name} not found in environment.`);
-    }
-    let val = env[variable.name][0];
-    let newEnv = deleteFromEnv(env, variable.name);
-    newEnv[variable.name] = [val, [val]];
-    return newEnv;
-}
-function markFieldOfObjectInEnv(field, variable, env) {
-    let x = variable.name;
-    if (!(x in env)) {
-        throw new Error(`Variable ${x} not found in environment.`);
-    }
-    let xVal = env[x][0];
-    let xValMark = env[x][1][0];
-    let newXValUpdatedMark = updateFieldMark(xValMark, field, xVal);
-    let newEnv = deleteFromEnv(env, x);
-    newEnv[x] = [xVal, [newXValUpdatedMark]];
-    return newEnv;
-}
-function updateEnvByEnv(env, env2) {
-    // Create a copy of env to avoid mutating the original env
-    let updatedEnv = Object.assign({}, env);
-    // Iterate over keys in env2
-    for (const key in env2) {
-        if (env2.hasOwnProperty(key)) {
-            // Update the value in the updatedEnv
-            updatedEnv[key] = env2[key];
-        }
-    }
-    return updatedEnv;
-}
-function transformEnvironment(env) {
-    const map = new Map();
-    for (const variable in env) {
-        if (env.hasOwnProperty(variable)) {
-            map.set(variable, env[variable][0]);
-        }
-    }
-    return map;
-}
-function valueToConstantExpr(value) {
-    if (value === null ||
-        typeof value === "number" ||
-        typeof value === "boolean" ||
-        typeof value === "string") {
-        return { type: "constant", value: value };
-    }
-    else if (Array.isArray(value)) {
-        return {
-            type: "constant",
-            value: value.map((v) => valueToConstantExpr(v)),
-        };
-    }
-    else if (value.type === "object") {
-        const objectValue = value;
-        const fields = {};
-        for (const key in objectValue.fields) {
-            if (objectValue.fields.hasOwnProperty(key)) {
-                fields[key] = valueToConstantExpr(objectValue.fields[key]);
-            }
-        }
-        return {
-            type: "constant",
-            value: { type: "object", fields: fields },
-        };
-    }
-    else {
-        throw new Error(`Unhandled value type: ${typeof value}`);
-    }
-}
-exports.valueToConstantExpr = valueToConstantExpr;
-function printEnvironment(env) {
-    console.log("{\n");
-    for (const variable in env) {
-        if (env.hasOwnProperty(variable)) {
-            const [currentValue, marks] = env[variable];
-            console.log(`${variable}: {`);
-            console.log(" val: ");
-            Print_1.printValue(currentValue, " ");
-            console.log(",marks: [");
-            marks.forEach((v, index) => {
-                Print_1.printValue(v, " ");
-                if (index < marks.length - 1) {
-                    console.log(", ");
-                }
-            });
-            console.log("]\n },\n");
-        }
-    }
-    console.log("}");
-}
-exports.printEnvironment = printEnvironment;
-function fuseBulk(env, bulkOp, term) {
-    if (bulkOp.type === "id") {
-        // console.log("Bulk, term:", term);
-        return fuse(env, bulkOp, term);
-        // return [{ newEnv: env, newTermNode: term, remainingOperation: { type: 'id' } }];
-    }
-    if (bulkOp.type !== "bulk" || !bulkOp.operations) {
-        throw new Error("Invalid bulk operation");
-    }
-    // ending of recursive call
-    if (bulkOp.operations.length == 0) {
-        return [
-            { newEnv: env, newTermNode: term, remainingOperation: { type: "id" } },
-        ];
-    }
-    else if (term.type === "seq" && term.nodes.length == 0) {
-        return [{ newEnv: env, newTermNode: term, remainingOperation: bulkOp }];
-    }
-    const [op1, ...restOps] = bulkOp.operations;
-    if (term.type === "seq") {
-        const firstTerm = term.nodes[0];
-        const remainingTerms = term.nodes.slice(1);
-        const fuseResultsOfFirstTerm = fuseBulk(env, bulkOp, firstTerm);
-        // console.log("fuseResultsOfFirstTerm:", fuseResultsOfFirstTerm);
-        const results = [];
-        for (const result of fuseResultsOfFirstTerm) {
-            const subResults = fuseBulk(result.newEnv, result.remainingOperation, {
-                type: "seq",
-                nodes: remainingTerms,
-            });
-            for (const subResult of subResults) {
-                let remainingNodesTerm = [];
-                if (subResult.newTermNode.type != "seq") {
-                    remainingNodesTerm.push(subResult.newTermNode);
-                }
-                else {
-                    remainingNodesTerm = subResult.newTermNode.nodes;
-                }
-                results.push({
-                    newEnv: subResult.newEnv,
-                    newTermNode: {
-                        type: "seq",
-                        nodes: [result.newTermNode, ...remainingNodesTerm],
-                    },
-                    remainingOperation: subResult.remainingOperation,
-                });
-            }
-        }
-        return results;
-    }
-    else if (term.type === "lambda") {
-        return fuse(env, bulkOp, term);
-    }
-    else {
-        if (op1.type === "insert" ||
-            op1.type === "delete" ||
-            op1.type === "replace") {
-            const n1 = op1.position;
-            // 这里不能简单的fuse整个term，要根据term类型来，就好比上一个if判断是seq，除了seq外，LambdaAppNode需要特殊处理
-            const op1Results = fuse(env, op1, term);
-            let listOfList = op1Results.map((op1Result) => {
-                let op1Prime = op1Result.remainingOperation;
-                if (op1Prime.type === "id" ||
-                    op1Prime.type === "insert" ||
-                    op1Prime.type === "delete" ||
-                    op1Prime.type === "replace") {
-                    let termStr = Evaluation_1.evaluateTermNode(op1Result.newTermNode);
-                    let deltaN = termStr.length;
-                    // Adjust positions for the remaining operations
-                    const adjustedRestOps = restOps.map((op) => {
-                        if (op.type === "id") {
-                            return op;
-                        }
-                        else if (!("position" in op)) {
-                            throw new Error("All operations must have positions");
-                        }
-                        else {
-                            return Object.assign(Object.assign({}, op), { position: op.position - deltaN });
-                        }
-                    });
-                    // Combine the remaining operations
-                    let remainingBulkOp = {
-                        type: "bulk",
-                        operations: [op1Result.remainingOperation, ...adjustedRestOps],
-                    };
-                    return [
-                        {
-                            newEnv: op1Result.newEnv,
-                            newTermNode: op1Result.newTermNode,
-                            remainingOperation: remainingBulkOp,
-                        },
-                    ];
-                }
-                else {
-                    throw new Error("nested bulk current not supported");
-                }
-            });
-            return listOfList.reduce((acc, val) => acc.concat(val), []);
-        }
-        else if (op1.type === "id") {
-            // case 3
-            // Create a new bulk operation with the remaining operations
-            const newBulkOp = {
-                type: "bulk",
-                operations: restOps,
-            };
-            return fuseBulk(env, newBulkOp, term);
-        }
-    }
-    return [];
-}
-exports.fuseBulk = fuseBulk;
-function getOpStr(op1) {
-    if (op1.type === "insert" || op1.type === "delete") {
-        return op1.str;
-    }
-    else if (op1.type === "replace") {
-        return op1.str1;
-    }
-    else {
-        return undefined;
-    }
-}
-//# sourceMappingURL=Fuse.js.map