dop/dist/dop.js

Distributed Object Protocol.

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

// https://stackoverflow.com/questions/27433075/using-a-for-each-loop-on-an-empty-array-in-javascript
function forEach(object, callback) {
    if (isArray(object)) {
        for (var prop = 0; prop < object.length; ++prop) {
            callback(object[prop], prop);
        }
    } else {
        for (var prop$1 in object) {
            callback(object[prop$1], prop$1);
        }
    }
}

function forEachDeep(object, callback, path) {
    if ( path === void 0 ) path = [];

    forEach(object, function (value_origin, prop) {
        path.push(prop);
        if (
            callback({ object: object, prop: prop, path: path.slice(0) }) &&
            isObject(value_origin)
        ) {
            forEachDeep(value_origin, callback, path);
        }
        path.pop();
    });
}

// https://jsperf.com/merge-challenge
function merge(target, patch) {
    var args = arguments;
    if (args.length > 2) {
        // Remove the target 2 arguments of the arguments and add thoose arguments as merged at the begining
        Array.prototype.splice.call(args, 0, 2, merge.call(this, target, patch));
        // Recursion
        return merge.apply(this, args)
    } else if (patch === target) {
        return target
    } else {
        mergeCore(patch, target, mergeMutator);
        return target
    }
}

// https://jsperf.com/dop-foreachobject
// https://2ality.com/2019/10/shared-mutable-state.html
function mergeCore(patch, target_root, mutator) {
    forEachDeep(patch, function (ref) {
        var object = ref.object;
        var prop = ref.prop;
        var path = ref.path;

        var target = getDeep(target_root, path.slice(0, path.length - 1));
        var output = mutator({ patch: object, target: target, prop: prop, path: path });
        return output !== false
    });
}

function mergeMutator(ref) {
    var patch = ref.patch;
    var target = ref.target;
    var prop = ref.prop;

    var origin_value = patch[prop];
    var destiny_value = target[prop];
    var tof_origin = is(origin_value);
    var tof_destiny = is(destiny_value);
    if (isPlain(origin_value)) {
        if (!target.hasOwnProperty(prop) || tof_origin != tof_destiny) {
            target[prop] = tof_origin == 'array' ? [] : {};
        }
    } else {
        target[prop] = origin_value;
        return false // we dont go deeper
    }
}

function converter(patch, params, converters) {
    var patch_root = { '': patch }; // a trick to allow top level
    var target_root = { '': isArray(patch) ? [] : {} }; // a trick to allow top level
    mergeCore(patch_root, target_root, function (ref) {
        var patch = ref.patch;
        var prop = ref.prop;
        var target = ref.target;
        var path = ref.path;

        var value = converters.reduce(
            function (value, converter) { return converter(
                    merge(
                        {
                            value: value,
                            patch: patch,
                            target: target,
                            prop: prop,
                            path: path,
                        },
                        params
                    )
                ); },
            patch[prop]
        );
        if (patch[prop] !== value) {
            target[prop] = value;
            return false // we don't go deeper
        } else {
            return mergeMutator({ patch: patch, target: target, prop: prop })
        }
    });
    return target_root['']
}

function getUniqueKey(object) {
    var key_name;
    for (var key in object) {
        if (key_name !== undefined) {
            return
        }
        key_name = key;
    }
    return key_name
}

function getDeep(object, path) {
    var prop = path[0];
    if (path.length === 0) { return object }
    if (isObject(object) && object.hasOwnProperty(prop)) {
        return getDeep(object[prop], path.slice(1))
    }
}

function setDeep(object, path, value) {
    path = path.slice(0);
    var prop = path.shift();
    if (path.length === 0) {
        object[prop] = value;
        return
    }
    if (!object.hasOwnProperty(prop)) {
        object[prop] = {};
    }
    return setDeep(object[prop], path, value)
}

var ESCAPE_KEY = '$escape';
var RPC_KEY = '$r';
var DELETE_KEY = '$d';
var REPLACE_KEY = '$e';
var SPLICE_KEY = '$s';
var SWAP_KEY = '$w';
var MULTI_KEY = '$m';

var RPC_CREATOR = {
    ENTRY: 'ENTRY',
    REQUEST: 'REQUEST',
    RESPONSE: 'RESPONSE',
};

function is(value) {
    if (value === null) { return 'null' }
    if (isArray(value)) { return 'array' }
    return typeof value
}

