<commit_before>'use strict';

/*
* When adding names to the namespace, ensure that they are added in alphabetical order according to alias (namespace key).
*/

var ns = [];

ns.push({
	'alias': 'identity',
	'path': '@stdlib/utils/identity-function',
	'value': require( '@stdlib/utils/identity-function' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/constant-function'
	]
});

ns.push({
	'alias': 'indexOf',
	'path': '@stdlib/utils/index-of',
	'value': require( '@stdlib/utils/index-of' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'inherit',
	'path': '@stdlib/utils/inherit',
	'value': require( '@stdlib/utils/inherit' ),
	'type': 'Function',
	'related': []
});


// EXPORTS //

module.exports = ns;<commit_msg>Update namespace<commit_after>'use strict';

/*
* When adding names to the namespace, ensure that they are added in alphabetical order according to alias (namespace key).
*/

var ns = [];

ns.push({
	'alias': 'identity',
	'path': '@stdlib/utils/identity-function',
	'value': require( '@stdlib/utils/identity-function' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/constant-function'
	]
});

ns.push({
	'alias': 'indexOf',
	'path': '@stdlib/utils/index-of',
	'value': require( '@stdlib/utils/index-of' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'inherit',
	'path': '@stdlib/utils/inherit',
	'value': require( '@stdlib/utils/inherit' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isAbsolutePath',
	'path': '@stdlib/utils/is-absolute-path',
	'value': require( '@stdlib/utils/is-absolute-path' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-relative-path'
	]
});

ns.push({
	'alias': 'isArguments',
	'path': '@stdlib/utils/is-arguments',
	'value': require( '@stdlib/utils/is-arguments' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isArray',
	'path': '@stdlib/utils/is-array',
	'value': require( '@stdlib/utils/is-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array-like'
	]
});

ns.push({
	'alias': 'isArrayArray',
	'path': '@stdlib/utils/is-array-array',
	'value': require( '@stdlib/utils/is-array-array' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isArrayLike',
	'path': '@stdlib/utils/is-array-like',
	'value': require( '@stdlib/utils/is-array-like' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array'
	]
});

ns.push({
	'alias': 'isBinaryString',
	'path': '@stdlib/utils/is-binary-string',
	'value': require( '@stdlib/utils/is-binary-string' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-string'
	]
});

ns.push({
	'alias': 'isBoolean',
	'path': '@stdlib/utils/is-boolean',
	'value': require( '@stdlib/utils/is-boolean' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isBooleanArray',
	'path': '@stdlib/utils/is-boolean-array',
	'value': require( '@stdlib/utils/is-boolean-array' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isBrowser',
	'path': '@stdlib/utils/is-browser',
	'value': require( '@stdlib/utils/is-browser' ),
	'type': 'boolean',
	'related': []
});

ns.push({
	'alias': 'isBuffer',
	'path': '@stdlib/utils/is-buffer',
	'value': require( '@stdlib/utils/is-buffer' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isCapitalized',
	'path': '@stdlib/utils/is-capitalized',
	'value': require( '@stdlib/utils/is-capitalized' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-string'
	]
});

ns.push({
	'alias': 'isDarwin',
	'path': '@stdlib/utils/is-darwin',
	'value': require( '@stdlib/utils/is-darwin' ),
	'type': 'boolean',
	'related': []
});

ns.push({
	'alias': 'isDateObject',
	'path': '@stdlib/utils/is-date-object',
	'value': require( '@stdlib/utils/is-date-object' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isElectron',
	'path': '@stdlib/utils/is-electron',
	'value': require( '@stdlib/utils/is-electron' ),
	'type': 'boolean',
	'related': [
		'@stdlib/utils/is-electron-main',
		'@stdlib/utils/is-electron-renderer'
	]
});

ns.push({
	'alias': 'isElectronMain',
	'path': '@stdlib/utils/is-electron-main',
	'value': require( '@stdlib/utils/is-electron-main' ),
	'type': 'boolean',
	'related': [
		'@stdlib/utils/is-electron',
		'@stdlib/utils/is-electron-renderer'
	]
});

ns.push({
	'alias': 'isElectronRenderer',
	'path': '@stdlib/utils/is-electron-renderer',
	'value': require( '@stdlib/utils/is-electron-renderer' ),
	'type': 'boolean',
	'related': [
		'@stdlib/utils/is-electron',
		'@stdlib/utils/is-electron-main'
	]
});

ns.push({
	'alias': 'isEmailAddress',
	'path': '@stdlib/utils/is-email-address',
	'value': require( '@stdlib/utils/is-email-address' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isEmptyArray',
	'path': '@stdlib/utils/is-empty-array',
	'value': require( '@stdlib/utils/is-empty-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array'
	]
});

ns.push({
	'alias': 'isEnumerableProperty',
	'path': '@stdlib/utils/is-enumerable-property',
	'value': require( '@stdlib/utils/is-enumerable-property' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isEven',
	'path': '@stdlib/utils/is-even',
	'value': require( '@stdlib/utils/is-even' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-odd'
	]
});

ns.push({
	'alias': 'isFloat32Array',
	'path': '@stdlib/utils/is-float32-array',
	'value': require( '@stdlib/utils/is-float32-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-float64-array'
	]
});

ns.push({
	'alias': 'isFloat64Array',
	'path': '@stdlib/utils/is-float64-array',
	'value': require( '@stdlib/utils/is-float64-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-float32-array'
	]
});

ns.push({
	'alias': 'isFunction',
	'path': '@stdlib/utils/is-function',
	'value': require( '@stdlib/utils/is-function' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isFunctionArray',
	'path': '@stdlib/utils/is-function-array',
	'value': require( '@stdlib/utils/is-function-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array'
	]
});

ns.push({
	'alias': 'isInt16Array',
	'path': '@stdlib/utils/is-int16array',
	'value': require( '@stdlib/utils/is-int16array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-int32array',
		'@stdlib/utils/is-int8array'
	]
});

ns.push({
	'alias': 'isInt32Array',
	'path': '@stdlib/utils/is-int32array',
	'value': require( '@stdlib/utils/is-int32array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-int16array',
		'@stdlib/utils/is-int8array'
	]
});

ns.push({
	'alias': 'isInt8Array',
	'path': '@stdlib/utils/is-int8array',
	'value': require( '@stdlib/utils/is-int8array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-int16array',
		'@stdlib/utils/is-int32array'
	]
});

ns.push({
	'alias': 'isInteger',
	'path': '@stdlib/utils/is-integer',
	'value': require( '@stdlib/utils/is-integer' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-number'
	]
});

ns.push({
	'alias': 'isIntegerArray',
	'path': '@stdlib/utils/is-integer-array',
	'value': require( '@stdlib/utils/is-integer-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array'
	]
});

ns.push({
	'alias': 'isJSON',
	'path': '@stdlib/utils/is-json',
	'value': require( '@stdlib/utils/is-json' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isLeapYear',
	'path': '@stdlib/utils/is-leap-year',
	'value': require( '@stdlib/utils/is-leap-year' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isLittleEndian',
	'path': '@stdlib/utils/is-little-endian',
	'value': require( '@stdlib/utils/is-little-endian' ),
	'type': 'boolean',
	'related': []
});

ns.push({
	'alias': 'isLowercase',
	'path': '@stdlib/utils/is-lowercase',
	'value': require( '@stdlib/utils/is-lowercase' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-string',
		'@stdlib/utils/is-uppercase'
	]
});

ns.push({
	'alias': 'isnan',
	'path': '@stdlib/utils/is-nan',
	'value': require( '@stdlib/utils/is-nan' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-number'
	]
});

ns.push({
	'alias': 'isNaNArray',
	'path': '@stdlib/utils/is-nan-array',
	'value': require( '@stdlib/utils/is-nan-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-nan'
	]
});

ns.push({
	'alias': 'isNegativeInteger',
	'path': '@stdlib/utils/is-negative-integer',
	'value': require( '@stdlib/utils/is-negative-integer' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-integer'
	]
});

ns.push({
	'alias': 'isNegativeIntegerArray',
	'path': '@stdlib/utils/is-negative-integer-array',
	'value': require( '@stdlib/utils/is-negative-integer-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array'
	]
});

ns.push({
	'alias': 'isNegativeNumber',
	'path': '@stdlib/utils/is-negative-number',
	'value': require( '@stdlib/utils/is-negative-number' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-number'
	]
});

ns.push({
	'alias': 'isNegativeNumberArray',
	'path': '@stdlib/utils/is-negative-number-array',
	'value': require( '@stdlib/utils/is-negative-number-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array'
	]
});

ns.push({
	'alias': 'isNode',
	'path': '@stdlib/utils/is-node',
	'value': require( '@stdlib/utils/is-node' ),
	'type': 'boolean',
	'related': []
});

ns.push({
	'alias': 'isNonNegativeInteger',
	'path': '@stdlib/utils/is-nonnegative-integer',
	'value': require( '@stdlib/utils/is-nonnegative-integer' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-integer'
	]
});

ns.push({
	'alias': 'isNonNegativeIntegerArray',
	'path': '@stdlib/utils/is-nonnegative-integer-array',
	'value': require( '@stdlib/utils/is-nonnegative-integer-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array'
	]
});

ns.push({
	'alias': 'isNonNegativeNumber',
	'path': '@stdlib/utils/is-nonnegative-number',
	'value': require( '@stdlib/utils/is-nonnegative-number' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-number'
	]
});

ns.push({
	'alias': 'isNonNegativeNumberArray',
	'path': '@stdlib/utils/is-nonnegative-number-array',
	'value': require( '@stdlib/utils/is-nonnegative-number-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array'
	]
});

ns.push({
	'alias': 'isNonPositiveInteger',
	'path': '@stdlib/utils/is-nonpositive-integer',
	'value': require( '@stdlib/utils/is-nonpositive-integer' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-integer'
	]
});

ns.push({
	'alias': 'isNonPositiveIntegerArray',
	'path': '@stdlib/utils/is-nonpositive-integer-array',
	'value': require( '@stdlib/utils/is-nonpositive-integer-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array'
	]
});

ns.push({
	'alias': 'isNonPositiveNumber',
	'path': '@stdlib/utils/is-nonpositive-number',
	'value': require( '@stdlib/utils/is-nonpositive-number' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-number'
	]
});

ns.push({
	'alias': 'isNonPositiveNumberArray',
	'path': '@stdlib/utils/is-nonpositive-number-array',
	'value': require( '@stdlib/utils/is-nonpositive-number-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array'
	]
});

ns.push({
	'alias': 'isNull',
	'path': '@stdlib/utils/is-null',
	'value': require( '@stdlib/utils/is-null' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-undefined',
		'@stdlib/utils/is-undefined-or-null'
	]
});

ns.push({
	'alias': 'isNullArray',
	'path': '@stdlib/utils/is-null-array',
	'value': require( '@stdlib/utils/is-null-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array',
		'@stdlib/utils/is-null'
	]
});

ns.push({
	'alias': 'isNumber',
	'path': '@stdlib/utils/is-number',
	'value': require( '@stdlib/utils/is-number' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isNumericArray',
	'path': '@stdlib/utils/is-numeric-array',
	'value': require( '@stdlib/utils/is-numeric-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array'
	]
});

ns.push({
	'alias': 'isObject',
	'path': '@stdlib/utils/is-object',
	'value': require( '@stdlib/utils/is-object' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-object-like',
		'@stdlib/utils/is-plain-object'
	]
});

ns.push({
	'alias': 'isObjectArray',
	'path': '@stdlib/utils/is-object-array',
	'value': require( '@stdlib/utils/is-object-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array',
		'@stdlib/utils/is-object'
	]
});

ns.push({
	'alias': 'isObjectLike',
	'path': '@stdlib/utils/is-object-like',
	'value': require( '@stdlib/utils/is-object-like' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-object',
		'@stdlib/utils/is-plain-object'
	]
});

ns.push({
	'alias': 'isOdd',
	'path': '@stdlib/utils/is-odd',
	'value': require( '@stdlib/utils/is-odd' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-even'
	]
});

ns.push({
	'alias': 'isPlainObject',
	'path': '@stdlib/utils/is-plain-object',
	'value': require( '@stdlib/utils/is-plain-object' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-object'
	]
});

ns.push({
	'alias': 'isPlainObjectArray',
	'path': '@stdlib/utils/is-plain-object-array',
	'value': require( '@stdlib/utils/is-plain-object-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array',
		'@stdlib/utils/is-plain-object'
	]
});

ns.push({
	'alias': 'isPositiveInteger',
	'path': '@stdlib/utils/is-positive-integer',
	'value': require( '@stdlib/utils/is-positive-integer' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-integer'
	]
});

ns.push({
	'alias': 'isPositiveIntegerArray',
	'path': '@stdlib/utils/is-positive-integer-array',
	'value': require( '@stdlib/utils/is-positive-integer-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array',
		'@stdlib/utils/is-integer',
		'@stdlib/utils/is-positive-integer'
	]
});

ns.push({
	'alias': 'isPositiveNumber',
	'path': '@stdlib/utils/is-positive-number',
	'value': require( '@stdlib/utils/is-positive-number' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-number'
	]
});

ns.push({
	'alias': 'isPositiveNumberArray',
	'path': '@stdlib/utils/is-positive-number-array',
	'value': require( '@stdlib/utils/is-positive-number-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array',
		'@stdlib/utils/is-number',
		'@stdlib/utils/is-positive-number'
	]
});

ns.push({
	'alias': 'isPrimitive',
	'path': '@stdlib/utils/is-primitive',
	'value': require( '@stdlib/utils/is-primitive' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isPrimitiveArray',
	'path': '@stdlib/utils/is-primitive-array',
	'value': require( '@stdlib/utils/is-primitive-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array',
		'@stdlib/utils/is-primitive'
	]
});

ns.push({
	'alias': 'isProbability',
	'path': '@stdlib/utils/is-probability',
	'value': require( '@stdlib/utils/is-probability' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-number'
	]
});

ns.push({
	'alias': 'isProbabilityArray',
	'path': '@stdlib/utils/is-probability-array',
	'value': require( '@stdlib/utils/is-probability-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array',
		'@stdlib/utils/is-probability'
	]
});

ns.push({
	'alias': 'isRegExp',
	'path': '@stdlib/utils/is-regexp',
	'value': require( '@stdlib/utils/is-regexp' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isRegExpString',
	'path': '@stdlib/utils/is-regexp-string',
	'value': require( '@stdlib/utils/is-regexp-string' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-regexp'
	]
});

ns.push({
	'alias': 'isRelativePath',
	'path': '@stdlib/utils/is-relative-path',
	'value': require( '@stdlib/utils/is-relative-path' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-absolute-path'
	]
});

ns.push({
	'alias': 'isSafeInteger',
	'path': '@stdlib/utils/is-safe-integer',
	'value': require( '@stdlib/utils/is-safe-integer' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-integer',
		'@stdlib/utils/is-number'
	]
});

ns.push({
	'alias': 'isSafeIntegerArray',
	'path': '@stdlib/utils/is-safe-integer-array',
	'value': require( '@stdlib/utils/is-safe-integer-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array',
		'@stdlib/utils/is-safe-integer'
	]
});

ns.push({
	'alias': 'isString',
	'path': '@stdlib/utils/is-string',
	'value': require( '@stdlib/utils/is-string' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isStringArray',
	'path': '@stdlib/utils/is-string-array',
	'value': require( '@stdlib/utils/is-string-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array',
		'@stdlib/utils/is-string'
	]
});

ns.push({
	'alias': 'isTypedArray',
	'path': '@stdlib/utils/is-typed-array',
	'value': require( '@stdlib/utils/is-typed-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-array',
		'@stdlib/utils/is-typed-array-like'
	]
});

ns.push({
	'alias': 'isTypedArrayLike',
	'path': '@stdlib/utils/is-typed-array-like',
	'value': require( '@stdlib/utils/is-typed-array-like' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-typed-array'
	]
});

ns.push({
	'alias': 'isUint16Array',
	'path': '@stdlib/utils/is-uint16array',
	'value': require( '@stdlib/utils/is-uint16array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-typed-array',
		'@stdlib/utils/is-uint32array',
		'@stdlib/utils/is-uint8array'
	]
});

ns.push({
	'alias': 'isUint32Array',
	'path': '@stdlib/utils/is-uint32array',
	'value': require( '@stdlib/utils/is-uint32array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-typed-array',
		'@stdlib/utils/is-uint16array',
		'@stdlib/utils/is-uint8array'
	]
});

ns.push({
	'alias': 'isUint8Array',
	'path': '@stdlib/utils/is-uint8array',
	'value': require( '@stdlib/utils/is-uint8array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-typed-array',
		'@stdlib/utils/is-uint16array',
		'@stdlib/utils/is-uint32array'
	]
});

ns.push({
	'alias': 'isUint8ClampedArray',
	'path': '@stdlib/utils/is-uint8array-clamped',
	'value': require( '@stdlib/utils/is-uint8array-clamped' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-typed-array',
		'@stdlib/utils/is-uint8array'
	]
});

ns.push({
	'alias': 'isUNCPath',
	'path': '@stdlib/utils/is-unc-path',
	'value': require( '@stdlib/utils/is-unc-path' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isUndefined',
	'path': '@stdlib/utils/is-undefined',
	'value': require( '@stdlib/utils/is-undefined' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-null',
		'@stdlib/utils/is-undefined-or-null'
	]
});

ns.push({
	'alias': 'isUndefinedOrNull',
	'path': '@stdlib/utils/is-undefined-or-null',
	'value': require( '@stdlib/utils/is-undefined-or-null' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-null',
		'@stdlib/utils/is-undefined'
	]
});

ns.push({
	'alias': 'isUnityProbabilityArray',
	'path': '@stdlib/utils/is-unity-probability-array',
	'value': require( '@stdlib/utils/is-unity-probability-array' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-probability',
		'@stdlib/utils/is-probability-array'
	]
});

ns.push({
	'alias': 'isUppercase',
	'path': '@stdlib/utils/is-uppercase',
	'value': require( '@stdlib/utils/is-uppercase' ),
	'type': 'Function',
	'related': [
		'@stdlib/utils/is-lowercase',
		'@stdlib/utils/is-string'
	]
});

ns.push({
	'alias': 'isURI',
	'path': '@stdlib/utils/is-uri',
	'value': require( '@stdlib/utils/is-uri' ),
	'type': 'Function',
	'related': []
});

ns.push({
	'alias': 'isWebWorker',
	'path': '@stdlib/utils/is-web-worker',
	'value': require( '@stdlib/utils/is-web-worker' ),
	'type': 'boolean',
	'related': []
});

ns.push({
	'alias': 'isWindows',
	'path': '@stdlib/utils/is-windows',
	'value': require( '@stdlib/utils/is-windows' ),
	'type': 'boolean',
	'related': []
});


// EXPORTS //

module.exports = ns;
{'fraction_non_alphanumeric': 0.25351615667691685, 'fraction_numerical': 0.0035287593890205174, 'mean_word_length': 4.676108726752504, 'pattern_counts': {'":': 0, '<': 3, '<?xml version=': 0, '>': 3, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'dir': 'git-commits-cleaned', 'id': '5151', 'n_tokens_mistral': 8310, 'n_tokens_neox': 7845, 'n_words': 1175}