'use strict';

// The whole point behind this internal module is to allow Node.js to no

// longer be forced to treat every error message change as a semver-major

// change. The NodeError classes here all expose a `code` property whose

// value statically and permanently identifies the error. While the error

// message may change, the code should not.

const kCode = Symbol('code');

const messages = new Map();

var util;

function lazyUtil() {

}

var assert;

function lazyAssert() {

}

function makeNodeError(Base) {

}

function message(key, args) {

}

// Utility function for registering the error codes. Only used here. Exported

// *only* to allow for testing.

function E(sym, val) {

messages.set(sym, typeof val === 'function' ? val : String(val));

}

module.exports = exports = {

message,

Error: makeNodeError(Error),

TypeError: makeNodeError(TypeError),

RangeError: makeNodeError(RangeError),

E // This is exported only to facilitate testing.

};

// To declare an error message, use the E(sym, val) function above. The sym

// must be an upper case string. The val can be either a function or a string.

// The return value of the function must be a string.

// Examples:

// E('EXAMPLE_KEY1', 'This is the error value');

// E('EXAMPLE_KEY2', (a, b) => return `${a} ${b}`);

//

// Once an error code has been assigned, the code itself MUST NOT change and

// any given error code must never be reused to identify a different error.

//

// Any error code added here should also be added to the documentation

//

// Note: Please try to keep these in alphabetical order

E('ERR_ARG_NOT_ITERABLE', '%s must be iterable');

E('ERR_ASSERTION', (msg) => msg);

E('ERR_INVALID_ARG_TYPE', invalidArgType);

E('ERR_INVALID_CALLBACK', 'callback must be a function');

E('ERR_INVALID_FILE_URL_HOST', 'File URL host %s');

E('ERR_INVALID_FILE_URL_PATH', 'File URL path %s');

E('ERR_INVALID_HANDLE_TYPE', 'This handle type cannot be sent');

E('ERR_INVALID_OPT_VALUE',

(name, value) => {

return `The value "${String(value)}" is invalid for option "${name}"`;

});

E('ERR_INVALID_SYNC_FORK_INPUT',

(value) => {

return 'Asynchronous forks do not support Buffer, Uint8Array or string' +

`input: ${value}`;

});

E('ERR_INVALID_THIS', 'Value of "this" must be of type %s');

E('ERR_INVALID_TUPLE', '%s must be an iterable %s tuple');

E('ERR_INVALID_URL', 'Invalid URL: %s');

E('ERR_INVALID_URL_SCHEME',

(expected) => `The URL must be ${oneOf(expected, 'scheme')}`);

E('ERR_IPC_CHANNEL_CLOSED', 'channel closed');

E('ERR_IPC_DISCONNECTED', 'IPC channel is already disconnected');

E('ERR_IPC_ONE_PIPE', 'Child process can have only one IPC pipe');

E('ERR_IPC_SYNC_FORK', 'IPC cannot be used with synchronous forks');

E('ERR_MISSING_ARGS', missingArgs);

E('ERR_STDERR_CLOSE', 'process.stderr cannot be closed');

E('ERR_STDOUT_CLOSE', 'process.stdout cannot be closed');

E('ERR_UNKNOWN_BUILTIN_MODULE', (id) => `No such built-in module: ${id}`);

E('ERR_UNKNOWN_SIGNAL', (signal) => `Unknown signal: ${signal}`);

E('ERR_UNKNOWN_STDIN_TYPE', 'Unknown stdin file type');

E('ERR_UNKNOWN_STREAM_TYPE', 'Unknown stream file type');

// Add new errors from here...

function invalidArgType(name, expected, actual) {

}

function missingArgs(...args) {

}

function oneOf(expected, thing) {

}