function isFunction(fn) {
    return typeof fn == 'function'
}

function isArray(array) {
    return Array.isArray(array)
}

function isObject(object) {
    return object !== null && typeof object == 'object'
}

function isPlain(object) {
    if (!isObject(object)) { return false }
    var prototype = Object.getPrototypeOf(object);
    return prototype === Object.prototype || prototype === Array.prototype
}

function isPlainObject(object) {
    if (!isObject(object)) { return false }
    return Object.getPrototypeOf(object) === Object.prototype
}

function isInteger(number) {
    return (
        typeof number === 'number' &&
        isFinite(number) &&
        Math.floor(number) === number
    )
}

// export function isProxy(object) {
//     if (typeof Proxy !== 'function') {
//         return false
//     }
//     try {
//         object instanceof Proxy
//         return false
//     } catch (e) {
//         return true
//     }
// }

function isValidToDecode(ref) {
    var value = ref.value;
    var key = ref.key;

    return getUniqueKey(value) === key && value.hasOwnProperty(key)
}

function isValidToEscape(ref) {
    var value = ref.value;

    return getUniqueKey(value) === ESCAPE_KEY
}

function producePatch(baseobject, callback) {
    var draft = {};
    var mutations = [];
    var storing = false;

    forEachDeep({ draft: baseobject }, function (ref) {
        var object = ref.object;
        var prop = ref.prop;
        var path = ref.path;

        var origin = object;
        var destiny = getDeep(draft, path.slice(0, path.length - 1));
        var origin_value = origin[prop];
        var destiny_value = destiny[prop];
        var tof_origin = is(origin_value);
        var tof_destiny = is(destiny_value);

        if (
            isPlain(origin_value) &&
            (!destiny.hasOwnProperty(prop) || tof_origin != tof_destiny)
        ) {
            destiny[prop] = new Proxy(tof_origin == 'array' ? [] : {}, {
                set: function (object, prop, value) {
                    if (storing) {
                        mutations.push([
                            path.slice(1).concat(prop),
                            isPlainObject(value) //&& isPlainObject(object[prop])
                                ? TYPE.Replace(value)
                                : value ]);
                    }
                    object[prop] = value;
                    return true
                },
                deleteProperty: function (object, prop) {
                    if (storing) {
                        mutations.push([
                            path.slice(1).concat(prop),
                            TYPE.Delete() ]);
                    }
                    delete object[prop];
                    return true
                },
            });
            return true
        } else {
            destiny[prop] = origin_value;
            return false // we dont go deeper
        }
    });

    storing = true;
    callback(draft.draft);
    storing = false;

    var patch = createPatchFromMutations(mutations);
    return { patch: patch, mutations: mutations }
}

function createPatchFromMutations(mutations) {
    var patch = {};
    mutations.forEach(function (mutation) { return setDeep(patch, mutation[0], mutation[1]); });
    return patch
}

function createPatchAndUnpatchFromMutations(mutations, object) {
    var patch = {};
    var unpatch = {};
    mutations.forEach(function (ref) {
        var path = ref.path;
        var old_value = ref.old_value;

        setDeep(patch, path, getDeep(object, path));
        setDeep(unpatch, path, old_value);
    });
    return { patch: patch, unpatch: unpatch }
}

function localProcedureCall(fn, req, args, errorInstances) {
    function reject(error) {
        // https://airbrake.io/blog/nodejs-error-handling/nodejs-error-class-hierarchy
        for (var index = 0; index < errorInstances.length; ++index) {
            if (error instanceof errorInstances[index]) {
                throw error
            }
        }
        req.reject(error);
    }

    try {
        var output = fn.apply(req, args);
        if (output !== req) {
            output instanceof Promise
                ? output.then(req.resolve).catch(reject)
                : req.resolve(output);
        }
    } catch (error) {
        reject(error);
    }
}

function createRequest() {
    var resolve;
    var reject;
    var promise = new Promise(function (res, rej) {
        resolve = res;
        reject = rej;
    });
    promise.resolve = resolve;
    promise.reject = reject;
    return promise
}

// function Request(executor) {
//     let resolve
//     let reject
//     const promise = new Promise((res, rej) => {
//         resolve = res
//         reject = rej
//         // return executor(res, rej)
//     })

//     promise.__proto__ = Request.prototype
//     promise.resolve = resolve
//     promise.reject = reject
//     return promise
// }

