const {toArray, toIterator, toMap, toNumber, toObject, toString} = require('2')

const obj = {a: 1, b: 2}
obj::toMap()::toArray()::toObject()::toIterator()
  ::toArray()::toMap()::toObject() // {a: 1, b: 2}

let data = '1.23'
data = toNumber(data)
data = toString(data) // '1.23'

const {toArray, toIterator, toMap, toNumber, toObject, toString} = require('2')

const toArray = require('2/array')
const toIterator = require('2/iterator')
const toMap = require('2/map')
const toNumber = require('2/number')
const toObject = require('2/object')
const toString = require('2/string')

const toArray = require('2/array')

// Map => Array
const map = new Map()
map.set('a', 1)
map.set('b', 2)
toArray(map) // [['a', 1], ['b', 2]]

// Iterator => Array
toArray(map.values()) // [1, 2]

// Object => Array
toArray({a: 1, b: 2}) // [['a', 1], ['b', 2]]

// Array-like object => Array
toArray({0: 'first', 1: 'second'}, {detectIndexKeys: true}) // ['first', 'second']

// Primitive value => Array
toArray('test') // ['test']

const toIterator = require('2/iterator')

// Object => Iterator
let iterator = toIterator({a: 1, b: 2})
iterator.next().value // ['a', 1]
iterator.next().value // ['b', 2]
iterator.next().done // true

// Primitive value => Iterator
toIterator('test').next().value // 'test'

const toMap = require('2/map')

// Array of key/value pairs => Map
const map1 = toMap([['a', 1], ['b', 2]])
map1.get('a') // 1
map1.get('b') // 2

// Array of values => Map
const map2 = toMap(['a', 'b'])
map2.get(0) // 'a'
map2.get(1) // 'b'

// Object => Map
const map3 = toMap({a: 1, b: 2})
map3.get('a') // 1
map3.get('b') // 2

const toNumber = require('2/number')

toNumber('1.2') // 1.2
toNumber(Infinity) // 0
toNumber(NaN) // 0
toNumber('not a number') // 0

// Can specify a fallback other than zero:
toNumber('not a number', {elseReturn: 100}) // 100

// You can choose to throw an error for invalid inputs.
toNumber('not a number', {elseThrow: true}) // throws error
toNumber('not a number', {elseThrow: new TypeError('Not a number!')})

// Option to round floats:
toNumber('4.7') // 4.7
toNumber('4.7', {round: true}) // 5

// By default, Infinity is not considered a valid number,
// but this can be changed:
toNumber(Infinity) // 0
toNumber(Infinity, {finite: false}) // Infinity

// Number object => Number
const numberObject = new Number(123)
typeof numberObject // 'object'
typeof toNumber(numberObject) // 'number'

// Can parse strings that have digit grouping:
toNumber('1,234') // 1234
// The built-in Number function, on the other hand, cannot:
Number('1,234') // NaN

// Can be configured to interpret the comma as a decimal point:
toNumber('1,234', {decimalComma: true}) // 1.234

const toObject = require('2/object')

// Array of key/value pairs => Object
const obj1 = toObject([['a', 1], ['b', 2]])
obj1.a // 1
obj1.b // 2

// Array => Object
const obj2 = toObject(['first', 'second'])
Object.keys(obj2).length // 2
obj2[0] // 'first'
obj2[1] // 'second'

// In the above example, the array indices become the object keys.
// But you can make the keys mirror the values instead:
const obj3 = toObject(['first', 'second'], {mirror: true})
Object.keys(obj3).length // 2
obj3.first // 'first'
obj3.second // 'second'

// Map => Object
const map = new Map()
map.set('key1', 'value1')
map.set('key2', 'value2')
const obj4 = toObject(map)
obj4.key1 // 'value1'
obj4.key2 // 'value2'

// Duplicate keys
toObject([['key', 1], ['key', 2]]) // throws an error (default behavior)
const obj5 = toObject([['key', 1], ['key', 2]], {throwIfEquivKeys: false}) // error-throwing disabled
Object.keys(obj5).length // 1
obj5.key // 2

// Setting property descriptors
const obj6 = toObject([['a', 1], ['b', 2]], {descriptors: {enumerable: false}})
Object.keys(obj6).length // 0 (because the properties are non-enumerable)
obj6.a // 1
obj6.b // 2

const toString = require('2/string')

toString(123) // '123'
toString(-0) // '0'

toString(true) // ''
toString(false) // ''
toString(undefined) // ''
toString(null) // ''
toString(Infinity) // ''
toString(NaN) // ''
toString({}) // ''
toString([]) // ''
toString(function () {}) // ''
toString(Symbol('test')) // ''

// Compare the above to standard JavaScript string conversion:
String(true) // 'true'
String(false) // 'false'
String(undefined) // 'undefined'
String(null) // 'null'
String(Infinity) // 'Infinity'
String(NaN) // 'NaN'
String({}) // '[object Object]'
String([]) // ''
String(function () {}) // 'function () {}'
String(Symbol('test')) // 'Symbol(test)'

// Default fallback is an empty string, but you can change it:
toString(undefined) // ''
toString(undefined, {elseReturn: 'N/A'}) // 'N/A'

// You can choose to throw an error for invalid inputs.
toString(undefined, {elseThrow: true}) // throws error

// String object => String
const stringObject = new String('test')
typeof stringObject // 'object'
typeof toString(stringObject) // 'string'