imapkit 0.0.0-stage → 4.0.0

package/bin/help.txt

@@ -0,0 +1,98 @@
+ImapKit (v__VERSION__)
+==========__VBAR__=
+ImapKit starts an IMAP server that is suitable for running client
+integration tests. Nothing is written to disk, all operations are
+performed on memory and the changes are lost after restart, so the
+initial state is always guaranteed when running your tests.
+
+Additionally ImapKit offers an incoming SMTP server - every mail
+sent to it, is appended to INBOX. To use the incoming SMTP server,
+use smtpPort option.
+
+Usage: imapkit [OPTS]
+
+  -p <port>, --port=<port> Port number to listen to, defaults to 143
+  -s, --secure=true        Starts a secure server, defaults port to 993
+  -d, --debug=true         Writes IMAP traffic to console
+  --storage=<path>         Path to JSON file with the directory tree
+  --config=<config>        Path to config JSON file
+  --plugin=<plugin>        Enables a plugin for the server. See below for
+                           available plugins.
+  --smtpPort=<port>        Port number for incoming SMTP server. If not set
+                           SMTP server is not started.
+
+The options can also be set with environment variables: IMAPKIT_PORT,
+IMAPKIT_SECURE, IMAPKIT_DEBUG, IMAPKIT_STORAGE, IMAPKIT_CONFIG,
+IMAPKIT_PLUGINS (comma separated) and IMAPKIT_SMTPPORT.
+
+NB! If port or smtpPort values are below 1024 you most probably need to
+use sudo or run the command in Administrator rights.
+
+Available plugins
+-----------------
+
+Usage: imapkit [OPTS] --plugin=ID --plugin=IDLE
+or:    imapkit [OPTS] --plugin=ID,IDLE
+
+__PLUGINS__
+
+Configuration files
+-------------------
+
+Configuration file takes the following structure
+
+{
+    "plugins": ["ID", "IDLE"],
+    "debug": false,
+    "secureConnection": false,
+    "port": 143,
+    "maxLiteralSize": 67108864,
+    "appendLimit": 5242880,
+    "messageLimit": 1000,
+    "users": {
+        "testuser": {
+            "password": "testpass"
+        }
+    },
+    "id":{
+        "name": "hoodecrow",
+        "version": "__VERSION__",
+        "key": "value"
+    }
+}
+
+Storage file is a tree like structure starting with namespace values.
+INBOX has its own namespace.
+
+{
+    "INBOX":{
+        "uidnext": 123,
+        "messages": [
+            {"raw": "Subject: Test\r\n\r\nHello world!"}
+        ]
+    },
+    "":{
+        "separator": "/",
+        "folders": {
+            "Parent folder":{
+                "folders":{
+                    "Subfolder": {}
+                }
+            }
+        }
+    },
+    "#news/":{
+        "type": "shared"
+    }
+}
+
+If no storage file is specified, an empty "INBOX" is used. If no users
+are configured, the only account is "testuser" with password "testpass".
+The storage and users objects are copied, so the files are never changed.
+
+Project homepage: __HOMEPAGE__
+Report issues at: __BUGS__
+
+License: MIT
+
+Copyright (c) 2013-2026 Postal Systems OÜ