// Request.__proto__ = Promise
// Request.prototype.__proto__ = Promise.prototype

function createNodeFactory(ref) {
    var encode = ref.encode;
    var decode = ref.decode;

    return function createNode(ref) {
        if ( ref === void 0 ) ref = {};
        var serialize = ref.serialize; if ( serialize === void 0 ) serialize = JSON.stringify;
        var deserialize = ref.deserialize; if ( deserialize === void 0 ) deserialize = JSON.parse;
        var rpcFilter = ref.rpcFilter; if ( rpcFilter === void 0 ) rpcFilter = function (props) { return props.rpc; };
        var errorInstances = ref.errorInstances; if ( errorInstances === void 0 ) errorInstances = [Error];

        var local_rpcs_id = {};
        var local_rpcs = new Map();
        var local_rpc_index = 1; // 0 is reserved for the entry function used in open()
        var requests = {};
        var request_id_index = 0;

        var encode_params = {
            local_rpcs: local_rpcs,
            registerLocalRpcFromEncode: registerLocalRpcFromEncode,
        };

        function registerRpc(function_id, fn) {
            local_rpcs_id[function_id] = fn;
            local_rpcs.set(fn, function_id);
            return function_id
        }

        function createRpc(function_id) {
            var makeCall = function (request_id, args) {
                var data = [request_id, function_id];
                if (args.length > 0) { data.push(args); }
                node.send(encode(data, encode_params));
                return data
            };

            var rpc = function () {
                var args = [], len = arguments.length;
                while ( len-- ) args[ len ] = arguments[ len ];

                var request_id = ++request_id_index;
                var req = createRequest();
                var resolve = req.resolve;
                var reject = req.reject;
                var resolveOrReject = function (fn, value) {
                    fn(value);
                    delete requests[request_id];
                    return req
                };
                req.data = makeCall(request_id, args);
                req.node = node;
                req.createdAt = new Date().getTime();
                req.resolve = function (value) { return resolveOrReject(resolve, value); };
                req.reject = function (error) { return resolveOrReject(reject, error); };
                requests[request_id] = req;
                return req
            };

            rpc.push = function () {
                var args = [], len = arguments.length;
                while ( len-- ) args[ len ] = arguments[ len ];

                makeCall(0, args);
            };

            return rpc
        }

        function createRemoteFunction(ref) {
            var function_id = ref.function_id;
            var function_creator = ref.function_creator;
            var caller = ref.caller;
            var path = ref.path;

            return rpcFilter({
                rpc: createRpc(function_id),
                node: node,
                function_id: function_id,
                function_creator: function_creator,
                caller: caller,
                path: path,
            })
        }

        function getNextLocalFunctionId() {
            while (local_rpcs_id.hasOwnProperty(local_rpc_index)) {
                local_rpc_index += 1;
            }
            return local_rpc_index
        }

        function open(send, fn) {
            var function_id = 0;
            if (isFunction(fn)) { registerRpc(function_id, fn); }
            node.send = function (msg) { return send(serialize(msg)); };
            return createRemoteFunction({
                function_id: function_id,
                function_creator: RPC_CREATOR.ENTRY,
            })
        }

        function message(msg) {
            msg = deserialize(msg);
            if (!isArray(msg) || !isInteger(msg[0])) {
                return false
            }

            var id = msg[0];
            var function_id = msg[1];
            var is_request = id > -1;
            var fn = is_request ? local_rpcs_id[function_id] : undefined;

            msg = decode(msg, {
                createRemoteFunction: createRemoteFunction,
                caller: fn,
                function_creator: is_request
                    ? RPC_CREATOR.REQUEST
                    : RPC_CREATOR.RESPONSE,
            });

            var args = msg[2];
            var response_id = -id;

            if (is_request && isFunction(fn)) {
                args = isArray(msg[2]) ? msg[2] : [];

                // Request without response
                if (id === 0) {
                    var req = { node: node };
                    args.push(req);
                    fn.apply(req, args);
                }

                // Request
                else {
                    var req$1 = createRequest();
                    var response = [response_id];
                    req$1.node = node;
                    req$1.then(function (value) {
                        response.push(0); // no errors
                        if (value !== undefined) { response.push(value); }
                        node.send(encode(response, encode_params));
                    }).catch(function (error) {
                        response.push(error === 0 ? null : error);
                        node.send(encode(response, encode_params));
                    });
                    args.push(req$1);
                    localProcedureCall(fn, req$1, args, errorInstances);
                }
                return true
            }

            // Response
            else if (id < 0 && requests.hasOwnProperty(response_id)) {
                var response_status = function_id;
                var req$2 = requests[response_id];
                response_status === 0
                    ? req$2.resolve(args)
                    : req$2.reject(response_status);
                return true
            }

            return false
        }

        function registerLocalRpcFromEncode(fn) {
            return registerRpc(getNextLocalFunctionId(), fn)
        }

        var node = {
            open: open,
            message: message,
            requests: requests,
            registerRpc: registerRpc,
            createRpc: createRpc,
        };

        return node
    }
}

