diff --git a/packages/node_modules/@node-red/editor-client/src/js/nodes.js b/packages/node_modules/@node-red/editor-client/src/js/nodes.js
index e1086884e..e6053b887 100644
--- a/packages/node_modules/@node-red/editor-client/src/js/nodes.js
+++ b/packages/node_modules/@node-red/editor-client/src/js/nodes.js
@@ -1764,6 +1764,16 @@ RED.nodes = (function() {
 
     }
 
+    /**
+     * Analyzes the array of nodes passed as an argument to find unknown node types.
+     *
+     * Options:
+     * - `emitNotification` (boolean) - Emit an notification with unknown types.
+     *
+     * @param {Array<object>} nodes An array of nodes to analyse
+     * @param {object} options An options object
+     * @returns {Array<string>} An array with unknown types
+     */
     function identifyUnknowType(nodes, options = {}) {
         const unknownTypes = [];
         for (let node of nodes) {
@@ -1791,6 +1801,191 @@ RED.nodes = (function() {
         return unknownTypes;
     }
 
+    function copyConfigNode(configNode, def, options = {}) {
+        const newNode = {
+            id: configNode.id,
+            z: configNode.z,
+            type: configNode.type,
+            icon: configNode.icon,
+            info: configNode.info,
+            label: def.label,
+            users: [],
+            _config: {},
+            _def: def
+        };
+
+        if (!configNode.z) {
+            delete newNode.z;
+        }
+
+        if (options.markChanged) {
+            newNode.changed = true;
+        }
+
+        if (configNode.hasOwnProperty("d")) {
+            newNode.d = configNode.d;
+        }
+
+        // Copy node user properties
+        for (const d in def.defaults) {
+            if (def.defaults.hasOwnProperty(d)) {
+                newNode._config[d] = JSON.stringify(configNode[d]);
+                newNode[d] = configNode[d];
+            }
+        }
+
+        // Copy credentials - ONLY if the node contains it to avoid erase it
+        if (def.hasOwnProperty("credentials") && configNode.hasOwnProperty("credentials")) {
+            newNode.credentials = {};
+            for (const c in def.credentials) {
+                if (def.credentials.hasOwnProperty(c) && configNode.credentials.hasOwnProperty(c)) {
+                    newNode.credentials[c] = configNode.credentials[c];
+                }
+            }
+        }
+    
+        return newNode;
+    }
+
+    function copyNode(node, def, options = {}) {
+        const newNode = {
+            id: node.id,
+            x: parseFloat(node.x || 0),
+            y: parseFloat(node.y || 0),
+            z: node.z,
+            type: node.type,
+            info: node.info,
+            changed: false,
+            _config: {},
+            _def: def
+        };
+
+        if (node.type !== "group" && node.type !== "junction") {
+            newNode.wires = node.wires || [];
+            newNode.inputLabels = node.inputLabels;
+            newNode.outputLabels = node.outputLabels;
+            newNode.icon = node.icon;
+        }
+        if (node.type === "junction") {
+            newNode.wires = node.wires || [];
+        }
+        if (node.hasOwnProperty("l")) {
+            newNode.l = node.l;
+        }
+        if (node.hasOwnProperty("d")) {
+            newNode.d = node.d;
+        }
+        if (node.hasOwnProperty("g")) { // Group
+            newNode.g = node.g;
+        }
+        if (options.markChanged) {
+            newNode.changed = true
+        }
+
+        if (node.type === "group") {
+            newNode._def = RED.group.def;
+            for (const d in newNode._def.defaults) {
+                if (newNode._def.defaults.hasOwnProperty(d) && d !== "inputs" && d !== "outputs") {
+                    newNode[d] = node[d];
+                    newNode._config[d] = JSON.stringify(node[d]);
+                }
+            }
+            newNode._config.x = node.x;
+            newNode._config.y = node.y;
+            if (node.hasOwnProperty("w")) { // Weight
+                newNode.w = node.w
+            }
+            if (node.hasOwnProperty("h")) { // Height
+                newNode.h = node.h
+            }
+        } else if (node.type === "junction") {
+            newNode._def = { defaults: {} };
+            newNode._config.x = node.x
+            newNode._config.y = node.y
+            newNode.inputs = 1
+            newNode.outputs = 1
+            newNode.w = 0;
+            newNode.h = 0;
+        } else if (node.type.substring(0, 7) === "subflow") {
+            const parentId = node.type.split(":")[1];
+            /*
+            const subflow = subflow_denylist[parentId]||subflow_map[parentId]||getSubflow(parentId);
+            // TODO: Pourquoi ne pas l'avoir mis dans les tabs ?
+            if (!subflow){
+                node._def = {
+                    color:"#fee",
+                    defaults: {},
+                    label: "unknown: "+n.type,
+                    labelStyle: "red-ui-flow-node-label-italic",
+                    outputs: n.outputs|| (n.wires && n.wires.length) || 0,
+                    set: registry.getNodeSet("node-red/unknown")
+                }
+            } else {
+                // TODO: Normal que la copie utilise le Subflow parent ?
+                if (subflow_denylist[parentId] || createNewIds || options.importMap[n.id] === "copy") {
+                    parentId = subflow.id;
+                    node.type = "subflow:"+parentId;
+                    node._def = registry.getNodeType(node.type);
+                    delete node.i;
+                }
+                node.name = n.name;
+                node.outputs = subflow.out.length;
+                node.inputs = subflow.in.length;
+                node.env = n.env;
+            }*/
+        } else {
+            newNode._config.x = node.x;
+            newNode._config.y = node.y;
+
+            if (node.hasOwnProperty("inputs")) {
+                newNode._config.inputs = JSON.stringify(node.inputs);
+                newNode.inputs = node.inputs;
+            } else {
+                newNode.inputs = def.inputs;
+            }
+
+            if (node.hasOwnProperty("outputs")) {
+                newNode._config.outputs = JSON.stringify(node.outputs);
+                newNode.outputs = node.outputs;
+            } else {
+                newNode.outputs = def.outputs;
+            }
+
+            if (newNode.wires.length > newNode.outputs) {
+                if (!def.defaults.hasOwnProperty("outputs") || !isNaN(parseInt(newNode.outputs))) {
+                    // The node declares outputs in its defaults, but has not got a valid value
+                    // Defer to the length of the wires array
+                    newNode.outputs = newNode.wires.length;
+                } else {
+                    // If 'wires' is longer than outputs, clip wires
+                    console.log("Warning: node.wires longer than node.outputs - trimming wires:", node.id, " wires:", node.wires.length, " outputs:", node.outputs);
+                    // TODO: Pas dans l'autre sens ?
+                    newNode.wires = newNode.wires.slice(0, newNode.outputs);
+                }
+            }
+
+            // Copy node user properties
+            for (const d in def.defaults) {
+                if (newNode._def.defaults.hasOwnProperty(d) && d !== "inputs" && d !== "outputs") {
+                    newNode._config[d] = JSON.stringify(node[d]);
+                    newNode[d] = node[d];
+                }
+            }
+
+            // Copy credentials - ONLY if the node contains it to avoid erase it
+            if (def.hasOwnProperty("credentials") && node.hasOwnProperty("credentials")) {
+                newNode.credentials = {};
+                for (const c in def.credentials) {
+                    if (newNode._def.credentials.hasOwnProperty(c) && node.credentials.hasOwnProperty(c)) {
+                        newNode.credentials[c] = node.credentials[c];
+                    }
+                }
+            }
+        }
+
+        return newNode;
+    }
+
     /**
      * Options:
      *  - generateIds - whether to replace all node ids
@@ -1803,7 +1998,7 @@ RED.nodes = (function() {
      *       - id:copy - import with new id
      *       - id:replace - import over the top of existing
      */
-    function importNodes(newNodes, options) {
+    function importNodes(originalNodes, options) {
         const defaultOptions = { generateIds: false, addFlow: false, markChanged: false, reimport: false, importMap: {} };
         options = Object.assign({}, defaultOptions, options);
 
@@ -1811,11 +2006,11 @@ RED.nodes = (function() {
         const createMissingWorkspace = options.addFlow;
         const reimport = (!createNewIds && !!options.reimport);
 
-        // Checks and converts the flow into an Array if necessary
-        if (typeof newNodes === "string") {
-            if (newNodes === "") { return; }
+        // Checks and converts nodes into an Array if necessary
+        if (typeof originalNodes === "string") {
+            if (originalNodes === "") { return; }
             try {
-                newNodes = JSON.parse(newNodes);
+                originalNodes = JSON.parse(originalNodes);
             } catch(err) {
                 const error = new Error(RED._("clipboard.invalidFlow", { message: err.message }));
                 error.code = "NODE_RED";
@@ -1823,15 +2018,15 @@ RED.nodes = (function() {
             }
         }
 
-        if (!Array.isArray(newNodes)) {
-            newNodes = [newNodes];
+        if (!Array.isArray(originalNodes)) {
+            originalNodes = [originalNodes];
         }
 
         const seenIds = new Set();
         const existingNodes = [];
         const nodesToReplace = [];
-        // Checks if the imported flow contains duplicates or existing nodes.
-        newNodes = newNodes.filter(function(node) {
+        // Checks if the imported nodes contains duplicates or existing nodes.
+        originalNodes = originalNodes.filter(function(node) {
             const id = node.id;
 
             // This is a temporary fix to help resolve corrupted flows caused by 0.20.0 where multiple
@@ -1840,10 +2035,11 @@ RED.nodes = (function() {
             if (seenIds.has(id)) { return false; }
             seenIds.add(id);
 
-            // Checks if the node already exists - the user will choose between copying the node or replacing it
+            // Checks if the node already exists - the user will choose between copying the node, replacing it or not import it
             if (!createNewIds) {
                 if (!options.importMap[id]) {
                     // No conflict resolution for this node
+                    // TODO: Sure?
                     const existingNode = allNodes.getNode(id) || configNodes[id] || workspaces[id] || subflows[id] || groups[id] || junctions[id];
                     if (existingNode) {
                         existingNodes.push({ existing: existingNode, imported: node });
@@ -1857,9 +2053,10 @@ RED.nodes = (function() {
             return true;
         });
 
-        // If some nodes already exists, ask the user for each node to choose between copying it or replacing it
+        // If some nodes already exists, ask the user for each node to choose
+        // between copying it, replacing it or not importing it.
         if (existingNodes.length) {
-            const errorMessage = RED._("clipboard.importDuplicate",{ count: existingNodes.length });
+            const errorMessage = RED._("clipboard.importDuplicate", { count: existingNodes.length });
             const maxItemCount = 5; // Max 5 items in the list
             const nodeList = $("<ul>");
 
@@ -1872,13 +2069,13 @@ RED.nodes = (function() {
             }
 
             if (existingNodes.length > maxItemCount) {
-                $("<li>").text(RED._("deploy.confirm.plusNMore", {count: (existingNodes.length - maxItemCount) })).appendTo(nodeList);
+                $("<li>").text(RED._("deploy.confirm.plusNMore", { count: (existingNodes.length - maxItemCount) })).appendTo(nodeList);
             }
 
             const wrapper = $("<p>").append(nodeList);
             const existingNodesError = new Error(errorMessage + wrapper.html());
             existingNodesError.code = "import_conflict";
-            existingNodesError.importConfig = identifyImportConflicts(newNodes);
+            existingNodesError.importConfig = identifyImportConflicts(originalNodes);
             throw existingNodesError;
         }
 
@@ -1886,7 +2083,7 @@ RED.nodes = (function() {
         // TODO: Handled activeWorkspace = 0
         let activeWorkspace = RED.workspaces.active();
         const activeSubflow = getSubflow(activeWorkspace);
-        for (let node of newNodes) {
+        for (const node of originalNodes) {
             const group = /^subflow:(.+)$/.exec(node.type);
             if (group) {
                 const subflowId = group[1];
@@ -1916,18 +2113,19 @@ RED.nodes = (function() {
         let isInitialLoad = false;
         if (!initialLoad) {
             isInitialLoad = true;
-            initialLoad = JSON.parse(JSON.stringify(newNodes));
+            initialLoad = JSON.parse(JSON.stringify(originalNodes));
         }
-       
-        const unknownTypes = identifyUnknowType(newNodes, { emitNotification: isInitialLoad });
+
+        const unknownTypes = identifyUnknowType(originalNodes, { emitNotification: isInitialLoad });
 
         const nodeZmap = {};
-        let recoveryWorkspace;
-        for (let node of newNodes) {
+        let recoveryWorkspace = null;
+        let missingWorkspace = null;
+        for (const node of originalNodes) {
             if (node.z) {
                 nodeZmap[node.z] = nodeZmap[node.z] || [];
                 nodeZmap[node.z].push(node);
-            } else if (isInitialLoad && node.hasOwnProperty('x') && node.hasOwnProperty('y') && !node.z) {
+            } else if (isInitialLoad && node.hasOwnProperty('x') && node.hasOwnProperty('y')) {
                 // Hit the rare issue where node z values get set to 0.
                 // Repair the flow - but we really need to track that down.
                 if (!recoveryWorkspace) {
@@ -1948,265 +2146,127 @@ RED.nodes = (function() {
             }
         }
 
-    
-        var i;
-        var n;
-
-
-        var new_workspaces = [];
-        var workspace_map = {};
-        var new_subflows = [];
-        var subflow_map = {};
-        var subflow_denylist = {};
-        var node_map = {};
-        var new_nodes = [];
-        var new_links = [];
-        var new_groups = [];
-        var new_junctions = [];
-        var new_group_set = new Set();
-        var nid;
-        var def;
-        var configNode;
-        var missingWorkspace = null;
-        var d;
+        // TODO
+        const subflow_denylist = {};
 
+        const newWorkspaces = [];
         if (recoveryWorkspace) {
-            new_workspaces.push(recoveryWorkspace);
+            newWorkspaces.push(recoveryWorkspace);
+            const notification = RED.notify(RED._("clipboard.recoveredNodesNotification", { flowName: RED._("clipboard.recoveredNodes") }), {
+                type: "warning",
+                fixed: true,
+                buttons: [
+                    { text: RED._("common.label.close"), click: function() { notification.close(); } }
+                ]
+            });
         }
 
-        // Find all tabs and subflow templates
-        for (i=0;i<newNodes.length;i++) {
-            n = newNodes[i];
+        const subflowMap = {};
+        const workspaceMap = {};
+        const newSubflows = [];
+        // Find all tabs and subflow tabs and add it to workspace
+        // NOTE: Subflow tab not the instance
+        for (const node of originalNodes) {
+            const oldId = node.id;
+
             // TODO: remove workspace in next release+1
-            if (n.type === "workspace" || n.type === "tab") {
-                if (n.type === "workspace") {
-                    n.type = "tab";
+            if (node.type === "workspace" || node.type === "tab") {
+                // Legacy type
+                if (node.type === "workspace") {
+                    node.type = "tab";
                 }
+                // The flow being sorted, the first workspace is supposed to be the default
                 if (defaultWorkspace == null) {
-                    defaultWorkspace = n;
+                    defaultWorkspace = node;
                 }
-                if (activeWorkspace === 0) {
-                    activeWorkspace = n.id;
+                if (activeWorkspace === 0) {    // TODO: Why?
+                    activeWorkspace = node.id;
                 }
-                if (createNewIds || options.importMap[n.id] === "copy") {
-                    nid = getID();
-                    workspace_map[n.id] = nid;
-                    n.id = nid;
-                } else {
-                    workspace_map[n.id] = n.id;
+                if (createNewIds || options.importMap[node.id] === "copy") {
+                    node.id = getID();
                 }
-                addWorkspace(n);
-                RED.workspaces.add(n);
-                new_workspaces.push(n);
-            } else if (n.type === "subflow") {
-                var matchingSubflow;
-                if (!options.importMap[n.id]) {
-                    matchingSubflow = checkForMatchingSubflow(n,nodeZmap[n.id]);
+                addWorkspace(node);
+                workspaceMap[oldId] = node.id;
+                newWorkspaces.push(node);
+                RED.workspaces.add(node);
+            } else if (node.type === "subflow") {
+                let matchingSubflow;
+
+                // TODO: Toujours lié à node.z ?
+                if (!options.importMap[node.id]) {
+                    matchingSubflow = checkForMatchingSubflow(node, nodeZmap[node.id]);
                 }
                 if (matchingSubflow) {
-                    subflow_denylist[n.id] = matchingSubflow;
+                    subflow_denylist[node.id] = matchingSubflow;
                 } else {
-                    subflow_map[n.id] = n;
-                    if (createNewIds || options.importMap[n.id] === "copy") {
-                        nid = getID();
-                        n.id = nid;
-                    }
-                    // TODO: handle createNewIds - map old to new subflow ids
-                    n.in.forEach(function(input,i) {
+                    node.in.forEach(function(input, i) {
                         input.type = "subflow";
                         input.direction = "in";
-                        input.z = n.id;
+                        input.z = node.id;
                         input.i = i;
                         input.id = getID();
                     });
-                    n.out.forEach(function(output,i) {
+                    node.out.forEach(function(output, i) {
                         output.type = "subflow";
                         output.direction = "out";
-                        output.z = n.id;
+                        output.z = node.id;
                         output.i = i;
                         output.id = getID();
                     });
-                    if (n.status) {
-                        n.status.type = "subflow";
-                        n.status.direction = "status";
-                        n.status.z = n.id;
-                        n.status.id = getID();
+                    if (node.status) {
+                        node.status.type = "subflow";
+                        node.status.direction = "status";
+                        node.status.z = node.id;
+                        node.status.id = getID();
                     }
-                    new_subflows.push(n);
-                    addSubflow(n,createNewIds || options.importMap[n.id] === "copy");
+                    if (createNewIds || options.importMap[node.id] === "copy") {
+                        node.id = getID();
+                    }
+                    subflowMap[oldId] = node;
+                    newSubflows.push(node);
+                    addSubflow(node, (createNewIds || options.importMap[node.id] === "copy"));
                 }
             }
         }
 
-        // Add a tab if there isn't one there already
-        if (defaultWorkspace == null) {
-            defaultWorkspace = { type:"tab", id:getID(), disabled: false, info:"",  label:RED._('workspace.defaultName',{number:1}), env:[]};
+        // Add a tab if there isn't one there already - Like first install
+        if (!defaultWorkspace) {
+            defaultWorkspace = { type: "tab", id: getID(), disabled: false, info: "",  label: RED._("workspace.defaultName", { number: 1 }), env: [] };
             addWorkspace(defaultWorkspace);
             RED.workspaces.add(defaultWorkspace);
-            new_workspaces.push(defaultWorkspace);
+            newWorkspaces.push(defaultWorkspace);
             activeWorkspace = RED.workspaces.active();
         }
 
-        // Find all config nodes and add them
-        for (i=0;i<newNodes.length;i++) {
-            n = newNodes[i];
-            def = registry.getNodeType(n.type);
-            if (def && def.category == "config") {
-                var existingConfigNode = null;
-                if (createNewIds || options.importMap[n.id] === "copy") {
-                    if (n.z) {
-                        if (subflow_denylist[n.z]) {
-                            continue;
-                        } else if (subflow_map[n.z]) {
-                            n.z = subflow_map[n.z].id;
-                        } else {
-                            n.z = workspace_map[n.z];
-                            if (!workspaces[n.z]) {
-                                if (createMissingWorkspace) {
-                                    if (missingWorkspace === null) {
-                                        missingWorkspace = RED.workspaces.add(null,true);
-                                        new_workspaces.push(missingWorkspace);
-                                    }
-                                    n.z = missingWorkspace.id;
-                                } else {
-                                    n.z = activeWorkspace;
-                                }
-                            }
-                        }
-                    }
-                    if (options.importMap[n.id] !== "copy") {
-                        existingConfigNode = RED.nodes.node(n.id);
-                        if (existingConfigNode) {
-                            if (n.z && existingConfigNode.z !== n.z) {
-                                existingConfigNode = null;
-                                // Check the config nodes on n.z
-                                for (var cn in configNodes) {
-                                    if (configNodes.hasOwnProperty(cn)) {
-                                        if (configNodes[cn].z === n.z && compareNodes(configNodes[cn],n,false)) {
-                                            existingConfigNode = configNodes[cn];
-                                            node_map[n.id] = configNodes[cn];
-                                            break;
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                } else {
-                    const keepNodesCurrentZ = reimport && n.z && (RED.workspaces.contains(n.z) || RED.nodes.subflow(n.z))
-                    if (!keepNodesCurrentZ && n.z && !workspace_map[n.z] && !subflow_map[n.z]) {
-                        n.z = activeWorkspace;
-                    }
-                }
+        const nodeMap = {};
+        const newNodes = [];
+        const newGroups = [];
+        const newJunctions = [];
+        // Find all Config Nodes, Groups, Junctions, Nodes and Subflow instances and add them
+        // NOTE: Replaced Config Nodes and Subflow instances no longer appear below
+        for (const node of originalNodes) {
+            const def = registry.getNodeType(node.type);
+            const isConfigNode = def?.category === "config";
+            const oldId = node.id;
 
-                if (!existingConfigNode || existingConfigNode._def.exclusive) { //} || !compareNodes(existingConfigNode,n,true) || existingConfigNode.z !== n.z) {
-                    configNode = {
-                        id:n.id,
-                        z:n.z,
-                        type:n.type,
-                        info: n.info,
-                        users:[],
-                        _config:{}
-                    };
-                    if (!n.z) {
-                        delete configNode.z;
-                    }
-                    if (options.markChanged) {
-                        configNode.changed = true
-                    }
-                    if (n.hasOwnProperty('d')) {
-                        configNode.d = n.d;
-                    }
-                    for (d in def.defaults) {
-                        if (def.defaults.hasOwnProperty(d)) {
-                            configNode[d] = n[d];
-                            configNode._config[d] = JSON.stringify(n[d]);
-                        }
-                    }
-                    if (def.hasOwnProperty('credentials') && n.hasOwnProperty('credentials')) {
-                        configNode.credentials = {};
-                        for (d in def.credentials) {
-                            if (def.credentials.hasOwnProperty(d) && n.credentials.hasOwnProperty(d)) {
-                                configNode.credentials[d] = n.credentials[d];
-                            }
-                        }
-                    }
-                    configNode.label = def.label;
-                    configNode._def = def;
-                    if (createNewIds || options.importMap[n.id] === "copy") {
-                        configNode.id = getID();
-                    }
-                    node_map[n.id] = configNode;
-                    new_nodes.push(configNode);
-                }
-            }
-        }
-
-        // Find regular flow nodes and subflow instances
-        for (i=0;i<newNodes.length;i++) {
-            n = newNodes[i];
             // TODO: remove workspace in next release+1
-            if (n.type !== "workspace" && n.type !== "tab" && n.type !== "subflow") {
-                def = registry.getNodeType(n.type);
-                if (!def || def.category != "config") {
-                    var node = {
-                        x:parseFloat(n.x || 0),
-                        y:parseFloat(n.y || 0),
-                        z:n.z,
-                        type:0,
-                        info: n.info,
-                        changed:false,
-                        _config:{}
-                    }
-                    if (n.type !== "group" && n.type !== 'junction') {
-                        node.wires = n.wires||[];
-                        node.inputLabels = n.inputLabels;
-                        node.outputLabels = n.outputLabels;
-                        node.icon = n.icon;
-                    }
-                    if (n.type === 'junction') {
-                        node.wires = n.wires||[];
-                    }
-                    if (n.hasOwnProperty('l')) {
-                        node.l = n.l;
-                    }
-                    if (n.hasOwnProperty('d')) {
-                        node.d = n.d;
-                    }
-                    if (n.hasOwnProperty('g')) {
-                        node.g = n.g;
-                    }
-                    if (options.markChanged) {
-                        node.changed = true
-                    }
-                    if (createNewIds || options.importMap[n.id] === "copy") {
-                        if (subflow_denylist[n.z]) {
-                            continue;
-                        } else if (subflow_map[node.z]) {
-                            node.z = subflow_map[node.z].id;
-                        } else {
-                            node.z = workspace_map[node.z];
-                            if (!workspaces[node.z]) {
-                                if (createMissingWorkspace) {
-                                    if (missingWorkspace === null) {
-                                        missingWorkspace = RED.workspaces.add(null,true);
-                                        new_workspaces.push(missingWorkspace);
-                                    }
-                                    node.z = missingWorkspace.id;
-                                } else {
-                                    node.z = activeWorkspace;
-                                }
-                            }
-                        }
-                        node.id = getID();
+            if (node.type === "workspace" || node.type === "tab" || node.type === "subflow") { continue; }
+
+            // TODO: Fixes weird thing with `node.z`
+            if (createNewIds || options.importMap[oldId] === "copy") {
+                // Config Node can have an undefined `node.z`
+                if (!isConfigNode || (isConfigNode && node.z)) {
+                    if (subflow_denylist[node.z]) {
+                        continue;
+                    } else if (subflowMap[node.z]) {
+                        node.z = subflowMap[node.z].id;
                     } else {
-                        node.id = n.id;
-                        const keepNodesCurrentZ = reimport && node.z && (RED.workspaces.contains(node.z) || RED.nodes.subflow(node.z))
-                        if (!keepNodesCurrentZ && (node.z == null || (!workspace_map[node.z] && !subflow_map[node.z]))) {
+                        node.z = workspaceMap[node.z];
+                        if (!workspaces[node.z]) {
                             if (createMissingWorkspace) {
                                 if (missingWorkspace === null) {
-                                    missingWorkspace = RED.workspaces.add(null,true);
-                                    new_workspaces.push(missingWorkspace);
+                                    missingWorkspace = RED.workspaces.add(null, true);
+                                    newWorkspaces.push(missingWorkspace);
                                 }
                                 node.z = missingWorkspace.id;
                             } else {
@@ -2214,267 +2274,237 @@ RED.nodes = (function() {
                             }
                         }
                     }
-                    node.type = n.type;
-                    node._def = def;
-                    if (node.type === "group") {
-                        node._def = RED.group.def;
-                        for (d in node._def.defaults) {
-                            if (node._def.defaults.hasOwnProperty(d) && d !== 'inputs' && d !== 'outputs') {
-                                node[d] = n[d];
-                                node._config[d] = JSON.stringify(n[d]);
-                            }
-                        }
-                        node._config.x = node.x;
-                        node._config.y = node.y;
-                        if (n.hasOwnProperty('w')) {
-                            node.w = n.w
-                        }
-                        if (n.hasOwnProperty('h')) {
-                            node.h = n.h
-                        }
-                    } else if (n.type.substring(0,7) === "subflow") {
-                        var parentId = n.type.split(":")[1];
-                        var subflow = subflow_denylist[parentId]||subflow_map[parentId]||getSubflow(parentId);
-                        if (!subflow){
-                            node._def = {
-                                color:"#fee",
-                                defaults: {},
-                                label: "unknown: "+n.type,
-                                labelStyle: "red-ui-flow-node-label-italic",
-                                outputs: n.outputs|| (n.wires && n.wires.length) || 0,
-                                set: registry.getNodeSet("node-red/unknown")
-                            }
-                        } else {
-                            if (subflow_denylist[parentId] || createNewIds || options.importMap[n.id] === "copy") {
-                                parentId = subflow.id;
-                                node.type = "subflow:"+parentId;
-                                node._def = registry.getNodeType(node.type);
-                                delete node.i;
-                            }
-                            node.name = n.name;
-                            node.outputs = subflow.out.length;
-                            node.inputs = subflow.in.length;
-                            node.env = n.env;
-                        }
-                    } else if (n.type === 'junction') {
-                         node._def = {defaults:{}}
-                         node._config.x = node.x
-                         node._config.y = node.y
-                         node.inputs = 1
-                         node.outputs = 1
-                         node.w = 0;
-                         node.h = 0;
+                }
+            } else {
+                const keepNodesCurrentZ = reimport && node.z && (RED.workspaces.contains(node.z) || RED.nodes.subflow(node.z));
 
-                    } else {
-                        if (!node._def) {
-                            if (node.x && node.y) {
-                                node._def = {
-                                    color:"#fee",
-                                    defaults: {},
-                                    label: "unknown: "+n.type,
-                                    labelStyle: "red-ui-flow-node-label-italic",
-                                    outputs: n.outputs|| (n.wires && n.wires.length) || 0,
-                                    set: registry.getNodeSet("node-red/unknown")
-                                }
-                            } else {
-                                node._def = {
-                                    category:"config",
-                                    set: registry.getNodeSet("node-red/unknown")
-                                };
-                                node.users = [];
-                                // This is a config node, so delete the default
-                                // non-config node properties
-                                delete node.x;
-                                delete node.y;
-                                delete node.wires;
-                                delete node.inputLabels;
-                                delete node.outputLabels;
-                                if (!n.z) {
-                                    delete node.z;
-                                }
-                            }
-                            var orig = {};
-                            for (var p in n) {
-                                if (n.hasOwnProperty(p) && p!="x" && p!="y" && p!="z" && p!="id" && p!="wires") {
-                                    orig[p] = n[p];
-                                }
-                            }
-                            node._orig = orig;
-                            node.name = n.type;
-                            node.type = "unknown";
+                if (isConfigNode && !keepNodesCurrentZ && node.z && !workspaceMap[node.z] && !subflowMap[node.z]) {
+                    node.z = activeWorkspace;
+                } else if (!isConfigNode && !keepNodesCurrentZ && (node.z == null || (!workspaceMap[node.z] && !subflowMap[node.z]))) {
+                    // TODO: Encore ?
+                    if (createMissingWorkspace) {
+                        if (missingWorkspace === null) {
+                            missingWorkspace = RED.workspaces.add(null,true);
+                            newWorkspaces.push(missingWorkspace);
                         }
-                        if (node._def.category != "config") {
-                            if (n.hasOwnProperty('inputs')) {
-                                node.inputs = n.inputs;
-                                node._config.inputs = JSON.stringify(n.inputs);
-                            } else {
-                                node.inputs = node._def.inputs;
-                            }
-                            if (n.hasOwnProperty('outputs')) {
-                                node.outputs = n.outputs;
-                                node._config.outputs = JSON.stringify(n.outputs);
-                            } else {
-                                node.outputs = node._def.outputs;
-                            }
-                            if (node.hasOwnProperty('wires') && node.wires.length > node.outputs) {
-                                if (!node._def.defaults.hasOwnProperty("outputs") || !isNaN(parseInt(n.outputs))) {
-                                    // If 'wires' is longer than outputs, clip wires
-                                    console.log("Warning: node.wires longer than node.outputs - trimming wires:",node.id," wires:",node.wires.length," outputs:",node.outputs);
-                                    node.wires = node.wires.slice(0,node.outputs);
-                                } else {
-                                    // The node declares outputs in its defaults, but has not got a valid value
-                                    // Defer to the length of the wires array
-                                    node.outputs = node.wires.length;
-                                }
-                            }
-                            for (d in node._def.defaults) {
-                                if (node._def.defaults.hasOwnProperty(d) && d !== 'inputs' && d !== 'outputs') {
-                                    node[d] = n[d];
-                                    node._config[d] = JSON.stringify(n[d]);
-                                }
-                            }
-                            node._config.x = node.x;
-                            node._config.y = node.y;
-                            if (node._def.hasOwnProperty('credentials') && n.hasOwnProperty('credentials')) {
-                                node.credentials = {};
-                                for (d in node._def.credentials) {
-                                    if (node._def.credentials.hasOwnProperty(d) && n.credentials.hasOwnProperty(d)) {
-                                        node.credentials[d] = n.credentials[d];
+                        node.z = missingWorkspace.id;
+                    } else {
+                        node.z = activeWorkspace;
+                    }
+                }
+            }
+
+            // Config Node
+            if (isConfigNode) {
+                // TODO: A quoi sert ce bloc ? Replace?
+                let existingConfigNode;
+                if (createNewIds || options.importMap[oldId] === "copy") {
+                    if (options.importMap[oldId] !== "copy") {
+                        existingConfigNode = RED.nodes.node(oldId);
+                        if (existingConfigNode) {
+                            if (node.z && existingConfigNode.z !== node.z) {
+                                existingConfigNode = null;
+                                // Check the config nodes on n.z
+                                // TODO: pourquoi utiliser z au lieu de l'id ?
+                                for (var cn in configNodes) {
+                                    if (configNodes.hasOwnProperty(cn)) {
+                                        if (configNodes[cn].z === node.z && compareNodes(configNodes[cn], node, false)) {
+                                            existingConfigNode = configNodes[cn];
+                                            nodeMap[oldId] = configNodes[cn];
+                                            break;
+                                        }
                                     }
                                 }
                             }
                         }
                     }
-                    node_map[n.id] = node;
-                    // If an 'unknown' config node, it will not have been caught by the
-                    // proper config node handling, so needs adding to new_nodes here
-                    if (node.type === 'junction') {
-                        new_junctions.push(node)
-                    } else if (node.type === "unknown" || node._def.category !== "config") {
-                        new_nodes.push(node);
-                    } else if (node.type === "group") {
-                        new_groups.push(node);
-                        new_group_set.add(node.id);
-                    }
                 }
+                if (!existingConfigNode || existingConfigNode._def.exclusive) { //} || !compareNodes(existingConfigNode,n,true) || existingConfigNode.z !== n.z) {
+                    nodeMap[oldId] = copyConfigNode(node, def, options);
+                }
+                //nodeMap[oldId] = copyConfigNode(node, def, options);
+            // Node, Group, Junction or Subflow
+            } else if (def || node.type === "group") {
+                nodeMap[oldId] = copyNode(node, def, options);
+            // Unknown Node
+            } else {
+                // Config Node
+                if (!node.x && !node.y) {
+                    node._def = {
+                        category: "config",
+                        set: registry.getNodeSet("node-red/unknown")
+                    };
+                } else {
+                    node._def = {
+                        color: "#fee",
+                        defaults: {},
+                        label: "unknown: " + node.type,
+                        labelStyle: "red-ui-flow-node-label-italic",
+                        outputs: node.outputs ?? node.wires?.length ?? 0,
+                        set: registry.getNodeSet("node-red/unknown")
+                    };
+                }
+                const propertiesNotCopyable = ["x", "y", "z", "id", "wires"];
+                node._orig = Object.entries(node).reduce(function (orig, [prop, value]) {
+                    if (node.hasOwnProperty(prop) && !propertiesNotCopyable.includes(prop)) {
+                        orig[prop] = value;
+                    }
+                    return orig;
+                }, {});
+                node.name = node.type;
+                node.type = "unknown";
+                nodeMap[oldId] = node;
+            }
+
+            // Now the properties have been copied, change the `id` if it's a copy
+            if (createNewIds || options.importMap[oldId] === "copy") {
+                nodeMap[oldId].id = getID();
+            }
+
+            if (node.type === "junction") {
+                newJunctions.push(nodeMap[oldId])
+            } else if (node.type === "group") {
+                newGroups.push(nodeMap[oldId]);
+            } else {
+                newNodes.push(nodeMap[oldId]);
             }
         }
 
-        // Remap all wires and config node references
-        for (i=0;i<new_nodes.length+new_junctions.length;i++) {
-            if (i<new_nodes.length) {
-                n = new_nodes[i];
-            } else {
-                n = new_junctions[i - new_nodes.length]
+        // Update Users Count
+        // NOTE: the only reliable way to get the right number is to scan all the nodes
+        // Replacing a Config Node overwrites the list giving a wrong number
+        allNodes.eachNode(function (node) {
+            const def = registry.getNodeType(node.type);
+            if (def?.category === "config") {
+                node.users = [];
             }
-            if (n.wires) {
-                for (var w1=0;w1<n.wires.length;w1++) {
-                    var wires = (Array.isArray(n.wires[w1]))?n.wires[w1]:[n.wires[w1]];
-                    for (var w2=0;w2<wires.length;w2++) {
-                        if (node_map.hasOwnProperty(wires[w2])) {
-                            if (n.z === node_map[wires[w2]].z) {
-                                var link = {source:n,sourcePort:w1,target:node_map[wires[w2]]};
-                                addLink(link);
-                                new_links.push(link);
-                            } else {
-                                console.log("Warning: dropping link that crosses tabs:",n.id,"->",node_map[wires[w2]].id);
-                            }
+        });
+        allNodes.eachNode(function (node) {
+            // The event will be triggered after the import
+            updateConfigNodeUsers(node, { emitEvent: false });
+        });
+
+        const newLinks = [];
+        // Remap all wires and (Config) Node references
+        for (const node of [...newNodes, ...newGroups]) {
+            if (node.wires) {
+                for (const wiresGroup of node.wires) {
+                    const wires = Array.isArray(wiresGroup) ? wiresGroup : [wiresGroup];
+                    wires.forEach(function (wire) {
+                        // Skip if the wire is clinked to a non-existent node
+                        // TODO: Add warning message? Add RED.nodes.node() for same workspace?
+                        if (!nodeMap.hasOwnProperty(wire)) { return; }
+                        if (node.z === nodeMap[wire].z) {
+                            const link = { source: node, sourcePort: node.wires.indexOf(wiresGroup), target: nodeMap[wire] };
+                            addLink(link);
+                            newLinks.push(link);
+                        } else {
+                            console.log("Warning: dropping link that crosses tabs:", node.id, "->", nodeMap[wire].id);
                         }
-                    }
+                    });
                 }
-                delete n.wires;
+                delete node.wires;
             }
-            if (n.g && node_map[n.g]) {
-                n.g = node_map[n.g].id;
+
+            if (node.g && nodeMap[node.g]) {
+                node.g = nodeMap[node.g].id;
             } else {
-                delete n.g
+                delete node.g;
             }
-            for (var d3 in n._def.defaults) {
-                if (n._def.defaults.hasOwnProperty(d3)) {
-                    if (n._def.defaults[d3].type) {
-                        var nodeList = n[d3];
-                        if (!Array.isArray(nodeList)) {
-                            nodeList = [nodeList];
-                        }
-                        nodeList = nodeList.map(function(id) {
-                            var node = node_map[id];
-                            if (node) {
-                                if (node._def.category === 'config') {
-                                    if (node.users.indexOf(n) === -1) {
-                                        node.users.push(n);
-                                    }
-                                }
-                                return node.id;
-                            }
-                            return id;
-                        })
-                        n[d3] = Array.isArray(n[d3])?nodeList:nodeList[0];
-                    }
-                }
-            }
-            // If importing into a subflow, ensure an outbound-link doesn't
-            // get added
-            if (activeSubflow && /^link /.test(n.type) && n.links) {
-                n.links = n.links.filter(function(id) {
-                    const otherNode = node_map[id] || RED.nodes.node(id);
-                    return (otherNode && otherNode.z === activeWorkspace)
+
+            // If importing into a subflow, ensure an outbound-link doesn't get added
+            if (activeSubflow && /^link /.test(node.type) && node.links) {
+                node.links = node.links.filter(function (id) {
+                    const otherNode = nodeMap[id] || RED.nodes.node(id);
+                    return (otherNode?.z === activeWorkspace);
                 });
             }
+
+            // Update the old Node Id with the new one
+            for (const d in node._def.defaults) {
+                // Config Node, Node or Links (not sure)
+                if (node._def.defaults.hasOwnProperty(d) && node._def.defaults[d].type) {
+                    let nodeList = node[d];
+
+                    if (!Array.isArray(nodeList)) {
+                        nodeList = [nodeList];
+                    }
+                    nodeList = nodeList.map(function(id) {
+                        const n = nodeMap[id];
+                        if (n) {
+                            if (n._def.category === "config") {
+                                if (n.users.indexOf(node) === -1) {
+                                    n.users.push(node);
+                                }
+                            }
+                            return n.id;
+                        }
+                        return id;
+                    });
+
+                    node[d] = Array.isArray(node[d]) ? nodeList : nodeList[0];
+                }
+            }
         }
-        for (i=0;i<new_subflows.length;i++) {
-            n = new_subflows[i];
-            n.in.forEach(function(input) {
-                input.wires.forEach(function(wire) {
-                    var link = {source:input, sourcePort:0, target:node_map[wire.id]};
+
+        for (const subflow of newSubflows) {
+            subflow.in.forEach(function (input) {
+                input.wires.forEach(function (wire) {
+                    const link = { source: input, sourcePort: 0, target: nodeMap[wire.id] };
                     addLink(link);
-                    new_links.push(link);
+                    newLinks.push(link);
                 });
                 delete input.wires;
             });
-            n.out.forEach(function(output) {
-                output.wires.forEach(function(wire) {
-                    var link;
-                    if (subflow_map[wire.id] && subflow_map[wire.id].id == n.id) {
-                        link = {source:n.in[wire.port], sourcePort:wire.port,target:output};
+
+            subflow.out.forEach(function (output) {
+                output.wires.forEach(function (wire) {
+                    let link;
+                    if (subflowMap[wire.id] && subflowMap[wire.id].id === subflow.id) {
+                        link = { source: subflow.in[wire.port], sourcePort: wire.port, target: output };
                     } else {
-                        link = {source:node_map[wire.id]||subflow_map[wire.id], sourcePort:wire.port,target:output};
+                        link = { source: nodeMap[wire.id] || subflowMap[wire.id], sourcePort: wire.port, target: output };
                     }
                     addLink(link);
-                    new_links.push(link);
+                    newLinks.push(link);
                 });
                 delete output.wires;
             });
-            if (n.status) {
-                n.status.wires.forEach(function(wire) {
-                    var link;
-                    if (subflow_map[wire.id] && subflow_map[wire.id].id == n.id) {
-                        link = {source:n.in[wire.port], sourcePort:wire.port,target:n.status};
-                    } else {
-                        link = {source:node_map[wire.id]||subflow_map[wire.id], sourcePort:wire.port,target:n.status};
-                    }
-                    addLink(link);
-                    new_links.push(link);
-                });
-                delete n.status.wires;
+
+            subflow.status?.wires.forEach(function (wire) {
+                let link;
+                if (subflowMap[wire.id] && subflowMap[wire.id].id === subflow.id) {
+                    link = { source: subflow.in[wire.port], sourcePort: wire.port, target: subflow.status };
+                } else {
+                    link = { source: subflowMap[wire.id] || subflowMap[wire.id], sourcePort: wire.port, target: subflow.status };
+                }
+                addLink(link);
+                newLinks.push(link);
+            });
+
+            if (subflow.status) {
+                delete subflow.status.wires;
             }
         }
+
         // Order the groups to ensure they are outer-most to inner-most
         var groupDepthMap = {};
-        for (i=0;i<new_groups.length;i++) {
-            n = new_groups[i];
-
-            if (n.g && !new_group_set.has(n.g)) {
-                delete n.g;
+        const groupsId = newGroups.map(function (group) { return group.id; });
+        for (const group of newGroups) {
+            if (group.g && !groupsId.includes(group.g)) {
+                delete group.g;
             }
-            if (!n.g) {
-                groupDepthMap[n.id] = 0;
+            if (!group.g) {
+                groupDepthMap[group.id] = 0;
             }
         }
+
+        // TODO: C'est quoi ce brol ?
         var changedDepth;
         do {
             changedDepth = false;
-            for (i=0;i<new_groups.length;i++) {
-                n = new_groups[i];
+            for (let i=0;i<newGroups.length;i++) {
+                const n = newGroups[i];
                 if (n.g) {
                     if (groupDepthMap[n.id] !== groupDepthMap[n.g] + 1) {
                         groupDepthMap[n.id] = groupDepthMap[n.g] + 1;
@@ -2484,90 +2514,86 @@ RED.nodes = (function() {
             }
         } while(changedDepth);
 
-        new_groups.sort(function(A,B) {
-            return groupDepthMap[A.id] - groupDepthMap[B.id];
+        console.log("GROUP", groupDepthMap);
+
+        newGroups.sort(function(a, b) {
+            return (groupDepthMap[a.id] - groupDepthMap[b.id]);
         });
-        for (i=0;i<new_groups.length;i++) {
-            new_groups[i] = addGroup(new_groups[i]);
-            node_map[new_groups[i].id] = new_groups[i]
+
+        for (const index in newGroups) {
+            if (newGroups.hasOwnProperty(newGroups[index])) {
+                newGroups[index] = addGroup(newGroups[index]);
+                nodeMap[newGroups[index].id] = newGroups[index];
+            }
         }
 
-        for (i=0;i<new_junctions.length;i++) {
-            new_junctions[i] = addJunction(new_junctions[i]);
-            node_map[new_junctions[i].id] = new_junctions[i]
+        for (const index in newJunctions) {
+            if (newJunctions.hasOwnProperty(newJunctions[index])) {
+                newJunctions[index] = addJunction(newJunctions[index]);
+                nodeMap[newJunctions[index].id] = newJunctions[index];
+            }
         }
 
-
-        // Now the nodes have been fully updated, add them.
-        for (i=0;i<new_nodes.length;i++) {
-            new_nodes[i] = addNode(new_nodes[i])
-            node_map[new_nodes[i].id] = new_nodes[i]
+        // Now the nodes have been fully updated, add them as Proxy.
+        for (const index in newNodes) {
+            if (newNodes.hasOwnProperty(newNodes[index])) {
+                newNodes[index] = addNode(newNodes[index]);
+                nodeMap[newNodes[index].id] = newNodes[index];
+            }
         }
 
-        // Finally validate them all.
-        // This has to be done after everything is added so that any checks for
-        // dependent config nodes will pass
-        for (i=0;i<new_nodes.length;i++) {
-            var node = new_nodes[i];
+        // Finally validate all Nodes.
+        for (const node of newNodes) {
             RED.editor.validateNode(node);
         }
+
         const lookupNode = (id) => {
-            const mappedNode = node_map[id]
+            const mappedNode = nodeMap[id];
             if (!mappedNode) {
-                return null
+                return null;
             }
             if (mappedNode.__isProxy__) {
-                return mappedNode
+                return mappedNode;
             } else {
-                return node_map[mappedNode.id]
+                return nodeMap[mappedNode.id];
             }
-        }
+        };
+
         // Update groups to reference proxy node objects
-        for (i=0;i<new_groups.length;i++) {
-            n = new_groups[i];
+        for (const group of newGroups) {
             // bypass the proxy in case the flow is locked
-            n.__node__.nodes = n.nodes.map(lookupNode)
+            group.__node__.nodes = group.nodes.map(lookupNode);
             // Just in case the group references a node that doesn't exist for some reason
-            n.__node__.nodes = n.nodes.filter(function(v) {
-                if (v) {
+            group.__node__.nodes = group.nodes.filter(function (n) {
+                if (n) {
                     // Repair any nodes that have forgotten they are in this group
-                    if (v.g !== n.id) {
-                        v.g = n.id;
+                    if (n.g !== group.id) {
+                        n.g = group.id;
                     }
                 }
-                return !!v
+                return !!n;
             });
         }
 
         // Update links to use proxy node objects
-        for (i=0;i<new_links.length;i++) {
-            new_links[i].source = lookupNode(new_links[i].source.id) || new_links[i].source
-            new_links[i].target = lookupNode(new_links[i].target.id) || new_links[i].target
+        for (const link of newLinks) {
+            link.source = lookupNode(link.source.id) || link.source;
+            link.target = lookupNode(link.target.id) || link.target;
         }
 
+        // TODO: Right place?
         RED.workspaces.refresh();
 
-
-        if (recoveryWorkspace) {
-            var notification = RED.notify(RED._("clipboard.recoveredNodesNotification",{flowName:RED._("clipboard.recoveredNodes")}),{
-                type:"warning",
-                fixed:true,
-                buttons: [
-                    {text: RED._("common.label.close"), click: function() { notification.close() }}
-                ]
-            });
-        }
-
         return {
-            nodes:new_nodes,
-            links:new_links,
-            groups:new_groups,
-            junctions: new_junctions,
-            workspaces:new_workspaces,
-            subflows:new_subflows,
+            nodes: newNodes,
+            links: newLinks,
+            groups: newGroups,
+            junctions: newJunctions,
+            workspaces: newWorkspaces,
+            subflows: newSubflows,
             missingWorkspace: missingWorkspace,
             removedNodes: removedNodes
-        }
+        };
     }
 
     // TODO: supports filter.z|type
@@ -2633,7 +2659,10 @@ RED.nodes = (function() {
     }
 
     // Update any config nodes referenced by the provided node to ensure their 'users' list is correct
-    function updateConfigNodeUsers(n) {
+    function updateConfigNodeUsers(n, options) {
+        const defaultOptions = { emitEvent: true };
+        options = Object.assign({}, defaultOptions, options);
+
         for (var d in n._def.defaults) {
             if (n._def.defaults.hasOwnProperty(d)) {
                 var property = n._def.defaults[d];
@@ -2644,7 +2673,9 @@ RED.nodes = (function() {
                         if (configNode) {
                             if (configNode.users.indexOf(n) === -1) {
                                 configNode.users.push(n);
-                                RED.events.emit('nodes:change',configNode)
+                                if (options.emitEvent) {
+                                    RED.events.emit('nodes:change', configNode);
+                                }
                             }
                         }
                     }
diff --git a/packages/node_modules/@node-red/editor-client/src/js/ui/view.js b/packages/node_modules/@node-red/editor-client/src/js/ui/view.js
index e71478457..733659f29 100644
--- a/packages/node_modules/@node-red/editor-client/src/js/ui/view.js
+++ b/packages/node_modules/@node-red/editor-client/src/js/ui/view.js
@@ -5618,12 +5618,9 @@ RED.view = (function() {
      *                           default names
      */
     function importNodes(newNodesObj,options) {
-        options = options || {
-            addFlow: false,
-            touchImport: false,
-            generateIds: false,
-            generateDefaultNames: false
-        }
+        const defaultOptions = { generateIds: false, addFlow: false, touchImport: false, generateDefaultNames: false, importMap: {} };
+        options = Object.assign({}, defaultOptions, options);
+
         var addNewFlow = options.addFlow
         var touchImport = options.touchImport;