Modified the language grammar to split out the parameters rule into two rules, parameters which only allows a catalog, and arguments which only allows a list. Components are still parameterized, but functions and messages take arguments instead of parameters. Changed the indices rule to allow either a list of keys or a range of keys.
Removed an indentation option of -1 for inlining and removed Angle.toDegrees(), Angle.toRadians(), Binary.toBaseXX(), Complex.toRectangular(), and Complex.toPolar() methods.
Added missing toArray() method to bali.Tree class.
Removed the setParameters() method from the Component class.
Removed the bali.literal() function from the interface.
Fixed bugs in bali.Catalog.concatenation() and bali.Catalog.extraction() where the catalog parameters were not being preserved in the resulting catalog.
Changed the bali.catalog({...}) function to allow object key strings that don't include the '$' prefix. The function now inserts the '$' as needed. This makes example code more understandable to traditional javascript programmers who are not used to seeing object keys beginning with '$'.
Changed formatter indentation parameter from a string containing the indentation to a number representing the number of levels to indent the top level.
Added the ability to do inline formatting by passing a value of -1 as the indentation parameter to the formatter.
Fixed bug in language grammar that did not accept a zero as the last decimal of a fraction. This affected the bali.Probability, bali.Number, bali.Percentage, bali.Moment, and bali.Duration element types.
Reversed the order of the parameters in the bali.Set() constructor to be consistent with other collections and fix a bug in the bali.Collection.getItems() method. Also fixed bugs in bali.Set, bali.Stack and bali.Queue constructors where the type of the collection was not getting set in the parameters.
Added a bali.Duplicator class for doing deep copies of components.
Fixed bug with the bali.Formatter which couldn't handle parameters containing a bali.Range as its collection.
Moved the Component.getType() method out of this project since it really belongs in the bali-virtual-machine project.
Added a Parser.parseComponent() method for parsing a single component from a string containing multiple components rather than a document containing just one component.
Changed bali.Moment class to default to UTC timezone for all times.
Replaced all throw new Error() statements with throw new utilities.Exception() to make exception handling consistent throughout and much easier to understand what is causing an exception.
Added encoding and decoding of the '#' character in the body of a bali.Reference containing a citation. Otherwise, the string after the hash character is interpreted as the URI fragment.
Added getters to the bali.Reference class for the different components of the URI.
Refactored the top level index.js file to provide a much simpler and easy to use interface to all of the component classes and utilities.
Moved all formatting into the bali.Formatter class instead of having formatting functionality in the element classes. The parser and formatter are now completely symmetrical.
Changed the bali.Formatter to calculate the inlining on the fly instead of the less accurate way based on pre-calculated complexities of each component.
Made all private attributes hidden by defining the methods that use them in the constructor rather than on the prototype.
Replaced the precision constants PI, E, and PHI with Math.PI, Math.E and a new Math.PHI constant.
Added implementation of baliDuration.inverse(duration) and associated unit tests.
Added functions to the bali.Moment class.
Fixed bugs in the bali.Comparator class. It wasn't handling booleans and numbers correctly.
Fixed problem with the language grammar for negative time durations.
Removed the ability for the bali.Binary() constructor to create a random byte string. Pass in bali.random.bytes(size) to the constructor instead for consistency.
Merged bali.Parameters.getValue() and bali.Parameters.getParameter() to make it simpler and more intuitive.
Changed bali.Tag.getNumberOfBytes() to bali.Tag.getSize() for consistency even though the number of bytes is not the same as the number of base 32 characters. The number bytes is the more important aspect from a collision estimation perspective.
Simplified how parameters are accessed from parameter lists.
Removed value instanceof bali.Component check from bali.Structure.asComponent() method once and for all since it can't made to behave with the circular dependency between bali.Structure and the Bali elements classes. This circular dependency cannot be avoided and provides a much nicer interface between Bali and JS.
Revisited all require() statements in the modules and index.js files to make sure they always require the modules in the same order to help minimize the effects of the circular dependency.
Renamed the from(literal, parameters) constructors for the element classes to fromLiteral(literal, parameters) to make it clearer what the constructor does.
Renamed the from(collection, parameters) constructors for the collection classes to fromSequential(sequential, parameters) to be consistent with the element constructors where sequential is any type, Bali or native, that can be iterated over.
Refactored the way elements process parameters. They now use the parameter values to adjust the raw value into a canonical form which can be accessed using a toLiteral() method on the elements.
Added a from(literal, parameters) constructor to each element type. This provides a consistent way to create a new element from its Bali literal source string.
Renamed the bali.Filter class to bali.Pattern and added a component.matches(pattern) method that can take a pattern or regular expression text string and use it to determine whether or not the string version of the component matches the pattern.
Refactored the grammar rule for 'number' to depend on 'angle' since that is the true semantics of a polar complex number.
Added intrinsic interface checking functions to the bali.types module.
Refactored the methods and functions for many of the element classes to be consistent with the intrinsic interfaces required by the Bali Virtual Machine™.
Changed the packaging build plugin to webpack to handle ES6 features especially const.
Added a bali.Exception class for real runtime exceptions and made it clear that when the code throws an Error exception it represents a bug in the calling code. The new bali.Exception extends Error and adds an exception attribute that is a bali.Catalog containing the exception attributes.
Made the bali.Collection.addItem(item) method signature consistent for all concrete subtypes. They all now return a boolean stating whether or not the item as added successfully. Note, the bali.Stack and bali.Queue classes will throw an exception when this method is called and the collection is at full capacity.
The bali.Catalog.addItem(association) method now returns false when attempting to add an association with the same key as an existing association in the catalog rather than overwriting the association value. This was considered a bug in the original implementation.
Changed the list randomizer to generate a random ordinal index using the bali.codex.randomIndex(length) function instead of the Math.random() function. Simplified the bali.List.shuffleItems() method and added unit tests to test it.
Changed the bali.codex.randomIndex(length) implementation to return an ordinal index in the range [1..length] to be consistent with the rest of the Bali collection index semantics.
Added a bali.codex.randomProbability() function that returns a random probability in the range [0..1].
Added a bali.Probability.randomProbability() function that returns a random probability in the range [false..true].
Added a bali.Binary.randomBytes(numberOfBytes) function.
Fixed bugs in the this.comparedTo(that) methods. They were using typeof to determine the object types for this and that which always returned type 'object'. Now they use this.constructor.name string comparisons.
Added intrinsic functions and unit tests to the bali.Angle, bali.Probability, and bali.Complex classes.
Added a bali.Precision module that handles the significant digits resulting from arithmetic and trigonometric operations. It is used to implement the intrinsic functions for the bali.Angle, bali.Probability, and bali.Complex classes.
Fixed bugs in error reporting for several element types.
Changed the NATURAL grammar rule to NUMBER since there is no longer a distinction needed between natural numbers and integers. This only affects the regenerated parser, no code changes are necessary.
Added a new bali.Component.getType() method and the corresponding unit tests for each concrete component type.
Simplified the Bali Document Notation™ grammar for a document to only allow a component and not a procedure. This makes the document model much clearer and less error prone.
Removed the bali.Block and bali.Procedure classes and used the bali.Tree class to implement them instead.
Modified the interface to the bali.Parser class by changing parseComponent(source) to parseDocument(document) and removed the other parse methods.
Changed bali.Component.toSource(indentation) to bali.Component.toDocument(indentation) to avoid a naming conflict with the old JavaScript method of the same name.
Moved the bali.Comparator, bali.Iterator, bali.Sorter and the bali.Visitor classes into the utilities directory and removed them from the bali.Component inheritance tree.
Renamed bali.ComponentFormatter to bali.Formatter and converted it to a class.
Renamed bali.ComponentParser to bali.Parser and converted it to a class.