function createStoreFactory(applyPatchFunction) {
    return function createStore(state) {
        var listeners = new Map();

        function subscribe(listener, filter) {
            listeners.set(listener, filter);
            return function () { return unsubscribe(listener); } // This has become a kind of standard
        }

        function unsubscribe(listener) {
            listeners.delete(listener);
        }

        function applyPatch(patch_or_fn) {
            var applied = applyPatchFunction(api.state, patch_or_fn);

            var outputs = Array.from(listeners.entries()).map(
                function (ref) {
                    var listener = ref[0];
                    var filter = ref[1];

                    var mutations = isFunction(filter)
                        ? applied.mutations.filter(filter)
                        : applied.mutations.slice(0);

                    var ref$1 =
                        createPatchAndUnpatchFromMutations(
                            mutations,
                            applied.patch
                        );
                    var patch = ref$1.patch;
                    var unpatch = ref$1.unpatch;

                    return {
                        listener: listener,
                        patch: patch,
                        unpatch: unpatch,
                        mutations: mutations,
                    }
                }
            );

            outputs.mutations = applied.mutations;
            outputs.patch = applied.patch;
            outputs.unpatch = applied.unpatch;

            return outputs
        }

        var api = {
            state: state,
            listeners: listeners,
            subscribe: subscribe,
            unsubscribe: unsubscribe,
            applyPatch: applyPatch,
        };

        return api
    }
}

function applyPatchFactory(patchers) {
    function applyPatch(target, patch_or_fn) {
        var patch = isFunction(patch_or_fn)
            ? producePatch(target, patch_or_fn).patch
            : patch_or_fn;
        return applyPatchRaw(target, patch)
    }

    function applyPatchRaw(target, patch) {
        var mutations = [];
        var target_root = { '': target }; // a trick to allow top level patches
        var patch_root = { '': patch }; // a trick to allow top level patches
        var unpatch_root = { '': {} };

        function addMutation(target, prop, old_value, path) {
            mutations.push({
                target: target,
                prop: prop,
                old_value: old_value,
                path: path,
            });
        }

        mergeCore(patch_root, target_root, function (ref) {
            var patch = ref.patch;
            var target = ref.target;
            var prop = ref.prop;
            var path = ref.path;

            var patch_value = patch[prop];
            var target_value = target[prop];
            if (
                !target.hasOwnProperty(prop) ||
                (patch_value !== target_value &&
                    !(isPlainObject(patch_value) && isPlain(target_value)))
            ) {
                var length = target.length;

                // Applying patches
                var old_value = patchers.reduce(
                    function (old_value, patcher) { return patcher({
                            patch: patch,
                            target: target,
                            prop: prop,
                            old_value: old_value,
                            applyPatch: applyPatch,
                        }); },
                    target_value
                );

                // We register the mutation if old_value is different to the new value
                if (target[prop] !== old_value) {
                    addMutation(target, prop, old_value, path.slice(1));
                    if (target.length !== length) {
                        addMutation(
                            target,
                            'length',
                            length,
                            path.slice(1, path.length - 1).concat('length')
                        );
                    }
                }

                return false // we don't go deeper
            }
        });

        // Creating unpatch
        for (var index = mutations.length - 1; index >= 0; --index) {
            var ref = mutations[index];
            var path = ref.path;
            var old_value = ref.old_value;
            setDeep(unpatch_root, [''].concat(path), old_value);
        }

        return {
            result: target_root[''],
            patch: patch,
            unpatch: unpatch_root[''],
            mutations: mutations,
        }
    }

    return applyPatch
}

function Delete() {
    if (!(this instanceof Delete)) {
        return new Delete()
    }
}