package/bin/imapkit.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { parseArgs } = require('node:util');
+const imapkit = require('../lib/server');
+const packageData = require('../package.json');
+
+// Non-strict so that boolean flags also accept an explicit value (`--secure=true`)
+const { values: argv } = parseArgs({
+    strict: false,
+    options: {
+        port: { type: 'string', short: 'p' },
+        secure: { type: 'boolean', short: 's' },
+        debug: { type: 'boolean', short: 'd' },
+        help: { type: 'boolean', short: 'h' },
+        config: { type: 'string' },
+        storage: { type: 'string' },
+        plugin: { type: 'string', multiple: true },
+        smtpPort: { type: 'string' }
+    }
+});
+
+const isTrue = value => (value || '').toString().trim().toLowerCase() === 'true';
+
+const configLocation = argv.config || process.env.IMAPKIT_CONFIG;
+const storageLocation = argv.storage || process.env.IMAPKIT_STORAGE;
+const smtpPort = argv.smtpPort || process.env.IMAPKIT_SMTPPORT;
+const pluginsList = []
+    .concat(argv.plugin || process.env.IMAPKIT_PLUGINS || [])
+    .flatMap(plugin =>
+        String(plugin)
+            .toUpperCase()
+            .trim()
+            .split(/\s*,\s*/)
+    )
+    .filter(Boolean);
+const secure = isTrue(argv.secure || process.env.IMAPKIT_SECURE);
+const debug = isTrue(argv.debug || process.env.IMAPKIT_DEBUG);
+
+let config = {};
+
+if (configLocation) {
+    config = JSON.parse(fs.readFileSync(configLocation, 'utf-8'));
+}
+
+if (storageLocation) {
+    config.storage = JSON.parse(fs.readFileSync(storageLocation, 'utf-8'));
+}
+
+if (pluginsList.length) {
+    config.plugins = pluginsList;
+}
+
+if (secure) {
+    config.secureConnection = true;
+}
+
+if (debug) {
+    config.debug = true;
+}
+
+const port = argv.port || process.env.IMAPKIT_PORT || config.port || (secure ? 993 : 143);
+
+if (argv.help) {
+    const help = fs.readFileSync(path.join(__dirname, 'help.txt'), 'utf-8');
+    const pluginsDir = path.join(__dirname, '..', 'lib', 'plugins');
+
+    const plugins = fs.readdirSync(pluginsDir).map(fileName => {
+        const file = fs.readFileSync(path.join(pluginsDir, fileName), 'utf-8');
+        return {
+            key: fileName.replace(/\.js$/i, '').toUpperCase(),
+            value: Array.from(file.matchAll(/@help (.*)/gim), match => match[1])
+        };
+    });
+
+    const indent = Math.max(0, ...plugins.map(plugin => plugin.key.length)) + 2;
+    const pluginText = plugins.flatMap(plugin => [
+        ' ' + plugin.key.padEnd(indent - 1) + (plugin.value[0] || ''),
+        ...plugin.value.slice(1).map(line => ' '.repeat(indent) + line)
+    ]);
+
+    console.log(
+        help
+            .replace(/__PLUGINS__/g, pluginText.join('\n'))
+            .replace(/__VERSION__/g, packageData.version)
+            .replace(/__VBAR__/g, '='.repeat(packageData.version.length))
+            .replace(/__HOMEPAGE__/g, packageData.homepage)
+            .replace(/__BUGS__/g, packageData.bugs.url)
+            .trim()
+    );
+} else {
+    const server = imapkit(config);
+    console.log('Starting ImapKit ...');
+    server.server.on('error', err => {
+        console.error('Failed to start ImapKit on port %s: %s', port, err.message);
+        process.exit(1);
+    });
+    server.listen(port, () => {
+        console.log('ImapKit successfully%s listening on port %s', secure ? ' and securely' : '', port);
+    });
+
+    if (smtpPort) {
+        // loaded on demand, smtp-server is only needed when SMTP is enabled
+        require('../lib/smtp-listener').startSMTPServer(smtpPort, server);
+    }
+}

