2 * Ensure symbols are copied in Object.mixin
3 * Prevent RangeError errors in array#flatten
4 * Do not validate invalidate dates in validDate
7 * Ensure that check for implementation of RegExp flags doesn't crash in V8 (thanks @mathiasbynens)
10 * Add Object.isNumberValue util
13 * Add Object.ensureNaturalNumber and Object.ensureNaturalNumberValue
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
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
33 * Iterable.validateObject
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
44 * Fix handling of infinite values in Math.trunc
45 * Fix handling of getters in Object.normalizeOptions
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
58 * Assure maximum spec compliance of Array.of and Array.from (thanks @mathiasbynens)
59 * Improve documentations
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
67 * Array.prototype.entries
68 * Array.prototype.keys
69 * Array.prototype.values
70 * Array.prototype[@@iterator]
71 * String.prototype[@@iterator]
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
83 (Workaround for accidental premature publish & unpublish of v0.10.0 a while ago)
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
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.
103 - `Array.isPlainArray`
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
141 - `Object.keys` (as updated with ES6)
142 - `Object.mixinPrototypes`
143 - `Object.primitiveSet`
144 - `Object.setPrototypeOf` (as introduced with ES6)
145 - `Object.validObject`
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`
162 - `Array.prototype.commonLeft`
165 - `Function.prototype.silent`
166 - `Function.prototype.wrap`
167 - `Object.descriptor` Move to external `d` project.
168 See: https://github.com/medikoo/d
170 - `Object.extendDeep`
173 - `String.prototype.trimCommonLeft`
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`
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
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
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
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)
222 * Array.prototype.isCopy
223 * Array.prototype.isUniq
225 * Function.validFunction
227 * Object.descriptor.binder
228 * Object.safeTraverse
230 * String.prototype.capitalize
231 * String.prototype.simpleReplace
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
243 * Object.reduce - reduce for hash-like collections
244 * Accapt any callable object as callback in Object.filter, mapKeys and map
248 We're getting to real solid API
251 * Function#memoize - it's grown up to be external package, to be soon published
253 * String.guid - it doesn't fit es5-ext (extensions) concept, will be provided as
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
261 * String#camelToHyphen - String format convertion
264 * String#dashToCamelCase -> String#hyphenToCamel
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)
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
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
285 Fix errors in Array's intersection and exclusion methods, related to improper
286 usage of contains method
289 Reorganized internal logic of Function.prototype.memoize. So it's more safe now
290 and clears cache properly. Additionally preventCache option was provided.
293 Again, major overhaul. Probably last experimental stuff was trashed, all API
294 looks more like standard extensions now.
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
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'
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
349 * Better and cleaner String.prototype.indent implementation. No default value
350 for indent string argument, optional nest value (defaults to 1), remove
352 * Correct length values for most methods (so they reflect length of similar
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
358 Removed methods and functions:
359 * Object.prototype.slice - Object is not ordered collection, so slice doesn't
361 * Function's rcurry, rncurry, s - too cumbersome for JS, not many use cases for
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
367 * getNextIdGenerator - no use case for that (String.guid should be used if
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
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
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
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
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
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
411 * Object.map now supports third argument for callback
415 * Array.prototype.firstIndex - returns first valid index of array (for
416 sparse arrays it may not be '0'
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
424 * Array.prototype.forEachRight, object's length read through UInt32 conversion
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
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
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
459 * Travis CI support (only for Node v0.6 branch, as v0.4 has buggy V8 version)
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
467 * Object iterators: forEach, mapToArray and every can now iterate in specified
469 * pluck, invoke and other functions that return reusable functions or methods
470 have now their results memoized.
473 * Global: assertNotNull, getNextIdGenerator, guid, isEqual, isPrimitive,
476 * Array.prototype: binarySearch, clear, contains, diff, exclusion, find, first,
477 forEachRight, group, indexesOf, intersection, remove, someRight, someValue
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,
490 * String: getPrefixWith, isString
491 * String.prototype: caseInsensitiveCompare, contains, isNumeric
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
516 * List.isList -> Object.isList
517 * List.toArray -> Object.prototype.toArray
518 * String/convert/dashToCamelCase -> String.prototype.dashToCamelCase
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
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 ===
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
556 * Object/plain/setTrue -> now easily configurable by more universal
558 * String.trimRightStr -> Eventually String.prototype.trimCommonRight will be
562 * Cleared npm warning for misnamed property in package.json
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)
570 * Added TAD test suite to devDependencies, configured test commands.
571 Tests can be run with 'make test' or 'npm test'
575 * Array: clone, compact (in place)
576 * Date: format, duration, clone, monthDaysCount, day.floor, month.floor,
578 * Function: getApplyArg, , ncurry, rncurry, hold, cache, log
579 * List: findSameStartLength, shiftSame, peek, isListObject
581 * Object: sameType, toString, mapToArray, mergeDeep, toDescriptor,
582 toDescriptors, invoke
583 * String: startsWith, endsWith, indent, trimLeftStr, trimRightStr, pad, format
586 * Object.extend does now prototypal extend as exptected
587 * Object.merge now tries to overwrite only configurable properties
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
606 * Function's bindBind, bindCall and bindApply now more versatile
609 * Removed Object.is and List.apply
610 * Renamed Object.plain.is to Object.plain.isPlainObject (keep naming convention
612 * Improved documentation
615 * Take most functions on Object to Object.plain to keep them away from object
617 * Object functions with ES5 standard in mind (object descriptors)
621 * Consistent file naming (dash instead of camelCase)
624 * Renamed Functions.K and Function.S to to lowercase versions (use consistent
628 * Renamed Array folder to List (as its generic functions for array-like objects)
630 * Added various functions
Code Review / simantics / district.git / blob