Delete.patch = function (ref) {
    var patch = ref.patch;
    var target = ref.target;
    var prop = ref.prop;
    var old_value = ref.old_value;

    if (patch[prop] instanceof Delete || patch[prop] === Delete) {
        delete target[prop];
    }
    return old_value
};

Delete.encode = function (ref) {
    var obj, obj$1;

    var value = ref.value;
    if (value instanceof Delete || value === Delete) {
        return ( obj = {}, obj[DELETE_KEY] = 0, obj )
    } else if (isValidToDecodeDelete({ value: value })) {
        return ( obj$1 = {}, obj$1[ESCAPE_KEY] = value, obj$1 )
    }
    return value
};

Delete.decode = function (ref) {
    var value = ref.value;

    if (isValidToDecodeDelete({ value: value })) {
        return new Delete()
    } else if (
        isValidToEscape({ value: value }) &&
        isValidToDecodeDelete({ value: value[ESCAPE_KEY] })
    ) {
        return value[ESCAPE_KEY]
    }
    return value
};

function isValidToDecodeDelete(ref) {
    var value = ref.value;

    return getUniqueKey(value) === DELETE_KEY && value[DELETE_KEY] === 0
}

function Replace(value) {
    if (!(this instanceof Replace)) {
        return new Replace(value)
    }
    this.value = value;
}

Replace.patch = function (ref) {
    var patch = ref.patch;
    var target = ref.target;
    var prop = ref.prop;
    var old_value = ref.old_value;

    if (patch[prop] instanceof Replace) {
        target[prop] = patch[prop].value;
        return old_value instanceof Delete ? old_value : new Replace(old_value)
    }
    return old_value
};

Replace.encode = function (ref) {
    var obj, obj$1;

    var value = ref.value;
    var encode = ref.encode;
    if (value instanceof Replace) {
        return ( obj = {}, obj[REPLACE_KEY] = encode(value.value), obj )
    } else if (isValidToDecode({ value: value, key: REPLACE_KEY })) {
        return ( obj$1 = {}, obj$1[ESCAPE_KEY] = value, obj$1 )
    }
    return value
};

Replace.decode = function (ref) {
    var value = ref.value;
    var decode = ref.decode;

    if (isValidToDecode({ value: value, key: REPLACE_KEY })) {
        return new Replace(decode(value[REPLACE_KEY]))
    } else if (
        isValidToEscape({ value: value }) &&
        isValidToDecode({ value: value[ESCAPE_KEY], key: REPLACE_KEY })
    ) {
        return value[ESCAPE_KEY]
    }
    return value
};

function Primitives() {}

Primitives.patch = function (ref) {
    var patch = ref.patch;
    var target = ref.target;
    var prop = ref.prop;
    var old_value = ref.old_value;
    var applyPatch = ref.applyPatch;

    var patch_value = patch[prop];

    // If target[prop] is not defined yet
    if (!target.hasOwnProperty(prop)) {
        old_value = new Delete();
    }

    // New array
    if (isArray(patch_value)) {
        target[prop] = merge([], patch_value);
        if (isPlainObject(old_value)) {
            old_value = Replace(old_value);
        }
    }

    // Object as patch
    else if (isPlainObject(patch_value)) {
        target[prop] = applyPatch({}, patch_value).result;
    }

    // Any other
    else {
        target[prop] = patch_value;
    }

    return old_value
};

function Rpc() {}

Rpc.encode = function (ref) {
    var obj, obj$1;

    var value = ref.value;
    var local_rpcs = ref.local_rpcs;
    var registerLocalRpcFromEncode = ref.registerLocalRpcFromEncode;
    if (isFunction(value)) {
        var function_id = local_rpcs.has(value)
            ? local_rpcs.get(value)
            : registerLocalRpcFromEncode(value);
        return ( obj = {}, obj[RPC_KEY] = function_id, obj )
    } else if (isValidToDecode({ value: value, key: RPC_KEY })) {
        return ( obj$1 = {}, obj$1[ESCAPE_KEY] = value, obj$1 )
    }
    return value
};

