"Fossies" - the Fresh Open Source Software Archive

Member "Atom/resources/app/apm/node_modules/es5-ext/CHANGES" (8 Mar 2017, 27608 Bytes) of archive /windows/misc/atom-windows.zip:


As a special service "Fossies" has tried to format the requested text file into HTML format (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file.

    1 v0.10.12  --  2016.07.01
    2 * Ensure symbols are copied in Object.mixin
    3 * Prevent RangeError errors in array#flatten
    4 * Do not validate invalidate dates in validDate
    5 
    6 v0.10.11  --  2015.12.18
    7 * Ensure that check for implementation of RegExp flags doesn't crash in V8 (thanks @mathiasbynens)
    8 
    9 v0.10.10  --  2015.12.11
   10 * Add Object.isNumberValue util
   11 
   12 v0.10.9  --  2015.12.01
   13 * Add Object.ensureNaturalNumber and Object.ensureNaturalNumberValue
   14 
   15 v0.10.8  --  2015.10.02
   16 * Add Number.isNatural
   17 * Add Object.find and Object.findKey
   18 * Support arrays in Object.copyDeep
   19 * Fix iteration issue in forEachRight and someRight
   20 * Fix detection of native sinh
   21 * Depend on es6-symbol v3
   22 
   23 v0.10.7  --  2015.04.22
   24 * New utlitities. They're convention differs from v0.10, as they were supposed to land in v1.
   25   Still they're non breaking and start the conventions to be used in v1
   26   * Object.validateArrayLike
   27   * Object.validateArrayLikeObject
   28   * Object.validateStringifiable
   29   * Object.validateStringifiableValue
   30   * Universal utilities for array-like/iterable objects
   31     * Iterable.is
   32     * Iterable.validate
   33     * Iterable.validateObject
   34     * Iterable.forEach
   35 * Fix camelToHyphen resolution, it must be absolutely reversable by hyphenToCamel
   36 * Fix calculations of large numbers in Math.tanh
   37 * Fix algorithm of Math.sinh
   38 * Fix indexes to not use real symbols
   39 * Fix length of String.fromCodePoint
   40 * Fix tests of Array#copyWithin
   41 * Update Travis CI configuration
   42 
   43 v0.10.6  --  2015.02.02
   44 * Fix handling of infinite values in Math.trunc
   45 * Fix handling of getters in Object.normalizeOptions
   46 
   47 v0.10.5  --  2015.01.20
   48 * Add Function#toStringTokens
   49 * Add Object.serialize and Object.unserialize
   50 * Add String.randomUniq
   51 * Fix Strin#camelToHyphen issue with tokens that end with digit
   52 * Optimise Number.isInteger logic
   53 * Improve documentation
   54 * Configure lint scripts
   55 * Fix spelling of LICENSE
   56 
   57 v0.10.4  --  2014.04.30
   58 * Assure maximum spec compliance of Array.of and Array.from (thanks @mathiasbynens)
   59 * Improve documentations
   60 
   61 v0.10.3  --  2014.04.29
   62 Provide accurate iterators handling:
   63 * Array.from improvements:
   64   * Assure right unicode symbols resolution when processing strings in Array.from
   65   * Rely on ES6 symbol shim and use native @@iterator Symbol if provided by environment
   66 * Add methods:
   67   * Array.prototype.entries
   68   * Array.prototype.keys
   69   * Array.prototype.values
   70   * Array.prototype[@@iterator]
   71   * String.prototype[@@iterator]
   72 
   73 Improve documentation
   74 
   75 v0.10.2  --  2014.04.24
   76 - Simplify and deprecate `isCallable`. It seems in ES5 based engines there are
   77   no callable objects which are `typeof obj !== 'function'`
   78 - Update Array.from map callback signature (up to latest resolution of TC39)
   79 - Improve documentation
   80 
   81 v0.10.1  --  2014.04.14
   82 Bump version for npm
   83 (Workaround for accidental premature publish & unpublish of v0.10.0 a while ago)
   84 
   85 v0.10.0  --  2014.04.13
   86 Major update:
   87 - All methods and function specified for ECMAScript 6 are now introduced as
   88   shims accompanied with functions through which (optionally) they can be
   89   implementend on native objects
   90 - Filename convention was changed to shorter and strictly lower case names. e.g.
   91   `lib/String/prototype/starts-with` became `string/#/starts-with`
   92 - Generated functions are guaranteed to have expected length
   93 - Objects with null prototype (created via `Object.create(null)`) are widely
   94   supported (older version have crashed due to implied `obj.hasOwnProperty` and
   95   related invocations)
   96 - Support array subclasses
   97 - When handling lists do not limit its length to Uint32 range
   98 - Use newly introduced `Object.eq` for strict equality in place of `Object.is`
   99 - Iteration of Object have been improved so properties that were hidden or
  100   removed after iteration started are not iterated.
  101 
  102 Additions:
  103 - `Array.isPlainArray`
  104 - `Array.validArray`
  105 - `Array.prototype.concat` (as updated with ES6)
  106 - `Array.prototype.copyWithin` (as introduced with ES6)
  107 - `Array.prototype.fill` (as introduced with ES6)
  108 - `Array.prototype.filter` (as updated with ES6)
  109 - `Array.prototype.findIndex` (as introduced with ES6)
  110 - `Array.prototype.map` (as updated with ES6)
  111 - `Array.prototype.separate`
  112 - `Array.prototype.slice` (as updated with ES6)
  113 - `Array.prototype.splice` (as updated with ES6)
  114 - `Function.prototype.copy`
  115 - `Math.acosh` (as introduced with ES6)
  116 - `Math.atanh` (as introduced with ES6)
  117 - `Math.cbrt` (as introduced with ES6)
  118 - `Math.clz32` (as introduced with ES6)
  119 - `Math.cosh` (as introduced with ES6)
  120 - `Math.expm1` (as introduced with ES6)
  121 - `Math.fround` (as introduced with ES6)
  122 - `Math.hypot` (as introduced with ES6)
  123 - `Math.imul` (as introduced with ES6)
  124 - `Math.log2` (as introduced with ES6)
  125 - `Math.log10` (as introduced with ES6)
  126 - `Math.log1p` (as introduced with ES6)
  127 - `Math.sinh` (as introduced with ES6)
  128 - `Math.tanh` (as introduced with ES6)
  129 - `Math.trunc` (as introduced with ES6)
  130 - `Number.EPSILON` (as introduced with ES6)
  131 - `Number.MIN_SAFE_INTEGER` (as introduced with ES6)
  132 - `Number.MAX_SAFE_INTEGER` (as introduced with ES6)
  133 - `Number.isFinite` (as introduced with ES6)
  134 - `Number.isInteger` (as introduced with ES6)
  135 - `Number.isSafeInteger` (as introduced with ES6)
  136 - `Object.create` (with fix for V8 issue which disallows prototype turn of
  137   objects derived from null
  138 - `Object.eq` - Less restrictive version of `Object.is` based on SameValueZero
  139   algorithm
  140 - `Object.firstKey`
  141 - `Object.keys` (as updated with ES6)
  142 - `Object.mixinPrototypes`
  143 - `Object.primitiveSet`
  144 - `Object.setPrototypeOf` (as introduced with ES6)
  145 - `Object.validObject`
  146 - `RegExp.escape`
  147 - `RegExp.prototype.match` (as introduced with ES6)
  148 - `RegExp.prototype.replace` (as introduced with ES6)
  149 - `RegExp.prototype.search` (as introduced with ES6)
  150 - `RegExp.prototype.split` (as introduced with ES6)
  151 - `RegExp.prototype.sticky` (as introduced with ES6)
  152 - `RegExp.prototype.unicode` (as introduced with ES6)
  153 - `String.fromCodePoint` (as introduced with ES6)
  154 - `String.raw` (as introduced with ES6)
  155 - `String.prototype.at`
  156 - `String.prototype.codePointAt` (as introduced with ES6)
  157 - `String.prototype.normalize` (as introduced with ES6)
  158 - `String.prototype.plainReplaceAll`
  159 
  160 Removals:
  161 - `reserved` set
  162 - `Array.prototype.commonLeft`
  163 - `Function.insert`
  164 - `Function.remove`
  165 - `Function.prototype.silent`
  166 - `Function.prototype.wrap`
  167 - `Object.descriptor` Move to external `d` project.
  168   See: https://github.com/medikoo/d
  169 - `Object.diff`
  170 - `Object.extendDeep`
  171 - `Object.reduce`
  172 - `Object.values`
  173 - `String.prototype.trimCommonLeft`
  174 
  175 Renames:
  176 - `Function.i` into `Function.identity`
  177 - `Function.k` into `Function.constant`
  178 - `Number.toInt` into `Number.toInteger`
  179 - `Number.toUint` into `Number.toPosInteger`
  180 - `Object.extend` into `Object.assign` (as introduced in ES 6)
  181 - `Object.extendProperties` into `Object.mixin`, with improved internal
  182   handling, so it matches temporarily specified `Object.mixin` for ECMAScript 6
  183 - `Object.isList` into `Object.isArrayLike`
  184 - `Object.mapToArray` into `Object.toArray` (with fixed function length)
  185 - `Object.toPlainObject` into `Object.normalizeOptions` (as this is the real
  186   use case where we use this function)
  187 - `Function.prototype.chain` into `Function.prototype.compose`
  188 - `Function.prototype.match` into `Function.prototype.spread`
  189 - `String.prototype.format` into `String.formatMethod`
  190 
  191 Improvements & Fixes:
  192 - Remove workaround for primitive values handling in object iterators
  193 - `Array.from`: Update so it follows ES 6 spec
  194 - `Array.prototype.compact`: filters just null and undefined values
  195   (not all falsies)
  196 - `Array.prototype.eIndexOf` and `Array.prototype.eLastIndexOf`: fix position
  197   handling, improve internals
  198 - `Array.prototype.find`: return undefined not null, in case of not found
  199   (follow ES 6)
  200 - `Array.prototype.remove` fix function length
  201 - `Error.custom`: simplify, Custom class case is addressed by outer
  202   `error-create` project -> https://github.com/medikoo/error-create
  203 - `Error.isError` true only for Error instances (remove detection of host
  204   Exception objects)
  205 - `Number.prototype.pad`: Normalize negative pad
  206 - `Object.clear`: Handle errors same way as in `Object.assign`
  207 - `Object.compact`: filters just null and undefined values (not all falsies)
  208 - `Object.compare`: Take into account NaN values
  209 - `Object.copy`: Split into `Object.copy` and `Object.copyDeep`
  210 - `Object.isCopy`: Separate into `Object.isCopy` and `Object.isCopyDeep`, where
  211   `isCopyDeep` handles nested plain objects and plain arrays only
  212 - `String.prototype.endsWith`: Adjust up to ES6 specification
  213 - `String.prototype.repeat`: Adjust up to ES6 specification and improve algorithm
  214 - `String.prototype.simpleReplace`: Rename into `String.prototype.plainReplace`
  215 - `String.prototype.startsWith`: Adjust up to ES6 specification
  216 - Update lint rules, and adjust code to that
  217 - Update Travis CI configuration
  218 - Remove Makefile (it's cross-env utility)
  219 
  220 v0.9.2  --  2013.03.11
  221 Added:
  222 * Array.prototype.isCopy
  223 * Array.prototype.isUniq
  224 * Error.CustomError
  225 * Function.validFunction
  226 * Object.extendDeep
  227 * Object.descriptor.binder
  228 * Object.safeTraverse
  229 * RegExp.validRegExp
  230 * String.prototype.capitalize
  231 * String.prototype.simpleReplace
  232 
  233 Fixed:
  234 * Fix Array.prototype.diff for sparse arrays
  235 * Accept primitive objects as input values in Object iteration methods and
  236   Object.clear, Object.count, Object.diff, Object.extend,
  237   Object.getPropertyNames, Object.values
  238 * Pass expected arguments to callbacks of Object.filter, Object.mapKeys,
  239   Object.mapToArray, Object.map
  240 * Improve callable callback support in Object.mapToArray
  241 
  242 v0.9.1  --  2012.09.17
  243 * Object.reduce - reduce for hash-like collections
  244 * Accapt any callable object as callback in Object.filter, mapKeys and map
  245 * Convention cleanup
  246 
  247 v0.9.0  --  2012.09.13
  248 We're getting to real solid API
  249 
  250 Removed:
  251 * Function#memoize - it's grown up to be external package, to be soon published
  252   as 'memoizee'
  253 * String.guid - it doesn't fit es5-ext (extensions) concept, will be provided as
  254   external package
  255 # Function.arguments - obsolete
  256 # Function.context - obsolete
  257 # Function#flip - not readable when used, so it was never used
  258 # Object.clone - obsolete and confusing
  259 
  260 Added:
  261 * String#camelToHyphen - String format convertion
  262 
  263 Renamed:
  264 * String#dashToCamelCase -> String#hyphenToCamel
  265 
  266 Fixes:
  267 * Object.isObject - Quote names in literals that match reserved keywords
  268   (older implementations crashed on that)
  269 * String#repeat - Do not accept negative values (coerce them to 1)
  270 
  271 Improvements:
  272 * Array#remove - Accepts many arguments, we can now remove many values at once
  273 * Object iterators (forEach, map, some) - Compare function invoked with scope
  274   object bound to this
  275 * Function#curry - Algorithm cleanup
  276 * Object.isCopy - Support for all types, not just plain objects
  277 * Object.isPlainObject - Support for cross-frame objects
  278 * Do not memoize any of the functions, it shouldn't be decided internally
  279 * Remove Object.freeze calls in reserved, it's not up to convention
  280 * Improved documentation
  281 * Better linting (hard-core approach using both JSLint mod and JSHint)
  282 * Optional arguments are now documented in funtions signature
  283 
  284 v0.8.2  --  2012.06.22
  285 Fix errors in Array's intersection and exclusion methods, related to improper
  286 usage of contains method
  287 
  288 v0.8.1  --  2012.06.13
  289 Reorganized internal logic of Function.prototype.memoize. So it's more safe now
  290 and clears cache properly. Additionally preventCache option was provided.
  291 
  292 v0.8.0  --  2012.05.28
  293 Again, major overhaul. Probably last experimental stuff was trashed, all API
  294 looks more like standard extensions now.
  295 
  296 Changes:
  297 * Turn all Object.prototype extensions into functions and move them to Object
  298 namespace. We learned that extending Object.prototype is bad idea in any case.
  299 * Rename Function.prototype.curry into Function.prototype.partial. This function
  300   is really doing partial application while currying is slightly different
  301   concept.
  302 * Convert Function.prototype.ncurry to new implementation of
  303   Function.prototype.curry, it now serves real curry concept additionaly it
  304   covers use cases for aritize and hold, which were removed.
  305 * Rename Array's peek to last, and provide support for sparse arrays in it
  306 * Rename Date's monthDaysCount into daysInMonth
  307 * Simplify object iterators, now order of iteration can be configured with just
  308   compareFn argument (no extra byKeys option)
  309 * Rename Object.isDuplicate to Object.isCopy
  310 * Rename Object.isEqual to Object.is which is compatible with future 'is'
  311   keyword
  312 * Function.memoize is now Function.prototype.memoize. Additionally clear cache
  313   functionality is added, and access to original arguments object.
  314 * Rename validation functions: assertNotNull to validValue, assertCallable to
  315   validCallable. validValue was moved to Object namespace. On success they now
  316   return validated value instead of true, it supports better composition.
  317   Additionally created Date.validDate and Error.validError
  318 * All documentation is now held in README.md not in code files.
  319 * Move guid to String namespace. All guids now start with numbers.
  320 * Array.generate: fill argument is now optional
  321 * Object.toArray is now Array.from (as new ES6 specification draft suggests)
  322 * All methods that rely on indexOf or lastIndexOf, now rely on egal (Object.is)
  323   versions of them (eIndexOf, eLastIndexOf)
  324 * Turn all get* functions that returned methods into actuall methods (get*
  325   functionality can still be achieved with help of Function.prototype.partial).
  326   So: Date.getFormat is now Date.prototype.format,
  327   Number.getPad is now Number.prototype.pad,
  328   String.getFormat is now String.prototype.format,
  329   String.getIndent is now String.prototype.indent,
  330   String.getPad is now String.prototype.pad
  331 * Refactored Object.descriptor, it is now just two functions, main one and
  332   main.gs, main is for describing values, and gs for describing getters and
  333   setters. Configuration is passed with first argument as string e.g. 'ce' for
  334   configurable and enumerable. If no configuration string is provided then by
  335   default it returns configurable and writable but not enumerable for value or
  336   configurable but not enumerable for getter/setter
  337 * Function.prototype.silent now returns prepared function (it was
  338   expected to be fixed for 0.7)
  339 * Reserved keywords map (reserved) is now array not hash.
  340 * Object.merge is now Object.extend (while former Object.extend was completely
  341   removed) - 'extend' implies that we change object, not creating new one (as
  342   'merge' may imply). Similarily Object.mergeProperties was renamed to
  343   Object.extendProperties
  344 * Position argument support in Array.prototype.contains and
  345   String.prototype.contains (so it follows ES6 specification draft)
  346 * endPosition argument support in String.prototype.endsWith and fromPosition
  347   argument support in String.prototype.startsWith (so it follows ES6
  348   specification draft)
  349 * Better and cleaner String.prototype.indent implementation. No default value
  350   for indent string argument, optional nest value (defaults to 1), remove
  351   nostart argument
  352 * Correct length values for most methods (so they reflect length of similar
  353   methods in standard)
  354 * Length argument is now optional in number and string pad methods.
  355 * Improve arguments validation in general, so it adheres to standard conventions
  356 * Fixed format of package.json
  357 
  358 Removed methods and functions:
  359 * Object.prototype.slice - Object is not ordered collection, so slice doesn't
  360   make sense.
  361 * Function's rcurry, rncurry, s - too cumbersome for JS, not many use cases for
  362   that
  363 * Function.prototype.aritize and Function.prototype.hold - same functionality
  364   can be achieved with new Function.prototype.curry
  365 * Function.prototype.log - provided more generic Function.prototype.wrap for
  366   same use case
  367 * getNextIdGenerator - no use case for that (String.guid should be used if
  368   needed)
  369 * Object.toObject - Can be now acheived with Object(validValue(x))
  370 * Array.prototype.someValue - no real use case (personally used once and
  371   case was already controversial)
  372 * Date.prototype.duration - moved to external package
  373 * Number.getAutoincrement - No real use case
  374 * Object.prototype.extend, Object.prototype.override,
  375   Object.prototype.plainCreate, Object.prototype.plainExtend - It was probably
  376   too complex, same should be achieved just with Object.create,
  377   Object.descriptor and by saving references to super methods in local scope.
  378 * Object.getCompareBy - Functions should be created individually for each use
  379   case
  380 * Object.get, Object.getSet, Object.set, Object.unset - Not many use cases and
  381   same can be easily achieved with simple inline function
  382 * String.getPrefixWith - Not real use case for something that can be easily
  383   achieved with '+' operator
  384 * Object.isPrimitive - It's just negation of Object.isObject
  385 * Number.prototype.isLess, Number.prototype.isLessOrEqual - they shouldn't be in
  386   Number namespace and should rather be addressed with simple inline functions.
  387 * Number.prototype.subtract - Should rather be addressed with simple inline
  388   function
  389 
  390 New methods and functions:
  391 * Array.prototype.lastIndex - Returns last declared index in array
  392 * String.prototype.last - last for strings
  393 * Function.prototype.wrap - Wrap function with other, it allows to specify
  394   before and after behavior transform return value or prevent original function
  395   from being called.
  396 * Math.sign - Returns sign of a number (already in ES6 specification draft)
  397 * Number.toInt - Converts value to integer (already in ES6 specification draft)
  398 * Number.isNaN - Returns true if value is NaN (already in ES6 specification
  399   draft)
  400 * Number.toUint - Converts value to unsigned integer
  401 * Number.toUint32 - Converts value to 32bit unsigned integer
  402 * Array.prototype.eIndexOf, eLastIndexOf - Egal version (that uses Object.is) of
  403   standard methods (all methods that were using native indexOf or lastIndexOf
  404   now uses eIndexOf and elastIndexOf respectively)
  405 * Array.of - as it's specified for ES6
  406 
  407 Fixes:
  408 * Fixed binarySearch so it always returns valid list index
  409 * Object.isList - it failed on lists that are callable (e.g. NodeList in Nitro
  410   engine)
  411 * Object.map now supports third argument for callback
  412 
  413 v0.7.1  --  2012.01.05
  414 New methods:
  415 * Array.prototype.firstIndex - returns first valid index of array (for
  416 	sparse arrays it may not be '0'
  417 
  418 Improvements:
  419 * Array.prototype.first - now returns value for index returned by firstIndex
  420 * Object.prototype.mapToArray - can be called without callback, then array of
  421 	key-value pairs is returned
  422 
  423 Fixes
  424 * Array.prototype.forEachRight, object's length read through UInt32 conversion
  425 
  426 v0.7.0  --  2011.12.27
  427 Major update.
  428 Stepped back from experimental ideas and introduced more standard approach
  429 taking example from how ES5 methods and functions are designed. One exceptions
  430 is that, we don’t refrain from declaring methods for Object.prototype - it’s up
  431 to developer whether how he decides to use it in his context (as function or as
  432 method).
  433 
  434 In general:
  435 * Removed any method 'functionalization' and functionalize method itself.
  436 	es5-ext declares plain methods, which can be configured to work as functions
  437 	with call.bind(method) - see documentation.
  438 * Removed separation of Object methods for ES5 (with descriptors) and
  439 	ES3 (plain) - we're following ES5 idea on that, some methods are intended just
  440 	for enumerable properties and some are for all properties, all are declared
  441 	for Object.prototype
  442 * Removed separation of Array generic (collected in List folder) and not generic
  443 	methods (collected in Array folder). Now all methods are generic and are in
  444 	Array/prototype folder. This separation also meant, that methods in Array are
  445 	usually destructive. We don’t do that separation now, there’s generally no use
  446 	case for destructive iterators, we should be fine with one version of each
  447 	method, (same as ES5 is fine with  e.g. one, non destructive 'filter' method)
  448 * Folder structure resembles tree of native ES5 Objects
  449 * All methods are written with ES5 conventions in mind, it means that most
  450 	methods are generic and can be run on any object. In more detail:
  451 	** Array.prototype and Object.prototype methods can be run on any object (any
  452 		not null or undefined value),
  453 	** Date.prototype methods should be called only on Date instances.
  454 	** Function.prototype methods can be called on any callable objects (not
  455 		necessarily functions)
  456 	** Number.prototype & String.prototype methods can be called on any value, in
  457 		case of Number it it’ll be degraded to number, in case of string it’ll be
  458 		degraded to string.
  459 * Travis CI support (only for Node v0.6 branch, as v0.4 has buggy V8 version)
  460 
  461 Improvements for existing functions and methods:
  462 * Function.memoize (was Function.cache) is now fully generic, can operate on any
  463 	type of arguments and it’s NaN safe (all NaN objects are considered equal)
  464 * Method properties passed to Object.prototype.extend or
  465 	Object.prototype.override can aside of _super optionally take prototype object
  466 	via _proto argument
  467 * Object iterators: forEach, mapToArray and every can now iterate in specified
  468 	order
  469 * pluck, invoke and other functions that return reusable functions or methods
  470 	have now their results memoized.
  471 
  472 New methods:
  473 * Global: assertNotNull, getNextIdGenerator, guid, isEqual, isPrimitive,
  474 	toObject
  475 * Array: generate
  476 * Array.prototype: binarySearch, clear, contains, diff, exclusion, find, first,
  477 	forEachRight, group, indexesOf, intersection, remove, someRight, someValue
  478 * Boolean: isBoolean
  479 * Date: isDate
  480 * Function: arguments, context, insert, isArguments, remove
  481 * Function.prototype: not, silent
  482 * Number: getAutoincrement, isNumber
  483 * Number.prototype: isLessOrEqual, isLess, subtract
  484 * Object: assertCallable, descriptor (functions for clean descriptors),
  485 	getCompareBy, isCallable, isObject
  486 * Object.prototype: clone (real clone), compact, count, diff, empty,
  487 	getPropertyNames, get, keyOf, mapKeys, override, plainCreate, plainExtend,
  488 	slice, some, unset
  489 * RegExp: isRegExp
  490 * String: getPrefixWith, isString
  491 * String.prototype: caseInsensitiveCompare, contains, isNumeric
  492 
  493 Renamed methods:
  494 * Date.clone -> Date.prototype.copy
  495 * Date.format -> Date.getFormat
  496 * Date/day/floor -> Date.prototype.floorDay
  497 * Date/month/floor -> Date.prototype.floorMonth
  498 * Date/month/year -> Date.prototype.floorYear
  499 * Function.cache -> Function.memoize
  500 * Function.getApplyArg -> Function.prototype.match
  501 * Function.sequence -> Function.prototype.chain
  502 * List.findSameStartLength -> Array.prototype.commonLeft
  503 * Number.pad -> Number.getPad
  504 * Object/plain/clone -> Object.prototype.copy
  505 * Object/plain/elevate -> Object.prototype.flatten
  506 * Object/plain/same -> Object.prototype.isDuplicate
  507 * Object/plain/setValue -> Object.getSet
  508 * String.format -> String.getFormat
  509 * String.indent -> String.getIndent
  510 * String.pad -> String.getPad
  511 * String.trimLeftStr -> String.prototype.trimCommonLeft
  512 * Object.merge -> Object.prototype.mergeProperties
  513 * Object/plain/pluck -> Object.prototype.get
  514 * Array.clone is now Array.prototype.copy and can be used also on any array-like
  515 	objects
  516 * List.isList -> Object.isList
  517 * List.toArray -> Object.prototype.toArray
  518 * String/convert/dashToCamelCase -> String.prototype.dashToCamelCase
  519 
  520 Removed methods:
  521 * Array.compact - removed destructive version (that operated on same array), we
  522 	have now non destructive version as Array.prototype.compact.
  523 * Function.applyBind -> use apply.bind directly
  524 * Function.bindBind -> use bind.bind directly
  525 * Function.callBind -> use call.bind directly
  526 * Fuction.clone -> no valid use case
  527 * Function.dscope -> controversial approach, shouldn’t be considered seriously
  528 * Function.functionalize -> It was experimental but standards are standards
  529 * List/sort/length -> It can be easy obtained by Object.getCompareBy(‘length’)
  530 * List.concat -> Concat’s for array-like’s makes no sense, just convert to array
  531 	first
  532 * List.every -> Use Array.prototype.every directly
  533 * List.filter -> Use Array.prototype.filter directly
  534 * List.forEach -> User Array.prototype.forEach directly
  535 * List.isListObject -> No valid use case, do: isList(list) && (typeof list ===
  536 	'object’)
  537 * List.map -> Use Array.prototype.map directly
  538 * List.reduce -> Use Array.prototype.reduce directly
  539 * List.shiftSame -> Use Array.prototype.commonLeft and do slice
  540 * List.slice -> Use Array.prototype.slice directly
  541 * List.some -> Use Array.prototype.some directly
  542 * Object.bindMethods -> it was version that considered descriptors, we have now
  543 	Object.prototype.bindMethods which operates only on enumerable properties
  544 * Object.every -> version that considered all properties, we have now
  545 	Object.prototype.every which iterates only enumerables
  546 * Object.invoke -> no use case
  547 * Object.mergeDeep -> no use case
  548 * Object.pluck -> no use case
  549 * Object.same -> it considered descriptors, now there’s only Object.isDuplicate
  550 	which compares only enumerable properties
  551 * Object.sameType -> no use case
  552 * Object.toDescriptor and Object.toDescriptors -> replaced by much nicer
  553 	Object.descriptor functions
  554 * Object/plain/link -> no use case (it was used internally only by
  555 	Object/plain/merge)
  556 * Object/plain/setTrue -> now easily configurable by more universal
  557 	Object.getSet(true)
  558 * String.trimRightStr -> Eventually String.prototype.trimCommonRight will be
  559 	added
  560 
  561 v0.6.3  --  2011.12.12
  562 * Cleared npm warning for misnamed property in package.json
  563 
  564 v0.6.2  --  2011.08.12
  565 * Calling String.indent without scope (global scope then) now treated as calling
  566   it with null scope, it allows more direct invocations when using default nest
  567   string: indent().call(str, nest)
  568 
  569 v0.6.1  --  2011.08.08
  570 * Added TAD test suite to devDependencies, configured test commands.
  571   Tests can be run with 'make test' or 'npm test'
  572 
  573 v0.6.0  --  2011.08.07
  574 New methods:
  575 * Array: clone, compact (in place)
  576 * Date: format, duration, clone, monthDaysCount, day.floor, month.floor,
  577   year.floor
  578 * Function: getApplyArg, , ncurry, rncurry, hold, cache, log
  579 * List: findSameStartLength, shiftSame, peek, isListObject
  580 * Number: pad
  581 * Object: sameType, toString, mapToArray, mergeDeep, toDescriptor,
  582   toDescriptors, invoke
  583 * String: startsWith, endsWith, indent, trimLeftStr, trimRightStr, pad, format
  584 
  585 Fixed:
  586 * Object.extend does now prototypal extend as exptected
  587 * Object.merge now tries to overwrite only configurable properties
  588 * Function.flip
  589 
  590 Improved:
  591 * Faster List.toArray
  592 * Better global retrieval
  593 * Functionalized all Function methods
  594 * Renamed bindApply and bindCall to applyBind and callBind
  595 * Removed Function.inherit (as it's unintuitive curry clone)
  596 * Straightforward logic in Function.k
  597 * Fixed naming of some tests files (letter case issue)
  598 * Renamed Function.saturate into Function.lock
  599 * String.dashToCamelCase digits support
  600 * Strings now considered as List objects
  601 * Improved List.compact
  602 * Concise logic for List.concat
  603 * Test wit TAD in clean ES5 context
  604 
  605 v0.5.1  --  2011.07.11
  606 * Function's bindBind, bindCall and bindApply now more versatile
  607 
  608 v0.5.0  --  2011.07.07
  609 * Removed Object.is and List.apply
  610 * Renamed Object.plain.is to Object.plain.isPlainObject (keep naming convention
  611   consistent)
  612 * Improved documentation
  613 
  614 v0.4.0  --  2011.07.05
  615 * Take most functions on Object to Object.plain to keep them away from object
  616   descriptors
  617 * Object functions with ES5 standard in mind (object descriptors)
  618 
  619 v0.3.0  --  2011.06.24
  620 * New functions
  621 * Consistent file naming (dash instead of camelCase)
  622 
  623 v0.2.1  --  2011.05.28
  624 * Renamed Functions.K and Function.S to to lowercase versions (use consistent
  625   naming)
  626 
  627 v0.2.0  --  2011.05.28
  628 * Renamed Array folder to List (as its generic functions for array-like objects)
  629 * Added Makefile
  630 * Added various functions
  631 
  632 v0.1.0  --  2011.05.24
  633 * Initial version