package/cert/server.crt

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDOjCCAiKgAwIBAgIUad1YSlfC6YFAqn38plnziyvx1/YwDQYJKoZIhvcNAQEL
+BQAwFDESMBAGA1UEAwwJbG9jYWxob3N0MCAXDTI2MTAwNjA4NDU1OFoYDzIxMjYw
+OTEyMDg0NTU4WjAUMRIwEAYDVQQDDAlsb2NhbGhvc3QwggEiMA0GCSqGSIb3DQEB
+AQUAA4IBDwAwggEKAoIBAQDN0THQ8qpf3mMoNlVzVvjfsw/QHo22ojmmUO+3QjZD
+eB7mSmniyGOFw0M8f2g3FM0Kfa51rKMYXWQVcqRTDFkk9zBnCagFIWCi2DI4VgAr
+zWlu4TqOHfRIHcbAH1bTKVh5KnVmQA6j6leKjvSW2021Ntp8VX+KV5nXM3rRUWaP
+USGj1+n6Pcj8ZrMdm2bd6Q4UscCvKrCi1dBPTPt9BNVO0CXL8zsiQfNOveN4nTBm
+F4T1+P/vvzSqHr199XDkjlhd8j3Pm2LKNS5OnPERgwZhgIg15G7Y/vz9N0vZGmIU
+7ApunyrgOhV1o4AlOzdo31xbVYIVn7/fv44DG7hvX8DVAgMBAAGjgYEwfzAdBgNV
+HQ4EFgQUzO7Y5K1NaU+/GXZJi2C47uK0+tQwHwYDVR0jBBgwFoAUzO7Y5K1NaU+/
+GXZJi2C47uK0+tQwDwYDVR0TAQH/BAUwAwEB/zAsBgNVHREEJTAjgglsb2NhbGhv
+c3SHBH8AAAGHEAAAAAAAAAAAAAAAAAAAAAEwDQYJKoZIhvcNAQELBQADggEBAL/P
+p3lI83Fcw8EpVyzr9QPYA7JZVmy8YlJ7vouOmEUi6X7BnK5Eits1uHGZ6rtLGBCY
+Eu4Z4DnCPXnyXuo4Bzaqabs5qUro3Ztf0FXeatGCmTLx06JSapKVyoXkJpzLzX0u
+pj0WfWUkwD3rGQozn0FOUOrZyjYgPgsqr6doWd5emAWl1L8ZGDFJEWPRvrS0dw7Z
+ZG83/H0UYur8lN2JxV4ITRovftmtruiVNw3mXH5BZCIsoFAEtf3hssn6rekfEOfc
+4vty2NskN112OLQzLK1Oq3dl0C6Ns1MdIoelAHrFdeM3O03Y0D2R+PlNw1cU55if
+EF3engvuSVRtcV8eyxM=
+-----END CERTIFICATE-----

package/cert/server.key

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDN0THQ8qpf3mMo
+NlVzVvjfsw/QHo22ojmmUO+3QjZDeB7mSmniyGOFw0M8f2g3FM0Kfa51rKMYXWQV
+cqRTDFkk9zBnCagFIWCi2DI4VgArzWlu4TqOHfRIHcbAH1bTKVh5KnVmQA6j6leK
+jvSW2021Ntp8VX+KV5nXM3rRUWaPUSGj1+n6Pcj8ZrMdm2bd6Q4UscCvKrCi1dBP
+TPt9BNVO0CXL8zsiQfNOveN4nTBmF4T1+P/vvzSqHr199XDkjlhd8j3Pm2LKNS5O
+nPERgwZhgIg15G7Y/vz9N0vZGmIU7ApunyrgOhV1o4AlOzdo31xbVYIVn7/fv44D
+G7hvX8DVAgMBAAECggEABIVNSlEiM+PfGrGC0/s7kTJOLRyWsUXD7WbGtShDp9y6
+FQXaaIxNP1FoJyqHP/p5fHsBO310waK/gYcYm+hgBuNVEVZRdfdjN4B3LeyZqVyk
+LbbNwfRferwIswydLBsy4cpwdLQAflI15Qm5zpx3ivzu9J8uI3xEGUl8r59RmOE9
+tXb+sA9YtWRXUR4mhqApGxMI5ZP1/WbmhlDvLUnartyBNilfS3RTWY7nWMKk3U0N
+yFmYX17WZYnXbJtXQmOX/LHd1nM2NFS2B6yJ6JKY0/jPOGCaTBcVmFgO3x/aDgiJ
+m0XL1mpGBIUugQTio5N1Ewznrg6SA7rzsOzN1g3ZqwKBgQD48+lGyQmFAaaXzf+9
+WiG6F6hQtsiWDwhQ3C1m1fOMk2Fgi/eVPEWxIRbf18XBwgvt4Q7PoyojzR730YZl
+5WsEpliGyaBdrR4ZRh92t3y0fQ6Q/AMhsIEIu62lZbLlLenW5/OZLyVsuctAUZCg
+HBNgwR1wuvBBXrc+TIXjUYgsfwKBgQDTpLEqsjh8ZrCvubH0mlTCHkSS/A3ifk27
+suLZhps0J0JMM1drxpNHcfySZ31sVrMZog1cf5W6z55pYlEDCrlEjK2gjyzJnmUA
+KE+ramKMH1/hfxdVZLY1F1zL2oLuprQEE6AUMDdZiv4JMcNfHA05Ii5VpsGe/sVe
+aCiudjH4qwKBgFEFiMk5ynhYJjDHoVCt0cYvxt6l7jgwIkO2tKwAO6hnmsyCIQyX
+thLEsx4cqka58Yn0sg5Pivpl2otKzJPDC4ZS4QLVAfUaz23oTXskklhnTuNOsXI4
+cHY4JnZq18MQo0cG7FfRaTuuaADByvDg0kmt7/ftTx3nRnnnC7gEo+3fAoGAX4WG
+fNnBSsxiVH2ARwDc3lwg4SIn9iDBXsTnQ/xP0mMhthi6DSer02Qr9bwFzL74yMnu
+M+BVqOIKAlBgdfoCEmFYAA5+zWTS+xY2lwxF/C4w7SqaUm1JG3823774t1PADdL5
+vgLhCGYGMAoovqV/hljaBshjvSoJ1Ik4Sz2HYk8CgYEAnSqiwlpYZKQX7jBo7yWA
+xB6r81uUHwy+XOq7A4OfgbEEuuKQ6tXOg72FX+38rF+Td6iA+6qIPoSoGtK0jANX
+ykroFnXr4N3IL5TafDZVvMGNuWhWwS8JR3B0VDzPobt/jxPJKmGunZoCqwJC+nqT
+ELanzRGdLk0G2chSGO7ZKGg=
+-----END PRIVATE KEY-----