Rpc.decode = function (ref) {
    var value = ref.value;
    var createRemoteFunction = ref.createRemoteFunction;
    var path = ref.path;
    var caller = ref.caller;
    var function_creator = ref.function_creator;

    if (getUniqueKey(value) === RPC_KEY && isInteger(value[RPC_KEY])) {
        return createRemoteFunction({
            function_id: value[RPC_KEY],
            function_creator: function_creator,
            caller: caller,
            path: path.slice(2),
        })
    } else if (
        isValidToEscape({ value: value }) &&
        isValidToDecode({ value: value[ESCAPE_KEY], key: RPC_KEY })
    ) {
        return value[ESCAPE_KEY]
    }
    return value
};

function Splice() {
    var args = [], len = arguments.length;
    while ( len-- ) args[ len ] = arguments[ len ];

    if (!(this instanceof Splice)) {
        return new (Function.prototype.bind.apply( Splice, [ null ].concat( args) ))
    }
    this.args = args;
}

Splice.patch = function (ref) {
    var patch = ref.patch;
    var target = ref.target;
    var prop = ref.prop;
    var old_value = ref.old_value;

    var patch_value = patch[prop];
    if (patch_value instanceof Splice) {
        target[prop] = old_value;
        if (isArray(old_value)) {
            var args = patch_value.args;
            if (args[0] < 0) {
                args[0] = old_value.length + args[0];
            }
            var spliced = old_value.splice.apply(old_value, args);
            var inverted = [args[0], args.length - 2].concat(spliced);
            return Splice.apply(null, inverted)
        }
    }
    return old_value
};

Splice.encode = function (ref) {
    var obj, obj$1;

    var value = ref.value;
    var encode = ref.encode;
    if (value instanceof Splice) {
        return ( obj = {}, obj[SPLICE_KEY] = encode(value.args), obj )
    } else if (isValidToDecode$1({ value: value, key: SPLICE_KEY })) {
        return ( obj$1 = {}, obj$1[ESCAPE_KEY] = value, obj$1 )
    }
    return value
};

Splice.decode = function (ref) {
    var value = ref.value;
    var decode = ref.decode;

    if (isValidToDecode$1({ value: value, key: SPLICE_KEY })) {
        return Splice.apply(null, decode(value[SPLICE_KEY]))
    } else if (
        isValidToEscape({ value: value }) &&
        isValidToDecode$1({ value: value[ESCAPE_KEY], key: SPLICE_KEY })
    ) {
        return value[ESCAPE_KEY]
    }
    return value
};

function isValidToDecode$1(ref) {
    var value = ref.value;

    return getUniqueKey(value) === SPLICE_KEY && isArray(value[SPLICE_KEY])
}

function Swap() {
    var args = [], len = arguments.length;
    while ( len-- ) args[ len ] = arguments[ len ];

    if (!(this instanceof Swap)) {
        return new (Function.prototype.bind.apply( Swap, [ null ].concat( args) ))
    }
    this.args = args;
}

Swap.patch = function (ref) {
    var patch = ref.patch;
    var target = ref.target;
    var prop = ref.prop;
    var old_value = ref.old_value;

    var patch_value = patch[prop];
    if (patch_value instanceof Swap) {
        target[prop] = old_value;
        if (isArray(old_value)) {
            var array = old_value;
            var swaps = patch_value.args;
            if (array.length > 0 && swaps.length > 1) {
                var total = swaps.length - 1;
                for (var index = 0; index < total; index += 2) {
                    var swap_a = swaps[index];
                    var swap_b = swaps[index + 1];
                    var temp_item = array[swap_a];
                    array[swap_a] = array[swap_b];
                    array[swap_b] = temp_item;
                }
                return Swap.apply(null, swaps.slice(0).reverse())
            }
        }
    }
    return old_value
};

Swap.encode = function (ref) {
    var obj, obj$1;

    var value = ref.value;
    if (value instanceof Swap) {
        return ( obj = {}, obj[SWAP_KEY] = value.args, obj )
    } else if (isValidToDecode$2({ value: value, key: SWAP_KEY })) {
        return ( obj$1 = {}, obj$1[ESCAPE_KEY] = value, obj$1 )
    }
    return value
};

Swap.decode = function (ref) {
    var value = ref.value;

    if (isValidToDecode$2({ value: value, key: SWAP_KEY })) {
        return Swap.apply(null, value[SWAP_KEY])
    } else if (
        isValidToEscape({ value: value }) &&
        isValidToDecode$2({ value: value[ESCAPE_KEY], key: SWAP_KEY })
    ) {
        return value[ESCAPE_KEY]
    }
    return value
};

