diff options
Diffstat (limited to 'cordova/node_modules/pegjs/CHANGELOG.md')
| -rw-r--r-- | cordova/node_modules/pegjs/CHANGELOG.md | 618 |
1 files changed, 618 insertions, 0 deletions
diff --git a/cordova/node_modules/pegjs/CHANGELOG.md b/cordova/node_modules/pegjs/CHANGELOG.md new file mode 100644 index 0000000..26afd3e --- /dev/null +++ b/cordova/node_modules/pegjs/CHANGELOG.md @@ -0,0 +1,618 @@ +Change Log +========== + +This file documents all notable changes to PEG.js. The releases follow [semantic +versioning](http://semver.org/). + +0.10.0 +------ + +Released: August 19, 2016 + +### Major Changes + + * **Parsers can be generated in multiple module formats.** The available + formats are: CommonJS (the default), AMD, UMD, globals, and bare (not + available from the command-line). + + The format can be specified using the `format` option of the `peg.generate` + function or the `--format` option on the command-line. + + It is also possible to specify parser dependencies using the `dependencies` + option of the `peg.generate` function or the `--dependency`/`-d` option on + the command-line. This is mainly useful for the UMD format, where the + dependencies are translated into both AMD dependencies and CommonJS + `require` calls. + + * **Browser version of PEG.js is now in the UMD format.** This means it will try + to detect AMD or Node.js/CommonJS module loader and define itself as a + module. If no loader is found, it will export itself using a global + variable. + + * **API polishing.** The `peg.buildParser` function was renamed to + `peg.generate`. The global variable the browser version of PEG.js is + available in when no loader is detected was renamed from `PEG` to `peg`. + + * **CLI improvements.** There is new `--output`/`-o` command-line option which + allows to specify the output file. The old way of specifying the output file + using a second argument was removed. To make room for the new `-o` option + the old one (a shortcut for `--optimize`) was renamed to `-O`. All these + changes make PEG.js conform to traditional compiler command-line interface. + + It is now also possible to use `-` as a file name on the command-line (with + the usual meaning of standard input/output). + + * **Improved error messages.** Both messages produced by PEG.js and generated + parsers were improved. + + * **Duplicate rule definitions are reported as errors.** + + * **Duplicate labels are reported as errors.** + +### Minor Changes + + * Exposed the AST node visitor builder as `peg.compiler.visitor`. This is + useful mainly for plugins which manipulate the AST. + + * Exposed the function which builds messages of exceptions produced by + generated parsers as `SyntaxError.buildMessage`. This is useful mainly for + customizing these error messages. + + * The `error` and `expected` functions now accept an optional `location` + parameter. This allows to customize the location in which the resulting + syntax error is reported. + + * Refactored expectations reported in the `expected` property of exceptions + produced by generated parsers. They are no longer de-duplicated and sorted, + their format changed to be more machine-readable, and they no longer contain + human-readable descriptions. + + * The `found` property of exceptions produced by the `error` function is now + set to `null`. + + * Removed access to the parser object in parser code via the `parser` + variable. + + * Made handling of optional parameters consistent with ES 2015. Specifically, + passing `undefined` as a parameter value is now equivalent to not passing + the parameter at all. + + * Renamed several compiler passes. + + * Generated parsers no longer consider `\r`, `\u2028`, and `\u2029` as + newlines (only `\n` and `\r\n`). + + * Simplified the arithmetics example grammar. + + * Switched from `first`/`rest` to `head`/`tail` in PEG.js grammar and example + grammars. + + * Started using ESLint instead of JSHint and fixed various problems it found. + + * Added [contribution + guidelines](https://github.com/pegjs/pegjs/blob/master/CONTRIBUTING.md). + + * Removed support for io.js. + +### Bug Fixes + + * Fixed `bin/pegjs` so that invoking it with one non-option argument which is + an extension-less file doesn’t cause that file to be overwritten. + + * Fixed label scoping so that labels in expressions like `(a:"a")` or `(a:"a" + b:"b" c:"c")` aren’t visible from the outside. + + * Fixed escaping of generated JavaScript strings & regexps to also escape DEL + (U+007F). + + * Fixed the JSON example grammar to correctly handle characters with code + points above U+10FF in strings. + + * Fixed multiple compatibility issues of `tools/impact` on OS X. + + * Fixed slow deduplication of expectation descriptions. + +[Complete set of changes](https://github.com/pegjs/pegjs/compare/v0.9.0...v0.10.0) + +0.9.0 +----- + +Released: August 30, 2015 + +### Major Changes + + * **Tracing support.** Parsers can be compiled with support for tracing their + progress, which can help debugging complex grammars. This feature is + experimental and is expected to evolve over time as experience is gained. + [More details](https://github.com/pegjs/pegjs/commit/da57118a43a904f753d44d407994cf0b36358adc) + + * **Infinite loop detection.** Grammar constructs that could cause infinite + loops in generated parsers are detected during compilation and cause errors. + + * **Improved location information API.** The `line`, `column`, and `offset` + functions available in parser code were replaced by a single `location` + function which returns an object describing the current location. Similarly, + the `line`, `column`, and `offset` properties of exceptions were replaced by + a single `location` property. The location is no longer a single point but a + character range, which is meaningful mainly in actions where the range + covers action’s expression. + [More details](https://github.com/pegjs/pegjs/compare/e75f21dc8f0e66b3d87c4c19b3fcb8f89d9c3acd...eaca5f0acf97b66ef141fed84aa95d4e72e33757) + + * **Improved error reporting.** All exceptions thrown when generating a parser + have associated location information. And all exceptions thrown by generated + parser and PEG.js itself have a stack trace (the `stack` property) in + environments that support `Error.captureStackTrace`. + + * **Strict mode code**. All PEG.js and generated parser code is written using + [JavaScript strict mode](https://developer.mozilla.org/cs/docs/Web/JavaScript/Reference/Strict_mode). + +### Minor Changes + + * Labels behave like block-scoped variables. This means parser code can see + labels defined outside expressions containing code. + + * Empty sequences are no longer allowed. + + * Label names can’t be JavaScript reserved words. + + * Rule and label names can contain Unicode characters like in JavaScript. + + * Rules have to be separated either by `;` or a newline (until now, any + whitespace was enough). + + * The PEG.js grammar and all the example grammars were completely rewritten. + This rewrite included a number of cleanups, formatting changes, naming + changes, and bug fixes. + + * The parser object can now be accessed as `parser` in parser code. + + * Location information computation is faster. + + * Added support for Node.js >= 0.10.x, io.js, and Edge. Removed support for + Node.js < 0.10.x. + +### Bug Fixes + + * Fixed left recursion detector which missed many cases. + + * Fixed escaping of U+0100—U+107F and U+1000—U+107F in generated code and + error messages. + + * Renamed `parse` and `SyntaxError` to `peg$parse` and `peg$SyntaxError` to + mark them as internal identifiers. + +[Complete set of changes](https://github.com/pegjs/pegjs/compare/v0.8.0...v0.9.0) + +0.8.0 +----- + +Released: December 24, 2013 + +### Big Changes + + * Completely rewrote the code generator. Among other things, it allows + optimizing generated parsers for parsing speed or code size using the + `optimize` option of the `PEG.buildParser` method or the `--optimize`/`-o` + option on the command-line. All internal identifiers in generated code now + also have a `peg$` prefix to discourage their use and avoid conflicts. + [[#35](https://github.com/dmajda/pegjs/issues/35), + [#92](https://github.com/dmajda/pegjs/issues/92)] + + * Completely redesigned error handling. Instead of returning `null` inside + actions to indicate match failure, new `expected` and `error` functions can + be called to trigger an error. Also, expectation inside the `SyntaxError` + exceptions are now structured to allow easier machine processing. + [[#198](https://github.com/dmajda/pegjs/issues/198)] + + * Implemented a plugin API. The list of plugins to use can be specified using + the `plugins` option of the `PEG.buildParser` method or the `--plugin` + option on the command-line. Also implemented the `--extra-options` and + `--extra-options-file` command-line options, which are mainly useful to pass + additional options to plugins. + [[#106](https://github.com/dmajda/pegjs/issues/106)] + + * Made `offset`, `line` and `column` functions, not variables. They are now + available in all parsers and return lazily-computed position data. Removed + now useless `trackLineAndColumn` option of the `PEG.buildParser` method and + the `--track-line-and-column` option on the command-line. + + * Added a new `text` function. When called inside an action, it returns the + text matched by action's expression. + [[#131](https://github.com/dmajda/pegjs/issues/131)] + + * Added a new `$` operator. It extracts matched strings from expressions. + + * The `?` operator now returns `null` on unsuccessful match. + + * Predicates now always return `undefined`. + + * Replaced the `startRule` parameter of the `parse` method in generated + parsers with more generic `options` parameter. The start rule can now be + specified as the `startRule` option. The `options` parameter can be also + used to pass custom options to the parser because it is visible as the + `options` variable inside parser code. + [[#37](https://github.com/dmajda/pegjs/issues/37)] + + * The list of allowed start rules of a generated parser now has to be + specified explicitly using the `allowedStartRules` option of the + `PEG.buildParser` method or the `--allowed-start-rule` option on the + command-line. This will make certain optimizations like rule inlining easier + in the future. + + * Removed the `toSource` method of generated parsers and introduced a new + `output` option of the `PEG.buildParser` method. It allows callers to + specify whether they want to get back the parser object or its source code. + + * The source code is now a valid npm package. This makes using development + versions easier. + [[#32](https://github.com/dmajda/pegjs/issues/32)] + + * Generated parsers are now ~25% faster and ~62%/~3% smaller (when optimized + for size/speed) than those generated by 0.7.0. + + * Requires Node.js 0.8.0+. + +### Small Changes + + * `bin/pegjs` now outputs just the parser source if the value of the + `--export-var` option is empty. This makes embedding generated parsers into + other files easier. + [[#143](https://github.com/dmajda/pegjs/issues/143)] + + * Changed the value of the `name` property of `PEG.GrammarError` instances + from “PEG.GrammarError” to just “GrammarError”. This better reflects the + fact that PEG.js can get required with different variable name than `PEG`. + + * Setup prototype chain for `PEG.GrammarError` correctly. + + * Setup prototype chain for `SyntaxError` in generated parsers correctly. + + * Fixed error messages in certain cases with trailing input + [[#119](https://github.com/dmajda/pegjs/issues/119)] + + * Fixed code generated for classes starting with `\^`. + [[#125](https://github.com/dmajda/pegjs/issues/125)] + + * Fixed too eager proxy rules removal. + [[#137](https://github.com/dmajda/pegjs/issues/137)] + + * Added a license to all vendored libraries. + [[#207](https://github.com/dmajda/pegjs/issues/207)] + + * Converted the test suite from QUnit to Jasmine, cleaning it up on the way. + + * Travis CI integration. + + * Various internal code improvements and fixes. + + * Various generated code improvements and fixes. + + * Various example grammar improvements and fixes. + + * Improved `README.md`. + + * Converted `CHANGELOG` to Markdown. + +0.7.0 +----- + +Released: April 18, 2012 + +### Big Changes + + * Added ability to pass options to `PEG.buildParser`. + + * Implemented the `trackLineAndColumn` option for `PEG.buildParser` (together + with the `--track-line-and-column` command-line option). It makes the + generated parser track line and column during parsing. These are made + available inside actions and predicates as `line` and `column` variables. + + * Implemented the `cache` option for `PEG.buildParser` (together with the + `--cache` command-line option). This option enables/disables the results + cache in generated parsers, resulting in dramatic speedup when the cache is + disabled (the default now). The cost is breaking the linear parsing time + guarantee. + + * The current parse position is visible inside actions and predicates as the + `offset` variable. + + * Exceptions thrown by the parser have `offset`, `expected` and `found` + properties containing machine-readable information about the parse failure + (based on a patch by Marcin Stefaniuk). + + * Semantic predicates have access to preceding labels. + [[GH-69](https://github.com/dmajda/pegjs/issues/69)] + + * Implemented case-insensitive literal and class matching. + [[GH-34](https://github.com/dmajda/pegjs/issues/34)] + + * Rewrote the code generator — split some computations into separate passes + and based it on a proper templating system (Codie). + + * Rewrote variable handling in generated parsers in a stack-like fashion, + simplifying the code and making the parsers smaller and faster. + + * Adapted to Node.js 0.6.6+ (no longer supported in older versions). + + * Dropped support for IE < 8. + + * As a result of several optimizations, parsers generated by 0.7.0 are ~6.4 + times faster and ~19% smaller than those generated by 0.6.2 (as reported by + `/tools/impact`). + +### Small Changes + + * Fixed reported error position when part of the input is not consumed. + [[GH-48](https://github.com/dmajda/pegjs/issues/48)] + + * Fixed incorrect disjunction operator in `computeErrorPosition` (original + patch by Wolfgang Kluge). + + * Fixed regexp for detecting command-line options in `/bin/pegjs`. + [[GH-51](https://github.com/dmajda/pegjs/issues/51)] + + * Generate more efficient code for empty literals (original patch by Wolfgang + Kluge). + + * Fixed comment typos (patches by Wolfgang Kluge and Jason Davies). + [[GH-59](https://github.com/dmajda/pegjs/issues/59)] + + * Fixed a typo in JavaScript example grammar. + [[GH-62](https://github.com/dmajda/pegjs/issues/62)] + + * Made copy & paste inclusion of the PEG.js library into another code easier + by changing how the library is exported. + + * Improved the copyright comment and the “Generated by...” header. + + * Replaced `Jakefile` with `Makefile`. + + * Added `make hint` task that checks all JavaScript files using JSHint and + resolved all issues it reported. All JavaScript files and also generated + parsers are JSHint-clean now. + + * Fixed output printed during test failures (expected value was being printed + instead of the actual one). Original patch by Wolfgang Kluge. + + * Added a `/tools/impact` script to measure speed and size impact of commits. + + * Various generated code improvements and fixes. + + * Various internal code improvements and fixes. + + * Improved `README.md`. + +0.6.2 +----- + +Released: August 20, 2011 + +### Small Changes + + * Reset parser position when action returns `null`. + + * Fixed typo in JavaScript example grammar. + +0.6.1 +----- + +Released: April 14, 2011 + +### Small Changes + + * Use `--ascii` option when generating a minified version. + +0.6.0 +----- + +Released: April 14, 2011 + +### Big Changes + + * Rewrote the command-line mode to be based on Node.js instead of Rhino — no + more Java dependency. This also means that PEG.js is available as a Node.js + package and can be required as a module. + + * Version for the browser is built separately from the command-line one in two + flavors (normal and minified). + + * Parser variable name is no longer required argument of `bin/pegjs` — it is + `module.exports` by default and can be set using the `-e`/`--export-var` + option. This makes parsers generated by `/bin/pegjs` Node.js modules by + default. + + * Added ability to start parsing from any grammar rule. + + * Added several compiler optimizations — 0.6 is ~12% faster than 0.5.1 in the + benchmark on V8. + +### Small Changes + + * Split the source code into multiple files combined together using a build + system. + + * Jake is now used instead of Rake for build scripts — no more Ruby + dependency. + + * Test suite can be run from the command-line. + + * Benchmark suite can be run from the command-line. + + * Benchmark browser runner improvements (users can specify number of runs, + benchmarks are run using `setTimeout`, table is centered and fixed-width). + + * Added PEG.js version to “Generated by...” line in generated parsers. + + * Added PEG.js version information and homepage header to `peg.js`. + + * Generated code improvements and fixes. + + * Internal code improvements and fixes. + + * Rewrote `README.md`. + +0.5.1 +----- + +Released: November 28, 2010 + +### Small Changes + + * Fixed a problem where “SyntaxError: Invalid range in character class.” error + appeared when using command-line version on Widnows + ([GH-13](https://github.com/dmajda/pegjs/issues/13)). + + * Fixed wrong version reported by `bin/pegjs --version`. + + * Removed two unused variables in the code. + + * Fixed incorrect variable name on two places. + +0.5 +--- + +Released: June 10, 2010 + +### Big Changes + + * Syntax change: Use labeled expressions and variables instead of `$1`, `$2`, + etc. + + * Syntax change: Replaced `:` after a rule name with `=`. + + * Syntax change: Allow trailing semicolon (`;`) for rules + + * Semantic change: Start rule of the grammar is now implicitly its first rule. + + * Implemented semantic predicates. + + * Implemented initializers. + + * Removed ability to change the start rule when generating the parser. + + * Added several compiler optimizations — 0.5 is ~11% faster than 0.4 in the + benchmark on V8. + +### Small Changes + + * `PEG.buildParser` now accepts grammars only in string format. + + * Added “Generated by ...” message to the generated parsers. + + * Formatted all grammars more consistently and transparently. + + * Added notes about ECMA-262, 5th ed. compatibility to the JSON example + grammar. + + * Guarded against redefinition of `undefined`. + + * Made `bin/pegjs` work when called via a symlink + ([issue #1](https://github.com/dmajda/pegjs/issues/1)). + + * Fixed bug causing incorrect error messages + ([issue #2](https://github.com/dmajda/pegjs/issues/2)). + + * Fixed error message for invalid character range. + + * Fixed string literal parsing in the JavaScript grammar. + + * Generated code improvements and fixes. + + * Internal code improvements and fixes. + + * Improved `README.md`. + +0.4 +--- + +Released: April 17, 2010 + +### Big Changes + + * Improved IE compatibility — IE6+ is now fully supported. + + * Generated parsers are now standalone (no runtime is required). + + * Added example grammars for JavaScript, CSS and JSON. + + * Added a benchmark suite. + + * Implemented negative character classes (e.g. `[^a-z]`). + + * Project moved from BitBucket to GitHub. + +### Small Changes + + * Code generated for the character classes is now regexp-based (= simpler and + more scalable). + + * Added `\uFEFF` (BOM) to the definition of whitespace in the metagrammar. + + * When building a parser, left-recursive rules (both direct and indirect) are + reported as errors. + + * When building a parser, missing rules are reported as errors. + + * Expected items in the error messages do not contain duplicates and they are + sorted. + + * Fixed several bugs in the example arithmetics grammar. + + * Converted `README` to GitHub Flavored Markdown and improved it. + + * Added `CHANGELOG`. + + * Internal code improvements. + +0.3 +--- + +Released: March 14, 2010 + + * Wrote `README`. + + * Bootstrapped the grammar parser. + + * Metagrammar recognizes JavaScript-like comments. + + * Changed standard grammar extension from `.peg` to `.pegjs` (it is more + specific). + + * Simplified the example arithmetics grammar + added comment. + + * Fixed a bug with reporting of invalid ranges such as `[b-a]` in the + metagrammar. + + * Fixed `--start` vs. `--start-rule` inconsistency between help and actual + option processing code. + + * Avoided ugliness in QUnit output. + + * Fixed typo in help: `parserVar` → `parser_var`. + + * Internal code improvements. + +0.2.1 +----- + +Released: March 8, 2010 + + * Added `pegjs-` prefix to the name of the minified runtime file. + +0.2 +--- + +Released: March 8, 2010 + + * Added `Rakefile` that builds minified runtime using Google Closure Compiler + API. + + * Removed trailing commas in object initializers (Google Closure does not like + them). + +0.1 +--- + +Released: March 8, 2010 + + * Initial release. |