package/lib/addressparser.js

@@ -0,0 +1,283 @@
+'use strict';
+
+/**
+ * Parses structured e-mail addresses from an address field
+ *
+ * Example:
+ *
+ *    "Name <address@domain>"
+ *
+ * will be converted to
+ *
+ *     [{name: "Name", address: "address@domain"}]
+ *
+ * @param {String} str Address field
+ * @return {Array} An array of address objects
+ */
+const parse = (module.exports = function (str, inGroup) {
+    const tokenizer = new Tokenizer(str);
+    const tokens = tokenizer.tokenize();
+
+    const addresses = [];
+    let address = [];
+    let parsedAddresses = [];
+
+    tokens.forEach(token => {
+        if (token.type === 'operator' && (token.value === ',' || token.value === ';')) {
+            if (address.length) {
+                addresses.push(address);
+            }
+            address = [];
+        } else {
+            address.push(token);
+        }
+    });
+
+    if (address.length) {
+        addresses.push(address);
+    }
+
+    addresses.forEach(address => {
+        address = _handleAddress(address, inGroup);
+        if (address.length) {
+            parsedAddresses = parsedAddresses.concat(address);
+        }
+    });
+
+    return parsedAddresses;
+});
+
+/**
+ * Converts tokens for a single address into an address object
+ *
+ * @param {Array} tokens Tokens object
+ * @param {Boolean} [inGroup] If true, the tokens are a member of a group. Groups do not nest
+ *        (RFC 5322 3.4), so a colon is not a group separator here
+ * @return {Object} Address object
+ */
+function _handleAddress(tokens, inGroup) {
+    let token;
+    let isGroup = false;
+    let state = 'text';
+    let address;
+    const addresses = [];
+    const data = {
+        address: [],
+        comment: [],
+        group: [],
+        text: []
+    };
+    let i;
+    let len;
+
+    // Filter out <addresses>, (comments) and regular text
+    for (i = 0, len = tokens.length; i < len; i++) {
+        token = tokens[i];
+
+        if (token.type === 'operator') {
+            switch (token.value) {
+                case '<':
+                    state = 'address';
+                    break;
+                case '(':
+                    state = 'comment';
+                    break;
+                case ':':
+                    if (inGroup) {
+                        state = 'text';
+                        break;
+                    }
+                    state = 'group';
+                    isGroup = true;
+                    break;
+                default:
+                    state = 'text';
+            }
+        } else {
+            if (token.value) {
+                data[state].push(token.value);
+            }
+        }
+    }
+
+    // If there is no text but a comment, replace the two
+    if (!data.text.length && data.comment.length) {
+        data.text = data.comment;
+        data.comment = [];
+    }
+
+    if (isGroup) {
+        // http://tools.ietf.org/html/rfc2822#appendix-A.1.3
+        data.text = data.text.join(' ');
+        addresses.push({
+            name: data.text || address.name,
+            group: data.group.length ? parse(data.group.join(','), true) : []
+        });
+    } else {
+        // If no address was found, try to detect one from regular text
+        if (!data.address.length && data.text.length) {
+            for (i = data.text.length - 1; i >= 0; i--) {
+                if (data.text[i].match(/^[^@\s]+@[^@\s]+$/)) {
+                    data.address = data.text.splice(i, 1);
+                    break;
+                }
+            }
+
+            const _regexHandler = function (address) {
+                if (!data.address.length) {
+                    data.address = [address.trim()];
+                    return ' ';
+                } else {
+                    return address;
+                }
+            };
+
+            // still no address
+            if (!data.address.length) {
+                for (i = data.text.length - 1; i >= 0; i--) {
+                    data.text[i] = data.text[i].replace(/\s*\b[^@\s]+@[^@\s]+\b\s*/, _regexHandler).trim();
+                    if (data.address.length) {
+                        break;
+                    }
+                }
+            }
+        }
+
+        // If there's still is no text but a comment exixts, replace the two
+        if (!data.text.length && data.comment.length) {
+            data.text = data.comment;
+            data.comment = [];
+        }
+
+        // Keep only the first address occurence, push others to regular text
+        if (data.address.length > 1) {
+            data.text = data.text.concat(data.address.splice(1));
+        }
+
+        // Join values with spaces
+        data.text = data.text.join(' ');
+        data.address = data.address.join(' ');
+
+        if (!data.address && isGroup) {
+            return [];
+        } else {
+            address = {
+                address: data.address || data.text || '',
+                name: data.text || data.address || ''
+            };
+
+            if (address.address === address.name) {
+                if ((address.address || '').match(/@/)) {
+                    address.name = '';
+                } else {
+                    address.address = '';
+                }
+            }
+
+            addresses.push(address);
+        }
+    }
+
+    return addresses;
+}
+
+/**
+ * Creates a Tokenizer object for tokenizing address field strings
+ *
+ * @constructor
+ * @param {String} str Address field string
+ */
+function Tokenizer(str) {
+    this.str = (str || '').toString();
+    this.operatorCurrent = '';
+    this.operatorExpecting = '';
+    this.node = null;
+    this.escaped = false;
+
+    this.list = [];
+}
+
+/**
+ * Operator tokens and which tokens are expected to end the sequence
+ */
+Tokenizer.prototype.operators = {
+    '"': '"',
+    '(': ')',
+    '<': '>',
+    ',': '',
+    ':': ';'
+};
+
+/**
+ * Tokenizes the original input string
+ *
+ * @return {Array} An array of operator|text tokens
+ */
+Tokenizer.prototype.tokenize = function () {
+    let chr;
+    const list = [];
+    for (let i = 0, len = this.str.length; i < len; i++) {
+        chr = this.str.charAt(i);
+        this.checkChar(chr);
+    }
+
+    this.list.forEach(node => {
+        node.value = (node.value || '').toString().trim();
+        if (node.value) {
+            list.push(node);
+        }
+    });
+
+    return list;
+};
+
+/**
+ * Checks if a character is an operator or text and acts accordingly
+ *
+ * @param {String} chr Character from the address field
+ */
+Tokenizer.prototype.checkChar = function (chr) {
+    if ((chr in this.operators || chr === '\\') && this.escaped) {
+        this.escaped = false;
+    } else if (this.operatorExpecting && chr === this.operatorExpecting) {
+        this.node = {
+            type: 'operator',
+            value: chr
+        };
+        this.list.push(this.node);
+        this.node = null;
+        this.operatorExpecting = '';
+        this.escaped = false;
+        return;
+    } else if (!this.operatorExpecting && chr in this.operators) {
+        this.node = {
+            type: 'operator',
+            value: chr
+        };
+        this.list.push(this.node);
+        this.node = null;
+        this.operatorExpecting = this.operators[chr];
+        this.escaped = false;
+        return;
+    }
+
+    if (!this.escaped && chr === '\\') {
+        this.escaped = true;
+        return;
+    }
+
+    if (!this.node) {
+        this.node = {
+            type: 'text',
+            value: ''
+        };
+        this.list.push(this.node);
+    }
+
+    if (this.escaped && chr !== '\\') {
+        this.node.value += '\\';
+    }
+
+    this.node.value += chr;
+    this.escaped = false;
+};