function isValidToDecode$2(ref) {
    var value = ref.value;

    return getUniqueKey(value) === SWAP_KEY && isArray(value[SWAP_KEY])
}

function Multi() {
    var values = [], len = arguments.length;
    while ( len-- ) values[ len ] = arguments[ len ];

    if (!(this instanceof Multi)) {
        return new (Function.prototype.bind.apply( Multi, [ null ].concat( values) ))
    }
    this.values = values;
}

Multi.patch = function (ref) {
    var patch = ref.patch;
    var target = ref.target;
    var prop = ref.prop;
    var old_value = ref.old_value;
    var applyPatch = ref.applyPatch;

    var patch_value = patch[prop];
    if (patch_value instanceof Multi) {
        target[prop] = old_value;
        var unpatch = patch_value.values.map(function (value) {
            var obj;

            var ref = applyPatch(target, ( obj = {}, obj[prop] = value, obj ));
            var unpatch = ref.unpatch;
            return unpatch[prop]
        });
        return Multi.apply(null, unpatch.reverse())
    }
    return old_value
};

Multi.encode = function (ref) {
    var obj, obj$1;

    var value = ref.value;
    var encode = ref.encode;
    if (value instanceof Multi) {
        return ( obj = {}, obj[MULTI_KEY] = encode(value.values), obj )
    } else if (isValidToDecodeMulti({ value: value })) {
        return ( obj$1 = {}, obj$1[ESCAPE_KEY] = value, obj$1 )
    }
    return value
};

Multi.decode = function (ref) {
    var value = ref.value;
    var decode = ref.decode;

    if (isValidToDecodeMulti({ value: value })) {
        return Multi.apply(null, decode(value[MULTI_KEY]))
    } else if (
        isValidToEscape({ value: value }) &&
        isValidToDecodeMulti({ value: value[ESCAPE_KEY] })
    ) {
        return value[ESCAPE_KEY]
    }
    return value
};

function isValidToDecodeMulti(ref) {
    var value = ref.value;

    return getUniqueKey(value) === MULTI_KEY && isArray(value[MULTI_KEY])
}

// import { version } from '../package.json.js'

// Deno does not support json imports: https://stackoverflow.com/questions/61907155/deno-import-json-file-as-module
var version = '1.5.4';

function factory() {
    var patchers = [];
    var encoders = [];
    var decoders = [];
    var encode = function (object, params, list) {
            if ( params === void 0 ) params = {};
            if ( list === void 0 ) list = encoders;

            return converter(object, merge(params, { encode: encode }), list);
    };
    var decode = function (object, params, list) {
            if ( params === void 0 ) params = {};
            if ( list === void 0 ) list = decoders;

            return converter(object, merge(params, { decode: decode }), list);
    };
    var applyPatch = applyPatchFactory(patchers);
    var createStore = createStoreFactory(applyPatch);
    var createNode = createNodeFactory({ encode: encode, decode: decode });
    var addType = function (ref) {
        var patch = ref.patch;
        var encode = ref.encode;
        var decode = ref.decode;

        if (isFunction(patch)) { patchers.push(patch); }
        if (isFunction(encode)) { encoders.push(encode); }
        if (isFunction(decode)) { decoders.push(decode); }
    };

    addType(Primitives);
    addType(Rpc);
    addType(Delete);
    addType(Replace);
    addType(Splice);
    addType(Swap);
    addType(Multi);

    return {
        version: version,
        factory: factory,
        merge: merge,
        encode: encode,
        decode: decode,
        producePatch: producePatch,
        applyPatch: applyPatch,
        createNode: createNode,
        createStore: createStore,
        addType: addType,
        TYPE: {
            Delete: Delete,
            Replace: Replace,
            Splice: Splice,
            Swap: Swap,
            Multi: Multi,
        },
    }
}

var dop = factory();
var encode = dop.encode;
var decode = dop.decode;
var applyPatch = dop.applyPatch;
var createNode = dop.createNode;
var createStore = dop.createStore;
var addType = dop.addType;
var TYPE = dop.TYPE;

exports.TYPE = TYPE;
exports.addType = addType;
exports.applyPatch = applyPatch;
exports.createNode = createNode;
exports.createStore = createStore;
exports.decode = decode;
exports.default = dop;
exports.encode = encode;
exports.factory = factory;
exports.merge = merge;
exports.producePatch = producePatch;
exports.version = version;