package/lib/arguments.js

@@ -0,0 +1,112 @@
+'use strict';
+
+// Checks of parsed command arguments (imap-handler parser output)
+
+/**
+ * Checks if a parsed argument is an atom, optionally a specific one
+ *
+ * @param {Object} value Parsed argument
+ * @param {String} [name] Upper case atom to match, the value is compared case-insensitively
+ * @return {Boolean} true for an atom (with that name)
+ */
+function isAtom(value, name) {
+    return !!value && !Array.isArray(value) && value.type === 'ATOM' && (name === undefined || String(value.value).toUpperCase() === name);
+}
+
+/**
+ * Checks if a parsed argument is an astring (RFC 3501 section 9): an atom, a quoted string or a literal. An
+ * atom the parser split into a section or partial range (like BODY[1]<0.5>) is not
+ *
+ * @param {Object} value Parsed argument
+ * @return {Boolean} true for an astring
+ */
+function isAstring(value) {
+    return !!value && !Array.isArray(value) && ['ATOM', 'STRING', 'LITERAL'].indexOf(value.type) >= 0 && !value.section && !value.partial;
+}
+
+// characters that end an atom in a command line (RFC 3501 section 9 atom-specials, and "[" "]" of sections)
+const ATOM_END = /[\s()[\]{"%*\\<]/;
+
+/**
+ * Lists how the client spelled the NIL atoms of a command line, in order. Quoted strings and literals are skipped
+ *
+ * @param {String} data Raw command line with its literals
+ * @return {Array} spellings, e.g. ["nil", "NIL"]
+ */
+function nilSpellings(data) {
+    const result = [];
+    let i = 0;
+    while (i < data.length) {
+        const ch = data.charAt(i);
+        if (ch === '"') {
+            for (i++; i < data.length && data.charAt(i) !== '"'; i++) {
+                if (data.charAt(i) === '\\') {
+                    i++;
+                }
+            }
+            i++;
+            continue;
+        }
+        const literal = (ch === '{' || ch === '~') && data.substr(i, 32).match(/^~?\{(\d+)\+?\}\r\n/);
+        if (literal) {
+            i += literal[0].length + Number(literal[1]);
+            continue;
+        }
+        if (ATOM_END.test(ch)) {
+            i++;
+            continue;
+        }
+        let end = i;
+        while (end < data.length && !ATOM_END.test(data.charAt(end))) {
+            end++;
+        }
+        const token = data.substring(i, end);
+        if (/^nil$/i.test(token)) {
+            result.push(token);
+        }
+        i = end;
+    }
+    return result;
+}
+
+/**
+ * The parser turns every NIL atom into null, as in an nstring. Where the grammar has an astring (mailbox names, user
+ * names, search strings, ...) NIL is an ordinary atom, so these nulls are turned back into atoms with the spelling
+ * the client used
+ *
+ * @param {Object} parsed Parsed command, changed in place
+ * @param {String} data Raw command line with its literals
+ * @param {Function} select `(path)` returns true for the nulls to restore, `path` lists the indexes from the
+ *   top-level arguments down, e.g. [2, 0] for the first item of a list in the third argument
+ */
+function restoreNilAtoms(parsed, data, select) {
+    if (!parsed.attributes || !/nil/i.test(data || '')) {
+        return;
+    }
+    // every null in the order the parser met them, sections included
+    const nulls = [];
+    const walk = (list, path) => {
+        list.forEach((item, i) => {
+            if (item === null) {
+                nulls.push({ list, index: i, path: path.concat(i) });
+            } else if (Array.isArray(item)) {
+                walk(item, path.concat(i));
+            } else if (item && Array.isArray(item.section)) {
+                walk(item.section, path.concat(i, 'section'));
+            }
+        });
+    };
+    walk(parsed.attributes, []);
+    if (!nulls.length) {
+        return;
+    }
+    // the tag and the command name come first, so the arguments are the last NIL atoms of the line
+    const spellings = nilSpellings(data).slice(-nulls.length);
+    nulls.forEach((entry, i) => {
+        if (select(entry.path)) {
+            entry.list[entry.index] = { type: 'ATOM', value: spellings.length === nulls.length ? spellings[i] : 'NIL' };
+        }
+    });
+}
+
+module.exports = { isAtom, isAstring, restoreNilAtoms };