Showing preview only (8,449K chars total). Download the full file or copy to clipboard to get everything.
Repository: jlongster/unwinder
Branch: master
Commit: 086322bbe1b2
Files: 563
Total size: 7.9 MB
Directory structure:
gitextract_9rmqceah/
├── .gitignore
├── .travis.yml
├── LICENSE
├── README.md
├── bin/
│ ├── compile
│ ├── regenerator
│ └── run
├── browser/
│ ├── build/
│ │ ├── bundle.js
│ │ └── styles.css
│ ├── index.html
│ ├── main.js
│ ├── script.js
│ └── style.css
├── debuggers/
│ ├── browser/
│ │ ├── main.js
│ │ └── static/
│ │ ├── app-conn.js
│ │ ├── app.css
│ │ ├── app.js
│ │ ├── conn.js
│ │ ├── index.html
│ │ ├── lib/
│ │ │ ├── bootstrap-3.0.3/
│ │ │ │ ├── .editorconfig
│ │ │ │ ├── .gitattributes
│ │ │ │ ├── .gitignore
│ │ │ │ ├── .travis.yml
│ │ │ │ ├── CNAME
│ │ │ │ ├── CONTRIBUTING.md
│ │ │ │ ├── DOCS-LICENSE
│ │ │ │ ├── Gruntfile.js
│ │ │ │ ├── LICENSE
│ │ │ │ ├── LICENSE-MIT
│ │ │ │ ├── README.md
│ │ │ │ ├── _config.yml
│ │ │ │ ├── _includes/
│ │ │ │ │ ├── ads.html
│ │ │ │ │ ├── footer.html
│ │ │ │ │ ├── header.html
│ │ │ │ │ ├── nav-about.html
│ │ │ │ │ ├── nav-components.html
│ │ │ │ │ ├── nav-css.html
│ │ │ │ │ ├── nav-customize.html
│ │ │ │ │ ├── nav-getting-started.html
│ │ │ │ │ ├── nav-javascript.html
│ │ │ │ │ ├── nav-main.html
│ │ │ │ │ ├── old-bs-docs.html
│ │ │ │ │ └── social-buttons.html
│ │ │ │ ├── _layouts/
│ │ │ │ │ ├── default.html
│ │ │ │ │ └── home.html
│ │ │ │ ├── about.html
│ │ │ │ ├── bower.json
│ │ │ │ ├── components.html
│ │ │ │ ├── composer.json
│ │ │ │ ├── css.html
│ │ │ │ ├── customize.html
│ │ │ │ ├── dist/
│ │ │ │ │ ├── css/
│ │ │ │ │ │ ├── bootstrap-theme.css
│ │ │ │ │ │ └── bootstrap.css
│ │ │ │ │ └── js/
│ │ │ │ │ └── bootstrap.js
│ │ │ │ ├── docs-assets/
│ │ │ │ │ ├── css/
│ │ │ │ │ │ ├── docs.css
│ │ │ │ │ │ └── pygments-manni.css
│ │ │ │ │ └── js/
│ │ │ │ │ ├── application.js
│ │ │ │ │ ├── customizer.js
│ │ │ │ │ ├── filesaver.js
│ │ │ │ │ ├── holder.js
│ │ │ │ │ ├── ie8-responsive-file-warning.js
│ │ │ │ │ ├── jszip.js
│ │ │ │ │ ├── less.js
│ │ │ │ │ ├── raw-files.js
│ │ │ │ │ └── uglify.js
│ │ │ │ ├── examples/
│ │ │ │ │ ├── carousel/
│ │ │ │ │ │ ├── carousel.css
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── grid/
│ │ │ │ │ │ ├── grid.css
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── jumbotron/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── jumbotron.css
│ │ │ │ │ ├── jumbotron-narrow/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── jumbotron-narrow.css
│ │ │ │ │ ├── justified-nav/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── justified-nav.css
│ │ │ │ │ ├── navbar/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── navbar.css
│ │ │ │ │ ├── navbar-fixed-top/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── navbar-fixed-top.css
│ │ │ │ │ ├── navbar-static-top/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── navbar-static-top.css
│ │ │ │ │ ├── non-responsive/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── non-responsive.css
│ │ │ │ │ ├── offcanvas/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ ├── offcanvas.css
│ │ │ │ │ │ └── offcanvas.js
│ │ │ │ │ ├── signin/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── signin.css
│ │ │ │ │ ├── starter-template/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── starter-template.css
│ │ │ │ │ ├── sticky-footer/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── sticky-footer.css
│ │ │ │ │ ├── sticky-footer-navbar/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── sticky-footer-navbar.css
│ │ │ │ │ └── theme/
│ │ │ │ │ ├── index.html
│ │ │ │ │ └── theme.css
│ │ │ │ ├── getting-started.html
│ │ │ │ ├── index.html
│ │ │ │ ├── javascript.html
│ │ │ │ ├── js/
│ │ │ │ │ ├── .jshintrc
│ │ │ │ │ ├── affix.js
│ │ │ │ │ ├── alert.js
│ │ │ │ │ ├── button.js
│ │ │ │ │ ├── carousel.js
│ │ │ │ │ ├── collapse.js
│ │ │ │ │ ├── dropdown.js
│ │ │ │ │ ├── modal.js
│ │ │ │ │ ├── popover.js
│ │ │ │ │ ├── scrollspy.js
│ │ │ │ │ ├── tab.js
│ │ │ │ │ ├── tests/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ ├── unit/
│ │ │ │ │ │ │ ├── affix.js
│ │ │ │ │ │ │ ├── alert.js
│ │ │ │ │ │ │ ├── button.js
│ │ │ │ │ │ │ ├── carousel.js
│ │ │ │ │ │ │ ├── collapse.js
│ │ │ │ │ │ │ ├── dropdown.js
│ │ │ │ │ │ │ ├── modal.js
│ │ │ │ │ │ │ ├── phantom.js
│ │ │ │ │ │ │ ├── popover.js
│ │ │ │ │ │ │ ├── scrollspy.js
│ │ │ │ │ │ │ ├── tab.js
│ │ │ │ │ │ │ ├── tooltip.js
│ │ │ │ │ │ │ └── transition.js
│ │ │ │ │ │ └── vendor/
│ │ │ │ │ │ ├── jquery.js
│ │ │ │ │ │ ├── qunit.css
│ │ │ │ │ │ └── qunit.js
│ │ │ │ │ ├── tooltip.js
│ │ │ │ │ └── transition.js
│ │ │ │ ├── less/
│ │ │ │ │ ├── alerts.less
│ │ │ │ │ ├── badges.less
│ │ │ │ │ ├── bootstrap.less
│ │ │ │ │ ├── breadcrumbs.less
│ │ │ │ │ ├── button-groups.less
│ │ │ │ │ ├── buttons.less
│ │ │ │ │ ├── carousel.less
│ │ │ │ │ ├── close.less
│ │ │ │ │ ├── code.less
│ │ │ │ │ ├── component-animations.less
│ │ │ │ │ ├── dropdowns.less
│ │ │ │ │ ├── forms.less
│ │ │ │ │ ├── glyphicons.less
│ │ │ │ │ ├── grid.less
│ │ │ │ │ ├── input-groups.less
│ │ │ │ │ ├── jumbotron.less
│ │ │ │ │ ├── labels.less
│ │ │ │ │ ├── list-group.less
│ │ │ │ │ ├── media.less
│ │ │ │ │ ├── mixins.less
│ │ │ │ │ ├── modals.less
│ │ │ │ │ ├── navbar.less
│ │ │ │ │ ├── navs.less
│ │ │ │ │ ├── normalize.less
│ │ │ │ │ ├── pager.less
│ │ │ │ │ ├── pagination.less
│ │ │ │ │ ├── panels.less
│ │ │ │ │ ├── popovers.less
│ │ │ │ │ ├── print.less
│ │ │ │ │ ├── progress-bars.less
│ │ │ │ │ ├── responsive-utilities.less
│ │ │ │ │ ├── scaffolding.less
│ │ │ │ │ ├── tables.less
│ │ │ │ │ ├── theme.less
│ │ │ │ │ ├── thumbnails.less
│ │ │ │ │ ├── tooltip.less
│ │ │ │ │ ├── type.less
│ │ │ │ │ ├── utilities.less
│ │ │ │ │ ├── variables.less
│ │ │ │ │ └── wells.less
│ │ │ │ └── package.json
│ │ │ ├── codemirror-3.20/
│ │ │ │ ├── .gitattributes
│ │ │ │ ├── .gitignore
│ │ │ │ ├── .travis.yml
│ │ │ │ ├── AUTHORS
│ │ │ │ ├── CONTRIBUTING.md
│ │ │ │ ├── LICENSE
│ │ │ │ ├── README.md
│ │ │ │ ├── addon/
│ │ │ │ │ ├── comment/
│ │ │ │ │ │ ├── comment.js
│ │ │ │ │ │ └── continuecomment.js
│ │ │ │ │ ├── dialog/
│ │ │ │ │ │ ├── dialog.css
│ │ │ │ │ │ └── dialog.js
│ │ │ │ │ ├── display/
│ │ │ │ │ │ ├── fullscreen.css
│ │ │ │ │ │ ├── fullscreen.js
│ │ │ │ │ │ └── placeholder.js
│ │ │ │ │ ├── edit/
│ │ │ │ │ │ ├── closebrackets.js
│ │ │ │ │ │ ├── closetag.js
│ │ │ │ │ │ ├── continuelist.js
│ │ │ │ │ │ ├── matchbrackets.js
│ │ │ │ │ │ ├── matchtags.js
│ │ │ │ │ │ └── trailingspace.js
│ │ │ │ │ ├── fold/
│ │ │ │ │ │ ├── brace-fold.js
│ │ │ │ │ │ ├── comment-fold.js
│ │ │ │ │ │ ├── foldcode.js
│ │ │ │ │ │ ├── foldgutter.css
│ │ │ │ │ │ ├── foldgutter.js
│ │ │ │ │ │ ├── indent-fold.js
│ │ │ │ │ │ └── xml-fold.js
│ │ │ │ │ ├── hint/
│ │ │ │ │ │ ├── anyword-hint.js
│ │ │ │ │ │ ├── css-hint.js
│ │ │ │ │ │ ├── html-hint.js
│ │ │ │ │ │ ├── javascript-hint.js
│ │ │ │ │ │ ├── pig-hint.js
│ │ │ │ │ │ ├── python-hint.js
│ │ │ │ │ │ ├── show-hint.css
│ │ │ │ │ │ ├── show-hint.js
│ │ │ │ │ │ ├── sql-hint.js
│ │ │ │ │ │ └── xml-hint.js
│ │ │ │ │ ├── lint/
│ │ │ │ │ │ ├── coffeescript-lint.js
│ │ │ │ │ │ ├── css-lint.js
│ │ │ │ │ │ ├── javascript-lint.js
│ │ │ │ │ │ ├── json-lint.js
│ │ │ │ │ │ ├── lint.css
│ │ │ │ │ │ └── lint.js
│ │ │ │ │ ├── merge/
│ │ │ │ │ │ ├── dep/
│ │ │ │ │ │ │ └── diff_match_patch.js
│ │ │ │ │ │ ├── merge.css
│ │ │ │ │ │ └── merge.js
│ │ │ │ │ ├── mode/
│ │ │ │ │ │ ├── loadmode.js
│ │ │ │ │ │ ├── multiplex.js
│ │ │ │ │ │ ├── multiplex_test.js
│ │ │ │ │ │ └── overlay.js
│ │ │ │ │ ├── runmode/
│ │ │ │ │ │ ├── colorize.js
│ │ │ │ │ │ ├── runmode-standalone.js
│ │ │ │ │ │ ├── runmode.js
│ │ │ │ │ │ └── runmode.node.js
│ │ │ │ │ ├── scroll/
│ │ │ │ │ │ └── scrollpastend.js
│ │ │ │ │ ├── search/
│ │ │ │ │ │ ├── match-highlighter.js
│ │ │ │ │ │ ├── search.js
│ │ │ │ │ │ └── searchcursor.js
│ │ │ │ │ ├── selection/
│ │ │ │ │ │ ├── active-line.js
│ │ │ │ │ │ └── mark-selection.js
│ │ │ │ │ ├── tern/
│ │ │ │ │ │ ├── tern.css
│ │ │ │ │ │ ├── tern.js
│ │ │ │ │ │ └── worker.js
│ │ │ │ │ └── wrap/
│ │ │ │ │ └── hardwrap.js
│ │ │ │ ├── bin/
│ │ │ │ │ ├── authors.sh
│ │ │ │ │ ├── compress
│ │ │ │ │ ├── lint
│ │ │ │ │ └── source-highlight
│ │ │ │ ├── bower.json
│ │ │ │ ├── demo/
│ │ │ │ │ ├── activeline.html
│ │ │ │ │ ├── anywordhint.html
│ │ │ │ │ ├── bidi.html
│ │ │ │ │ ├── btree.html
│ │ │ │ │ ├── buffers.html
│ │ │ │ │ ├── changemode.html
│ │ │ │ │ ├── closebrackets.html
│ │ │ │ │ ├── closetag.html
│ │ │ │ │ ├── complete.html
│ │ │ │ │ ├── emacs.html
│ │ │ │ │ ├── folding.html
│ │ │ │ │ ├── fullscreen.html
│ │ │ │ │ ├── hardwrap.html
│ │ │ │ │ ├── html5complete.html
│ │ │ │ │ ├── indentwrap.html
│ │ │ │ │ ├── lint.html
│ │ │ │ │ ├── loadmode.html
│ │ │ │ │ ├── marker.html
│ │ │ │ │ ├── markselection.html
│ │ │ │ │ ├── matchhighlighter.html
│ │ │ │ │ ├── matchtags.html
│ │ │ │ │ ├── merge.html
│ │ │ │ │ ├── multiplex.html
│ │ │ │ │ ├── mustache.html
│ │ │ │ │ ├── placeholder.html
│ │ │ │ │ ├── preview.html
│ │ │ │ │ ├── resize.html
│ │ │ │ │ ├── runmode.html
│ │ │ │ │ ├── search.html
│ │ │ │ │ ├── spanaffectswrapping_shim.html
│ │ │ │ │ ├── tern.html
│ │ │ │ │ ├── theme.html
│ │ │ │ │ ├── trailingspace.html
│ │ │ │ │ ├── variableheight.html
│ │ │ │ │ ├── vim.html
│ │ │ │ │ ├── visibletabs.html
│ │ │ │ │ ├── widget.html
│ │ │ │ │ └── xmlcomplete.html
│ │ │ │ ├── doc/
│ │ │ │ │ ├── activebookmark.js
│ │ │ │ │ ├── compress.html
│ │ │ │ │ ├── docs.css
│ │ │ │ │ ├── internals.html
│ │ │ │ │ ├── manual.html
│ │ │ │ │ ├── realworld.html
│ │ │ │ │ ├── releases.html
│ │ │ │ │ ├── reporting.html
│ │ │ │ │ ├── upgrade_v2.2.html
│ │ │ │ │ └── upgrade_v3.html
│ │ │ │ ├── index.html
│ │ │ │ ├── keymap/
│ │ │ │ │ ├── emacs.js
│ │ │ │ │ ├── extra.js
│ │ │ │ │ └── vim.js
│ │ │ │ ├── lib/
│ │ │ │ │ ├── codemirror.css
│ │ │ │ │ └── codemirror.js
│ │ │ │ ├── mode/
│ │ │ │ │ ├── apl/
│ │ │ │ │ │ ├── apl.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── asterisk/
│ │ │ │ │ │ ├── asterisk.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── clike/
│ │ │ │ │ │ ├── clike.js
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── scala.html
│ │ │ │ │ ├── clojure/
│ │ │ │ │ │ ├── clojure.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── cobol/
│ │ │ │ │ │ ├── cobol.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── coffeescript/
│ │ │ │ │ │ ├── coffeescript.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── commonlisp/
│ │ │ │ │ │ ├── commonlisp.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── css/
│ │ │ │ │ │ ├── css.js
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ ├── scss.html
│ │ │ │ │ │ ├── scss_test.js
│ │ │ │ │ │ └── test.js
│ │ │ │ │ ├── d/
│ │ │ │ │ │ ├── d.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── diff/
│ │ │ │ │ │ ├── diff.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── dtd/
│ │ │ │ │ │ ├── dtd.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── ecl/
│ │ │ │ │ │ ├── ecl.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── eiffel/
│ │ │ │ │ │ ├── eiffel.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── erlang/
│ │ │ │ │ │ ├── erlang.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── fortran/
│ │ │ │ │ │ ├── fortran.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── gas/
│ │ │ │ │ │ ├── gas.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── gfm/
│ │ │ │ │ │ ├── gfm.js
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── test.js
│ │ │ │ │ ├── gherkin/
│ │ │ │ │ │ ├── gherkin.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── go/
│ │ │ │ │ │ ├── go.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── groovy/
│ │ │ │ │ │ ├── groovy.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── haml/
│ │ │ │ │ │ ├── haml.js
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── test.js
│ │ │ │ │ ├── haskell/
│ │ │ │ │ │ ├── haskell.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── haxe/
│ │ │ │ │ │ ├── haxe.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── htmlembedded/
│ │ │ │ │ │ ├── htmlembedded.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── htmlmixed/
│ │ │ │ │ │ ├── htmlmixed.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── http/
│ │ │ │ │ │ ├── http.js
│ │ │ │ │ │ └── index.html
│ │ │ │ │ ├── index.html
│ │ │ │ │ ├── jade/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── jade.js
│ │ │ │ │ ├── javascript/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ ├── javascript.js
│ │ │ │ │ │ ├── test.js
│ │ │ │ │ │ └── typescript.html
│ │ │ │ │ ├── jinja2/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── jinja2.js
│ │ │ │ │ ├── julia/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── julia.js
│ │ │ │ │ ├── less/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── less.js
│ │ │ │ │ ├── livescript/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ ├── livescript.js
│ │ │ │ │ │ └── livescript.ls
│ │ │ │ │ ├── lua/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── lua.js
│ │ │ │ │ ├── markdown/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ ├── markdown.js
│ │ │ │ │ │ └── test.js
│ │ │ │ │ ├── meta.js
│ │ │ │ │ ├── mirc/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── mirc.js
│ │ │ │ │ ├── nginx/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── nginx.js
│ │ │ │ │ ├── ntriples/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── ntriples.js
│ │ │ │ │ ├── ocaml/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── ocaml.js
│ │ │ │ │ ├── octave/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── octave.js
│ │ │ │ │ ├── pascal/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── pascal.js
│ │ │ │ │ ├── pegjs/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── pegjs.js
│ │ │ │ │ ├── perl/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── perl.js
│ │ │ │ │ ├── php/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── php.js
│ │ │ │ │ ├── pig/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── pig.js
│ │ │ │ │ ├── properties/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── properties.js
│ │ │ │ │ ├── python/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── python.js
│ │ │ │ │ ├── q/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── q.js
│ │ │ │ │ ├── r/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── r.js
│ │ │ │ │ ├── rpm/
│ │ │ │ │ │ ├── changes/
│ │ │ │ │ │ │ ├── changes.js
│ │ │ │ │ │ │ └── index.html
│ │ │ │ │ │ └── spec/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ ├── spec.css
│ │ │ │ │ │ └── spec.js
│ │ │ │ │ ├── rst/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── rst.js
│ │ │ │ │ ├── ruby/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── ruby.js
│ │ │ │ │ ├── rust/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── rust.js
│ │ │ │ │ ├── sass/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── sass.js
│ │ │ │ │ ├── scheme/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── scheme.js
│ │ │ │ │ ├── shell/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── shell.js
│ │ │ │ │ ├── sieve/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── sieve.js
│ │ │ │ │ ├── smalltalk/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── smalltalk.js
│ │ │ │ │ ├── smarty/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── smarty.js
│ │ │ │ │ ├── smartymixed/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── smartymixed.js
│ │ │ │ │ ├── sparql/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── sparql.js
│ │ │ │ │ ├── sql/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── sql.js
│ │ │ │ │ ├── stex/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ ├── stex.js
│ │ │ │ │ │ └── test.js
│ │ │ │ │ ├── tcl/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── tcl.js
│ │ │ │ │ ├── tiddlywiki/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ ├── tiddlywiki.css
│ │ │ │ │ │ └── tiddlywiki.js
│ │ │ │ │ ├── tiki/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ ├── tiki.css
│ │ │ │ │ │ └── tiki.js
│ │ │ │ │ ├── toml/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── toml.js
│ │ │ │ │ ├── turtle/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── turtle.js
│ │ │ │ │ ├── vb/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── vb.js
│ │ │ │ │ ├── vbscript/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── vbscript.js
│ │ │ │ │ ├── velocity/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── velocity.js
│ │ │ │ │ ├── verilog/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── verilog.js
│ │ │ │ │ ├── xml/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── xml.js
│ │ │ │ │ ├── xquery/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ ├── test.js
│ │ │ │ │ │ └── xquery.js
│ │ │ │ │ ├── yaml/
│ │ │ │ │ │ ├── index.html
│ │ │ │ │ │ └── yaml.js
│ │ │ │ │ └── z80/
│ │ │ │ │ ├── index.html
│ │ │ │ │ └── z80.js
│ │ │ │ ├── package.json
│ │ │ │ ├── test/
│ │ │ │ │ ├── comment_test.js
│ │ │ │ │ ├── doc_test.js
│ │ │ │ │ ├── driver.js
│ │ │ │ │ ├── emacs_test.js
│ │ │ │ │ ├── index.html
│ │ │ │ │ ├── lint/
│ │ │ │ │ │ ├── acorn.js
│ │ │ │ │ │ ├── lint.js
│ │ │ │ │ │ └── walk.js
│ │ │ │ │ ├── mode_test.css
│ │ │ │ │ ├── mode_test.js
│ │ │ │ │ ├── phantom_driver.js
│ │ │ │ │ ├── run.js
│ │ │ │ │ ├── test.js
│ │ │ │ │ └── vim_test.js
│ │ │ │ └── theme/
│ │ │ │ ├── 3024-day.css
│ │ │ │ ├── 3024-night.css
│ │ │ │ ├── ambiance-mobile.css
│ │ │ │ ├── ambiance.css
│ │ │ │ ├── base16-dark.css
│ │ │ │ ├── base16-light.css
│ │ │ │ ├── blackboard.css
│ │ │ │ ├── cobalt.css
│ │ │ │ ├── eclipse.css
│ │ │ │ ├── elegant.css
│ │ │ │ ├── erlang-dark.css
│ │ │ │ ├── lesser-dark.css
│ │ │ │ ├── mbo.css
│ │ │ │ ├── midnight.css
│ │ │ │ ├── monokai.css
│ │ │ │ ├── neat.css
│ │ │ │ ├── night.css
│ │ │ │ ├── paraiso-dark.css
│ │ │ │ ├── paraiso-light.css
│ │ │ │ ├── rubyblue.css
│ │ │ │ ├── solarized.css
│ │ │ │ ├── the-matrix.css
│ │ │ │ ├── tomorrow-night-eighties.css
│ │ │ │ ├── twilight.css
│ │ │ │ ├── vibrant-ink.css
│ │ │ │ ├── xq-dark.css
│ │ │ │ └── xq-light.css
│ │ │ ├── esprima.js
│ │ │ └── react-0.8.0/
│ │ │ ├── README.md
│ │ │ ├── build/
│ │ │ │ ├── JSXTransformer.js
│ │ │ │ ├── react-with-addons.js
│ │ │ │ └── react.js
│ │ │ └── examples/
│ │ │ ├── ballmer-peak/
│ │ │ │ ├── example.js
│ │ │ │ └── index.html
│ │ │ ├── basic/
│ │ │ │ └── index.html
│ │ │ ├── basic-jsx/
│ │ │ │ └── index.html
│ │ │ ├── basic-jsx-external/
│ │ │ │ ├── example.js
│ │ │ │ └── index.html
│ │ │ ├── basic-jsx-precompile/
│ │ │ │ ├── example.js
│ │ │ │ └── index.html
│ │ │ ├── jquery-bootstrap/
│ │ │ │ ├── css/
│ │ │ │ │ └── example.css
│ │ │ │ ├── index.html
│ │ │ │ └── js/
│ │ │ │ └── app.js
│ │ │ ├── requirejs/
│ │ │ │ └── build/
│ │ │ │ ├── app.js
│ │ │ │ └── example-component.js
│ │ │ ├── shared/
│ │ │ │ └── css/
│ │ │ │ └── base.css
│ │ │ ├── todomvc-backbone/
│ │ │ │ ├── README.md
│ │ │ │ ├── css/
│ │ │ │ │ └── base.css
│ │ │ │ ├── index.html
│ │ │ │ ├── js/
│ │ │ │ │ ├── app.js
│ │ │ │ │ └── ie.js
│ │ │ │ └── thirdparty/
│ │ │ │ ├── backbone-min.js
│ │ │ │ └── backbone.localStorage-min.js
│ │ │ ├── todomvc-director/
│ │ │ │ ├── README.md
│ │ │ │ ├── bower.json
│ │ │ │ ├── index.html
│ │ │ │ └── js/
│ │ │ │ ├── app.jsx
│ │ │ │ ├── footer.jsx
│ │ │ │ ├── todoItem.jsx
│ │ │ │ └── utils.jsx
│ │ │ └── transitions/
│ │ │ ├── index.html
│ │ │ └── transition.css
│ │ ├── mouse.js
│ │ ├── probe.js
│ │ ├── renderers.js
│ │ ├── src.js
│ │ ├── src.txt
│ │ ├── src2.txt
│ │ ├── src3.txt
│ │ ├── src4.txt
│ │ ├── test.out.js
│ │ └── vm.js
│ └── node/
│ └── run.js
├── examples/
│ └── resumable-exceptions.js
├── lib/
│ ├── debug.js
│ ├── emit.js
│ ├── hoist.js
│ ├── leap.js
│ ├── meta.js
│ ├── util.js
│ └── visit.js
├── main.js
├── package.json
├── runtime/
│ └── vm.js
├── test.js
└── webpack.config.js
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
.#*
npm-debug.log
node_modules
test/mocha.js
test/mocha.css
test/tests.es5.js
test/tests.browser.js
.idea
================================================
FILE: .travis.yml
================================================
language: node_js
node_js:
- "0.11"
- "0.10"
- "0.8"
- "0.6"
================================================
FILE: LICENSE
================================================
BSD License
For "regenerator" software
Copyright (c) 2013, Facebook, Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: README.md
================================================
# unwinder
An implementation of continuations in JavaScript. Includes built-in
support for breakpoints (implemented with continuations) and setting
breakpoints on running scripts.
See [this post](http://jlongster.com/Whats-in-a-Continuation) for a
deeper explanation and interactive tutorials.
This implements the paper "[Exceptional Continuations in
JavaScript](http://www.schemeworkshop.org/2007/procPaper4.pdf)". It
started as a fork of
[regenerator](https://github.com/facebook/regenerator) from January
2014, so the code is outdated. However, it is useful for demos and
exploring interesting patterns.
**Do not build actual software with this**. Not only is it an old
regenerator fork, but my work on top of it is hacky. There are no
tests, as I was figuring out what was even possible. You will likely
hit bugs when trying to write non-trivial code against this.
With that said, fixing those bugs is usually straight-forward. Each
expression needs to mark itself correcly in the state machine. Usually
this is a matter of changing 1 or 2 lines of code.
There is little ES6 support, but that could be fixed by first
transforming code with Babel.
## Getting Started
The simplest way is to write some code in a file called `program.js`
and compile it with `./bin/compile program.js`. A file called `a.out`
will be generated, or you can specify an output file as the second
argument.
```
$ ./bin/compile program.js <output-file>
$ node <output-file>
```
There is also a browser editor included in the `browser` directory.
Open `browser/index.html` to run it, and you will be able to
interactively write code and set breakpoints.
## Continuation API
Use `callCC` to capture the current continuation. It will be given to
you as a function that never returns.
```js
function foo() {
var cont = callCC(cont => cont);
if(typeof cont === "function") {
cont(5);
}
return cont;
}
console.log(foo()); // -> 5
```
See [this post](http://jlongster.com/Exploring-Continuations-Resumable-Exceptions) for more interesting examples, including resumable exceptions.
## Machine API
At the bottom of the generated file, you will see where the program is
run by the virtual machine. This virtual machine does *not* interpret
the code; the code is real native JavaScript. All the virtual machine
does is check the behavior of the code and handle runtime information
of continuations (such as frames).
Some useful methods of the VM:
* **toggleBreakpoint(line)** - set/remove a breakpoint
* **continue()** - resume execution
* **step()** - step to the next expression
* **getTopFrame()** - if paused, get the top frame
* **abort()** - stop executing and clear out all state
Events (subscribe to events with `vm.on`):
* **paused** - fired when the code stops (breakpoint, stepped, etc)
* **error** - fired when an uncaught error occurs
* **resumed** - fired when the code resumed from being paused
* **finish** - fired when the code completes
* **cont-invoked** - fired when a continuation is invoked
## Contributing
I have turned off issues because I know there are many bugs in here
and I do not have time to triage them. However, I welcome PRs that
have a clear bugfix or purpose.
Some things I would like to see:
* Minor bugfixes and general stability improvements
* Clean up `lib/visit.js` and break up the large functions
* Remove so much manual AST construction. It would be great to give
something a string of code and generate the AST I need
automatically, but without having to parse the same code each time.
* Introduce two compiler modes: debugger and continuations. If we
don't support the "debugger" mode which allows live breakpoints, we
can do further optimizations and don't need to convert every single
expression into the state machine. But I want this project to
continue to support breakpoints, so it would be nice if we could
have different compiler modes (or maybe optimization levels?)
* Tests. Oh god help me, there are no tests.
Some things I am going to reject:
* Major refactorings without any discussion beforehand. I don't have
time to go through it.
================================================
FILE: bin/compile
================================================
#!/usr/bin/env node
var fs = require('fs');
var compiler = require(__dirname + '/../main');
var sweet = require('sweet.js');
var src = fs.readFileSync(process.argv[2], "utf-8");
src = sweet.compile(src, { noBabel: true }).code;
var output = compiler(src, { includeDebug: true });
var finalSrc =
"var $Machine = require('./runtime/vm.js').$Machine;\n" +
"var $ContinuationExc = require('./runtime/vm.js').$ContinuationExc;\n" +
"var $Frame = require('./runtime/vm.js').$Frame;" +
"var $DebugInfo = require('./runtime/vm.js').$DebugInfo;" +
output.code +
"var VM = new $Machine();\n" +
"VM.on('paused', function() { VM.continue() });\n" +
"VM.on('error', function(e) { console.log('error', e) });\n" +
"VM.setDebugInfo(new $DebugInfo(__debugInfo));\n" +
"VM.execute($__global);"
fs.writeFileSync(
process.argv[3] || 'a.out',
finalSrc
);
================================================
FILE: bin/regenerator
================================================
#!/usr/bin/env node
// -*- mode: js -*-
//Error.stackTraceLimit = 100;
var options = require("commander")
.version(require("../package.json").version)
.usage("[options] <file>")
.option("-r, --include-runtime", "Prepend the runtime to the output.")
.option("-d, --include-debug", "Prepend debug info to the output.")
.parse(process.argv);
var file = options.args[0];
if (typeof file !== "string") {
options.outputHelp();
process.exit(-1);
}
process.stdout.write('\n__debug_sourceURL="' + file + '";' + require("../main")(
require("fs").readFileSync(file, "utf-8"),
options // note: `regenerator` will ignore any unknown options anyway
).code);
================================================
FILE: bin/run
================================================
#!/usr/bin/env node
var Machine = require('../runtime/vm.js').$Machine;
var VM = new Machine();
VM.on("error", function(e) {
console.log('Error:', e.stack);
});
VM.on("paused", function(e) {
console.log('you broke it', VM.getLocation());
VM.continue()
});
VM.loadScript(process.argv[2]);
console.log(VM.getOutput());
================================================
FILE: browser/build/bundle.js
================================================
/******/ (function(modules) { // webpackBootstrap
/******/ // The module cache
/******/ var installedModules = {};
/******/ // The require function
/******/ function __webpack_require__(moduleId) {
/******/ // Check if module is in cache
/******/ if(installedModules[moduleId])
/******/ return installedModules[moduleId].exports;
/******/ // Create a new module (and put it into the cache)
/******/ var module = installedModules[moduleId] = {
/******/ exports: {},
/******/ id: moduleId,
/******/ loaded: false
/******/ };
/******/ // Execute the module function
/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/ // Flag the module as loaded
/******/ module.loaded = true;
/******/ // Return the exports of the module
/******/ return module.exports;
/******/ }
/******/ // expose the modules object (__webpack_modules__)
/******/ __webpack_require__.m = modules;
/******/ // expose the module cache
/******/ __webpack_require__.c = installedModules;
/******/ // __webpack_public_path__
/******/ __webpack_require__.p = "";
/******/ // Load entry module and return exports
/******/ return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {
const regenerator = __webpack_require__(1);
const VM = __webpack_require__(71);
const CodeMirror = __webpack_require__(72);
__webpack_require__(73);
__webpack_require__(74);
__webpack_require__(78);
__webpack_require__(80);
var template = document.querySelector('#template').innerHTML;
window.debuggerDemo = {
listeners: {},
on: function(event, callback) {
if(!this.listeners[event]) {
this.listeners[event] = [];
}
this.listeners[event].push(callback);
},
fire: function(event, vm, arg) {
if(this.listeners[event]) {
this.listeners[event].forEach(cb => {
cb(vm, arg)
});
}
}
};
var errorTimer;
function showError(e) {
var errorNode = document.querySelector("#debugger-error");
if(errorNode) {
errorNode.textContent = 'Error: ' + (e.message ? e.message : e);
errorNode.style.display = "block";
if(errorTimer) {
clearTimeout(errorTimer);
}
errorTimer = setTimeout(function() {
errorNode.style.display = 'none';
}, 5000);
}
}
function initDebugger(node, code) {
var code = code || node.textContent;
var breakpoint = node.dataset.breakpoint;
var id = node.id;
if(!id) {
throw new Error("debugger does not have an id");
}
var container = document.createElement('div');
container.className = "debugger";
container.id = id;
container.innerHTML = template;
node.parentNode.replaceChild(container, node);
// Don't judge me
setTimeout(() => finishInit(code, breakpoint, container, id), 10);
return container;
}
function finishInit(code, breakpoint, container, id) {
const pausedBtns = container.querySelector('#paused');
const resumedBtns = container.querySelector('#resumed');
const stackEl = container.querySelector('#actual-stack');
const outputEl = container.querySelector('#actual-output');
const mirror = CodeMirror(container.querySelector('#editor'), {
mode: 'javascript',
theme: 'monokai',
value: code,
lineNumbers: true,
gutters: ['breakpoints']
});
const vm = new VM.$Machine();
let currentPausedLoc = null;
let currentExprHighlight = null;
let breakpoints = [];
if(breakpoint) {
const line = parseInt(breakpoint);
breakpoints.push(line);
mirror.setGutterMarker(line - 1, 'breakpoints', marker());
}
function fixHeight() {
// Damn Chrome's flexbox implementation that forces us to do this.
var n = document.querySelector('#' + id + ' .CodeMirror');
var rect = n.getBoundingClientRect();
if(rect.height > 500) {
n.style.height = '500px';
}
}
function marker() {
let marker = document.createElement("div");
marker.className = "breakpoint";
return marker;
}
function exprHighlight(width, charHeight) {
let h = document.createElement("div");
h.className = "expr-highlight";
h.style.width = width + "px";
h.style.height = charHeight + "px";
// CodeMirror puts the widget *below* the line, but we actually
// want it to cover the indicated line, so move it up a line
h.style.marginTop = -charHeight + "px";
return h;
}
function removePauseState() {
if(currentPausedLoc) {
for(var i = currentPausedLoc.start.line; i <= currentPausedLoc.end.line; i++) {
mirror.removeLineClass(i - 1, 'line', 'debug');
}
currentPausedLoc = null;
}
if(currentExprHighlight) {
currentExprHighlight.parentNode.removeChild(currentExprHighlight);
currentExprHighlight = null;
}
updateUI();
}
mirror.on('gutterClick', (inst, line) => {
line = line + 1;
if(breakpoints.indexOf(line) === -1) {
breakpoints.push(line);
mirror.setGutterMarker(line - 1, 'breakpoints', marker());
}
else {
breakpoints = breakpoints.filter(l => l !== line);
mirror.setGutterMarker(line - 1, 'breakpoints', null);
}
if(vm.state === 'suspended') {
vm.toggleBreakpoint(line);
}
});
mirror.on('beforeChange', () => {
breakpoints.forEach(line => {
mirror.setGutterMarker(line - 1, 'breakpoints', null);
});
breakpoints = [];
vm.abort();
removePauseState();
});
mirror.on('change', fixHeight);
vm.on("error", function(e) {
console.log('Error:', e, e.stack);
showError(e);
updateUI();
});
vm.on("paused", function(e) {
currentPausedLoc = vm.getLocation();
if(currentPausedLoc) {
for(var i = currentPausedLoc.start.line; i <= currentPausedLoc.end.line; i++) {
mirror.addLineClass(i - 1, 'line', 'debug');
}
if(currentExprHighlight) {
currentExprHighlight.parentNode.removeChild(currentExprHighlight);
currentExprHighlight = null;
}
if(currentPausedLoc.start.line === currentPausedLoc.end.line) {
var width = currentPausedLoc.end.column - currentPausedLoc.start.column;
currentExprHighlight = exprHighlight(mirror.defaultCharWidth() * width,
mirror.defaultTextHeight())
mirror.addWidget(
{ line: currentPausedLoc.start.line - 1,
ch: currentPausedLoc.start.column },
currentExprHighlight,
false
);
}
mirror.scrollIntoView(
{ from: { line: currentPausedLoc.start.line, ch: 0 },
to: { line: currentPausedLoc.end.line, ch: 0 } },
50
);
}
updateUI();
});
vm.on("resumed", function() {
removePauseState();
});
// vm.on("cont-invoked", function() {
// });
vm.on("finish", () => {
updateUI();
});
function updateUI() {
if(currentPausedLoc) {
resumedBtns.style.display = 'none';
pausedBtns.style.display = 'block';
}
else {
resumedBtns.style.display = 'block';
pausedBtns.style.display = 'none';
}
if(vm.stack) {
stackEl.innerHTML = '<ul>' +
vm.stack.map(frame => {
return '<li>' + frame.name + '</li>';
}).join('') +
'</ul>';
}
else {
stackEl.innerHTML = '';
}
outputEl.textContent = vm.getOutput();
}
container.querySelector('#step').addEventListener('click', function() {
vm.step();
});
container.querySelector('#continue').addEventListener('click', function() {
vm.continue();
});
container.querySelector('#run').addEventListener('click', function() {
vm.abort();
const code = mirror.getValue();
outputEl.textContent = '';
try {
vm.loadString(mirror.getValue());
}
catch(e) {
debuggerDemo.fire("error", vm, e);
showError(e);
}
breakpoints.forEach(line => {
vm.toggleBreakpoint(line);
});
vm.run();
});
container.querySelector('#run-no-breakpoints').addEventListener('click', function() {
vm.abort();
const code = mirror.getValue();
outputEl.textContent = '';
vm.loadString(mirror.getValue());
vm.run();
});
fixHeight();
}
var demoDebugger = document.querySelector("#demo-debugger");
if(demoDebugger) {
var codeMatch = window.location.href.match(/\?code=(.*)/);
var code = codeMatch ? codeMatch[1] : "";
var container = initDebugger(demoDebugger, atob(code));
var shareBtn = container.querySelector("#share");
console.log(shareBtn);
shareBtn.addEventListener("click", function() {
var mirror = document.querySelector(".CodeMirror").CodeMirror;
var loc = window.location.href.replace(/\?code.*/, '');
history.pushState(null, null, loc + '?code=' + btoa(mirror.getValue()));
});
}
else {
var debuggers = document.querySelectorAll(".debugger");
for(var i=0; i<debuggers.length; i++) {
initDebugger(debuggers[i]);
}
}
/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(__dirname) {/**
* Copyright (c) 2013, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* https://raw.github.com/facebook/regenerator/master/LICENSE file. An
* additional grant of patent rights can be found in the PATENTS file in
* the same directory.
*/
var assert = __webpack_require__(2);
var path = __webpack_require__(7);
var types = __webpack_require__(8);
var b = types.builders;
var transform = __webpack_require__(22).transform;
var utils = __webpack_require__(24);
var recast = __webpack_require__(26);
var esprimaHarmony = __webpack_require__(55);
var genFunExp = /\bfunction\s*\*/;
var blockBindingExp = /\b(let|const)\s+/;
assert.ok(
/harmony/.test(esprimaHarmony.version),
"Bad esprima version: " + esprimaHarmony.version
);
function regenerator(source, options) {
options = utils.defaults(options || {}, {
supportBlockBinding: true
});
var supportBlockBinding = !!options.supportBlockBinding;
if (supportBlockBinding) {
if (!blockBindingExp.test(source)) {
supportBlockBinding = false;
}
}
var recastOptions = {
tabWidth: utils.guessTabWidth(source),
// Use the harmony branch of Esprima that installs with regenerator
// instead of the master branch that recast provides.
esprima: esprimaHarmony,
range: supportBlockBinding,
loc: true
};
var recastAst = recast.parse(source, recastOptions);
var ast = recastAst.program;
// Transpile let/const into var declarations.
if (supportBlockBinding) {
var defsResult = __webpack_require__(56)(ast, {
ast: true,
disallowUnknownReferences: false,
disallowDuplicated: false,
disallowVars: false,
loopClosures: "iife"
});
if (defsResult.errors) {
throw new Error(defsResult.errors.join("\n"))
}
}
var transformed = transform(ast, options);
recastAst.program = transformed.ast;
var appendix = '';
if(options.includeDebug) {
var body = recastAst.program.body;
body.unshift.apply(body, transformed.debugAST);
}
return {
code: recast.print(recastAst, recastOptions).code + '\n' + appendix,
debugInfo: transformed.debugInfo
};
}
// To modify an AST directly, call require("regenerator").transform(ast).
regenerator.transform = transform;
regenerator.runtime = {
dev: path.join(__dirname, "runtime", "vm.js"),
min: path.join(__dirname, "runtime", "min.js")
};
// To transform a string of ES6 code, call require("regenerator")(source);
module.exports = regenerator;
/* WEBPACK VAR INJECTION */}.call(exports, "/"))
/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {
// http://wiki.commonjs.org/wiki/Unit_Testing/1.0
//
// THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8!
//
// Originally from narwhal.js (http://narwhaljs.org)
// Copyright (c) 2009 Thomas Robinson <280north.com>
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the 'Software'), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
// when used in node, this will actually load the util module we depend on
// versus loading the builtin util module as happens otherwise
// this is a bug in node module loading as far as I am concerned
var util = __webpack_require__(3);
var pSlice = Array.prototype.slice;
var hasOwn = Object.prototype.hasOwnProperty;
// 1. The assert module provides functions that throw
// AssertionError's when particular conditions are not met. The
// assert module must conform to the following interface.
var assert = module.exports = ok;
// 2. The AssertionError is defined in assert.
// new assert.AssertionError({ message: message,
// actual: actual,
// expected: expected })
assert.AssertionError = function AssertionError(options) {
this.name = 'AssertionError';
this.actual = options.actual;
this.expected = options.expected;
this.operator = options.operator;
if (options.message) {
this.message = options.message;
this.generatedMessage = false;
} else {
this.message = getMessage(this);
this.generatedMessage = true;
}
var stackStartFunction = options.stackStartFunction || fail;
if (Error.captureStackTrace) {
Error.captureStackTrace(this, stackStartFunction);
}
else {
// non v8 browsers so we can have a stacktrace
var err = new Error();
if (err.stack) {
var out = err.stack;
// try to strip useless frames
var fn_name = stackStartFunction.name;
var idx = out.indexOf('\n' + fn_name);
if (idx >= 0) {
// once we have located the function frame
// we need to strip out everything before it (and its line)
var next_line = out.indexOf('\n', idx + 1);
out = out.substring(next_line + 1);
}
this.stack = out;
}
}
};
// assert.AssertionError instanceof Error
util.inherits(assert.AssertionError, Error);
function replacer(key, value) {
if (util.isUndefined(value)) {
return '' + value;
}
if (util.isNumber(value) && !isFinite(value)) {
return value.toString();
}
if (util.isFunction(value) || util.isRegExp(value)) {
return value.toString();
}
return value;
}
function truncate(s, n) {
if (util.isString(s)) {
return s.length < n ? s : s.slice(0, n);
} else {
return s;
}
}
function getMessage(self) {
return truncate(JSON.stringify(self.actual, replacer), 128) + ' ' +
self.operator + ' ' +
truncate(JSON.stringify(self.expected, replacer), 128);
}
// At present only the three keys mentioned above are used and
// understood by the spec. Implementations or sub modules can pass
// other keys to the AssertionError's constructor - they will be
// ignored.
// 3. All of the following functions must throw an AssertionError
// when a corresponding condition is not met, with a message that
// may be undefined if not provided. All assertion methods provide
// both the actual and expected values to the assertion error for
// display purposes.
function fail(actual, expected, message, operator, stackStartFunction) {
throw new assert.AssertionError({
message: message,
actual: actual,
expected: expected,
operator: operator,
stackStartFunction: stackStartFunction
});
}
// EXTENSION! allows for well behaved errors defined elsewhere.
assert.fail = fail;
// 4. Pure assertion tests whether a value is truthy, as determined
// by !!guard.
// assert.ok(guard, message_opt);
// This statement is equivalent to assert.equal(true, !!guard,
// message_opt);. To test strictly for the value true, use
// assert.strictEqual(true, guard, message_opt);.
function ok(value, message) {
if (!value) fail(value, true, message, '==', assert.ok);
}
assert.ok = ok;
// 5. The equality assertion tests shallow, coercive equality with
// ==.
// assert.equal(actual, expected, message_opt);
assert.equal = function equal(actual, expected, message) {
if (actual != expected) fail(actual, expected, message, '==', assert.equal);
};
// 6. The non-equality assertion tests for whether two objects are not equal
// with != assert.notEqual(actual, expected, message_opt);
assert.notEqual = function notEqual(actual, expected, message) {
if (actual == expected) {
fail(actual, expected, message, '!=', assert.notEqual);
}
};
// 7. The equivalence assertion tests a deep equality relation.
// assert.deepEqual(actual, expected, message_opt);
assert.deepEqual = function deepEqual(actual, expected, message) {
if (!_deepEqual(actual, expected)) {
fail(actual, expected, message, 'deepEqual', assert.deepEqual);
}
};
function _deepEqual(actual, expected) {
// 7.1. All identical values are equivalent, as determined by ===.
if (actual === expected) {
return true;
} else if (util.isBuffer(actual) && util.isBuffer(expected)) {
if (actual.length != expected.length) return false;
for (var i = 0; i < actual.length; i++) {
if (actual[i] !== expected[i]) return false;
}
return true;
// 7.2. If the expected value is a Date object, the actual value is
// equivalent if it is also a Date object that refers to the same time.
} else if (util.isDate(actual) && util.isDate(expected)) {
return actual.getTime() === expected.getTime();
// 7.3 If the expected value is a RegExp object, the actual value is
// equivalent if it is also a RegExp object with the same source and
// properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
} else if (util.isRegExp(actual) && util.isRegExp(expected)) {
return actual.source === expected.source &&
actual.global === expected.global &&
actual.multiline === expected.multiline &&
actual.lastIndex === expected.lastIndex &&
actual.ignoreCase === expected.ignoreCase;
// 7.4. Other pairs that do not both pass typeof value == 'object',
// equivalence is determined by ==.
} else if (!util.isObject(actual) && !util.isObject(expected)) {
return actual == expected;
// 7.5 For all other Object pairs, including Array objects, equivalence is
// determined by having the same number of owned properties (as verified
// with Object.prototype.hasOwnProperty.call), the same set of keys
// (although not necessarily the same order), equivalent values for every
// corresponding key, and an identical 'prototype' property. Note: this
// accounts for both named and indexed properties on Arrays.
} else {
return objEquiv(actual, expected);
}
}
function isArguments(object) {
return Object.prototype.toString.call(object) == '[object Arguments]';
}
function objEquiv(a, b) {
if (util.isNullOrUndefined(a) || util.isNullOrUndefined(b))
return false;
// an identical 'prototype' property.
if (a.prototype !== b.prototype) return false;
// if one is a primitive, the other must be same
if (util.isPrimitive(a) || util.isPrimitive(b)) {
return a === b;
}
var aIsArgs = isArguments(a),
bIsArgs = isArguments(b);
if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs))
return false;
if (aIsArgs) {
a = pSlice.call(a);
b = pSlice.call(b);
return _deepEqual(a, b);
}
var ka = objectKeys(a),
kb = objectKeys(b),
key, i;
// having the same number of owned properties (keys incorporates
// hasOwnProperty)
if (ka.length != kb.length)
return false;
//the same set of keys (although not necessarily the same order),
ka.sort();
kb.sort();
//~~~cheap key test
for (i = ka.length - 1; i >= 0; i--) {
if (ka[i] != kb[i])
return false;
}
//equivalent values for every corresponding key, and
//~~~possibly expensive deep test
for (i = ka.length - 1; i >= 0; i--) {
key = ka[i];
if (!_deepEqual(a[key], b[key])) return false;
}
return true;
}
// 8. The non-equivalence assertion tests for any deep inequality.
// assert.notDeepEqual(actual, expected, message_opt);
assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
if (_deepEqual(actual, expected)) {
fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual);
}
};
// 9. The strict equality assertion tests strict equality, as determined by ===.
// assert.strictEqual(actual, expected, message_opt);
assert.strictEqual = function strictEqual(actual, expected, message) {
if (actual !== expected) {
fail(actual, expected, message, '===', assert.strictEqual);
}
};
// 10. The strict non-equality assertion tests for strict inequality, as
// determined by !==. assert.notStrictEqual(actual, expected, message_opt);
assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
if (actual === expected) {
fail(actual, expected, message, '!==', assert.notStrictEqual);
}
};
function expectedException(actual, expected) {
if (!actual || !expected) {
return false;
}
if (Object.prototype.toString.call(expected) == '[object RegExp]') {
return expected.test(actual);
} else if (actual instanceof expected) {
return true;
} else if (expected.call({}, actual) === true) {
return true;
}
return false;
}
function _throws(shouldThrow, block, expected, message) {
var actual;
if (util.isString(expected)) {
message = expected;
expected = null;
}
try {
block();
} catch (e) {
actual = e;
}
message = (expected && expected.name ? ' (' + expected.name + ').' : '.') +
(message ? ' ' + message : '.');
if (shouldThrow && !actual) {
fail(actual, expected, 'Missing expected exception' + message);
}
if (!shouldThrow && expectedException(actual, expected)) {
fail(actual, expected, 'Got unwanted exception' + message);
}
if ((shouldThrow && actual && expected &&
!expectedException(actual, expected)) || (!shouldThrow && actual)) {
throw actual;
}
}
// 11. Expected to throw an error:
// assert.throws(block, Error_opt, message_opt);
assert.throws = function(block, /*optional*/error, /*optional*/message) {
_throws.apply(this, [true].concat(pSlice.call(arguments)));
};
// EXTENSION! This is annoying to write outside this module.
assert.doesNotThrow = function(block, /*optional*/message) {
_throws.apply(this, [false].concat(pSlice.call(arguments)));
};
assert.ifError = function(err) { if (err) {throw err;}};
var objectKeys = Object.keys || function (obj) {
var keys = [];
for (var key in obj) {
if (hasOwn.call(obj, key)) keys.push(key);
}
return keys;
};
/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(global, process) {// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
var formatRegExp = /%[sdj%]/g;
exports.format = function(f) {
if (!isString(f)) {
var objects = [];
for (var i = 0; i < arguments.length; i++) {
objects.push(inspect(arguments[i]));
}
return objects.join(' ');
}
var i = 1;
var args = arguments;
var len = args.length;
var str = String(f).replace(formatRegExp, function(x) {
if (x === '%%') return '%';
if (i >= len) return x;
switch (x) {
case '%s': return String(args[i++]);
case '%d': return Number(args[i++]);
case '%j':
try {
return JSON.stringify(args[i++]);
} catch (_) {
return '[Circular]';
}
default:
return x;
}
});
for (var x = args[i]; i < len; x = args[++i]) {
if (isNull(x) || !isObject(x)) {
str += ' ' + x;
} else {
str += ' ' + inspect(x);
}
}
return str;
};
// Mark that a method should not be used.
// Returns a modified function which warns once by default.
// If --no-deprecation is set, then it is a no-op.
exports.deprecate = function(fn, msg) {
// Allow for deprecating things in the process of starting up.
if (isUndefined(global.process)) {
return function() {
return exports.deprecate(fn, msg).apply(this, arguments);
};
}
if (process.noDeprecation === true) {
return fn;
}
var warned = false;
function deprecated() {
if (!warned) {
if (process.throwDeprecation) {
throw new Error(msg);
} else if (process.traceDeprecation) {
console.trace(msg);
} else {
console.error(msg);
}
warned = true;
}
return fn.apply(this, arguments);
}
return deprecated;
};
var debugs = {};
var debugEnviron;
exports.debuglog = function(set) {
if (isUndefined(debugEnviron))
debugEnviron = process.env.NODE_DEBUG || '';
set = set.toUpperCase();
if (!debugs[set]) {
if (new RegExp('\\b' + set + '\\b', 'i').test(debugEnviron)) {
var pid = process.pid;
debugs[set] = function() {
var msg = exports.format.apply(exports, arguments);
console.error('%s %d: %s', set, pid, msg);
};
} else {
debugs[set] = function() {};
}
}
return debugs[set];
};
/**
* Echos the value of a value. Trys to print the value out
* in the best way possible given the different types.
*
* @param {Object} obj The object to print out.
* @param {Object} opts Optional options object that alters the output.
*/
/* legacy: obj, showHidden, depth, colors*/
function inspect(obj, opts) {
// default options
var ctx = {
seen: [],
stylize: stylizeNoColor
};
// legacy...
if (arguments.length >= 3) ctx.depth = arguments[2];
if (arguments.length >= 4) ctx.colors = arguments[3];
if (isBoolean(opts)) {
// legacy...
ctx.showHidden = opts;
} else if (opts) {
// got an "options" object
exports._extend(ctx, opts);
}
// set default options
if (isUndefined(ctx.showHidden)) ctx.showHidden = false;
if (isUndefined(ctx.depth)) ctx.depth = 2;
if (isUndefined(ctx.colors)) ctx.colors = false;
if (isUndefined(ctx.customInspect)) ctx.customInspect = true;
if (ctx.colors) ctx.stylize = stylizeWithColor;
return formatValue(ctx, obj, ctx.depth);
}
exports.inspect = inspect;
// http://en.wikipedia.org/wiki/ANSI_escape_code#graphics
inspect.colors = {
'bold' : [1, 22],
'italic' : [3, 23],
'underline' : [4, 24],
'inverse' : [7, 27],
'white' : [37, 39],
'grey' : [90, 39],
'black' : [30, 39],
'blue' : [34, 39],
'cyan' : [36, 39],
'green' : [32, 39],
'magenta' : [35, 39],
'red' : [31, 39],
'yellow' : [33, 39]
};
// Don't use 'blue' not visible on cmd.exe
inspect.styles = {
'special': 'cyan',
'number': 'yellow',
'boolean': 'yellow',
'undefined': 'grey',
'null': 'bold',
'string': 'green',
'date': 'magenta',
// "name": intentionally not styling
'regexp': 'red'
};
function stylizeWithColor(str, styleType) {
var style = inspect.styles[styleType];
if (style) {
return '\u001b[' + inspect.colors[style][0] + 'm' + str +
'\u001b[' + inspect.colors[style][1] + 'm';
} else {
return str;
}
}
function stylizeNoColor(str, styleType) {
return str;
}
function arrayToHash(array) {
var hash = {};
array.forEach(function(val, idx) {
hash[val] = true;
});
return hash;
}
function formatValue(ctx, value, recurseTimes) {
// Provide a hook for user-specified inspect functions.
// Check that value is an object with an inspect function on it
if (ctx.customInspect &&
value &&
isFunction(value.inspect) &&
// Filter out the util module, it's inspect function is special
value.inspect !== exports.inspect &&
// Also filter out any prototype objects using the circular check.
!(value.constructor && value.constructor.prototype === value)) {
var ret = value.inspect(recurseTimes, ctx);
if (!isString(ret)) {
ret = formatValue(ctx, ret, recurseTimes);
}
return ret;
}
// Primitive types cannot have properties
var primitive = formatPrimitive(ctx, value);
if (primitive) {
return primitive;
}
// Look up the keys of the object.
var keys = Object.keys(value);
var visibleKeys = arrayToHash(keys);
if (ctx.showHidden) {
keys = Object.getOwnPropertyNames(value);
}
// IE doesn't make error fields non-enumerable
// http://msdn.microsoft.com/en-us/library/ie/dww52sbt(v=vs.94).aspx
if (isError(value)
&& (keys.indexOf('message') >= 0 || keys.indexOf('description') >= 0)) {
return formatError(value);
}
// Some type of object without properties can be shortcutted.
if (keys.length === 0) {
if (isFunction(value)) {
var name = value.name ? ': ' + value.name : '';
return ctx.stylize('[Function' + name + ']', 'special');
}
if (isRegExp(value)) {
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
}
if (isDate(value)) {
return ctx.stylize(Date.prototype.toString.call(value), 'date');
}
if (isError(value)) {
return formatError(value);
}
}
var base = '', array = false, braces = ['{', '}'];
// Make Array say that they are Array
if (isArray(value)) {
array = true;
braces = ['[', ']'];
}
// Make functions say that they are functions
if (isFunction(value)) {
var n = value.name ? ': ' + value.name : '';
base = ' [Function' + n + ']';
}
// Make RegExps say that they are RegExps
if (isRegExp(value)) {
base = ' ' + RegExp.prototype.toString.call(value);
}
// Make dates with properties first say the date
if (isDate(value)) {
base = ' ' + Date.prototype.toUTCString.call(value);
}
// Make error with message first say the error
if (isError(value)) {
base = ' ' + formatError(value);
}
if (keys.length === 0 && (!array || value.length == 0)) {
return braces[0] + base + braces[1];
}
if (recurseTimes < 0) {
if (isRegExp(value)) {
return ctx.stylize(RegExp.prototype.toString.call(value), 'regexp');
} else {
return ctx.stylize('[Object]', 'special');
}
}
ctx.seen.push(value);
var output;
if (array) {
output = formatArray(ctx, value, recurseTimes, visibleKeys, keys);
} else {
output = keys.map(function(key) {
return formatProperty(ctx, value, recurseTimes, visibleKeys, key, array);
});
}
ctx.seen.pop();
return reduceToSingleString(output, base, braces);
}
function formatPrimitive(ctx, value) {
if (isUndefined(value))
return ctx.stylize('undefined', 'undefined');
if (isString(value)) {
var simple = '\'' + JSON.stringify(value).replace(/^"|"$/g, '')
.replace(/'/g, "\\'")
.replace(/\\"/g, '"') + '\'';
return ctx.stylize(simple, 'string');
}
if (isNumber(value))
return ctx.stylize('' + value, 'number');
if (isBoolean(value))
return ctx.stylize('' + value, 'boolean');
// For some reason typeof null is "object", so special case here.
if (isNull(value))
return ctx.stylize('null', 'null');
}
function formatError(value) {
return '[' + Error.prototype.toString.call(value) + ']';
}
function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
var output = [];
for (var i = 0, l = value.length; i < l; ++i) {
if (hasOwnProperty(value, String(i))) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
String(i), true));
} else {
output.push('');
}
}
keys.forEach(function(key) {
if (!key.match(/^\d+$/)) {
output.push(formatProperty(ctx, value, recurseTimes, visibleKeys,
key, true));
}
});
return output;
}
function formatProperty(ctx, value, recurseTimes, visibleKeys, key, array) {
var name, str, desc;
desc = Object.getOwnPropertyDescriptor(value, key) || { value: value[key] };
if (desc.get) {
if (desc.set) {
str = ctx.stylize('[Getter/Setter]', 'special');
} else {
str = ctx.stylize('[Getter]', 'special');
}
} else {
if (desc.set) {
str = ctx.stylize('[Setter]', 'special');
}
}
if (!hasOwnProperty(visibleKeys, key)) {
name = '[' + key + ']';
}
if (!str) {
if (ctx.seen.indexOf(desc.value) < 0) {
if (isNull(recurseTimes)) {
str = formatValue(ctx, desc.value, null);
} else {
str = formatValue(ctx, desc.value, recurseTimes - 1);
}
if (str.indexOf('\n') > -1) {
if (array) {
str = str.split('\n').map(function(line) {
return ' ' + line;
}).join('\n').substr(2);
} else {
str = '\n' + str.split('\n').map(function(line) {
return ' ' + line;
}).join('\n');
}
}
} else {
str = ctx.stylize('[Circular]', 'special');
}
}
if (isUndefined(name)) {
if (array && key.match(/^\d+$/)) {
return str;
}
name = JSON.stringify('' + key);
if (name.match(/^"([a-zA-Z_][a-zA-Z_0-9]*)"$/)) {
name = name.substr(1, name.length - 2);
name = ctx.stylize(name, 'name');
} else {
name = name.replace(/'/g, "\\'")
.replace(/\\"/g, '"')
.replace(/(^"|"$)/g, "'");
name = ctx.stylize(name, 'string');
}
}
return name + ': ' + str;
}
function reduceToSingleString(output, base, braces) {
var numLinesEst = 0;
var length = output.reduce(function(prev, cur) {
numLinesEst++;
if (cur.indexOf('\n') >= 0) numLinesEst++;
return prev + cur.replace(/\u001b\[\d\d?m/g, '').length + 1;
}, 0);
if (length > 60) {
return braces[0] +
(base === '' ? '' : base + '\n ') +
' ' +
output.join(',\n ') +
' ' +
braces[1];
}
return braces[0] + base + ' ' + output.join(', ') + ' ' + braces[1];
}
// NOTE: These type checking functions intentionally don't use `instanceof`
// because it is fragile and can be easily faked with `Object.create()`.
function isArray(ar) {
return Array.isArray(ar);
}
exports.isArray = isArray;
function isBoolean(arg) {
return typeof arg === 'boolean';
}
exports.isBoolean = isBoolean;
function isNull(arg) {
return arg === null;
}
exports.isNull = isNull;
function isNullOrUndefined(arg) {
return arg == null;
}
exports.isNullOrUndefined = isNullOrUndefined;
function isNumber(arg) {
return typeof arg === 'number';
}
exports.isNumber = isNumber;
function isString(arg) {
return typeof arg === 'string';
}
exports.isString = isString;
function isSymbol(arg) {
return typeof arg === 'symbol';
}
exports.isSymbol = isSymbol;
function isUndefined(arg) {
return arg === void 0;
}
exports.isUndefined = isUndefined;
function isRegExp(re) {
return isObject(re) && objectToString(re) === '[object RegExp]';
}
exports.isRegExp = isRegExp;
function isObject(arg) {
return typeof arg === 'object' && arg !== null;
}
exports.isObject = isObject;
function isDate(d) {
return isObject(d) && objectToString(d) === '[object Date]';
}
exports.isDate = isDate;
function isError(e) {
return isObject(e) &&
(objectToString(e) === '[object Error]' || e instanceof Error);
}
exports.isError = isError;
function isFunction(arg) {
return typeof arg === 'function';
}
exports.isFunction = isFunction;
function isPrimitive(arg) {
return arg === null ||
typeof arg === 'boolean' ||
typeof arg === 'number' ||
typeof arg === 'string' ||
typeof arg === 'symbol' || // ES6 symbol
typeof arg === 'undefined';
}
exports.isPrimitive = isPrimitive;
exports.isBuffer = __webpack_require__(5);
function objectToString(o) {
return Object.prototype.toString.call(o);
}
function pad(n) {
return n < 10 ? '0' + n.toString(10) : n.toString(10);
}
var months = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep',
'Oct', 'Nov', 'Dec'];
// 26 Feb 16:19:34
function timestamp() {
var d = new Date();
var time = [pad(d.getHours()),
pad(d.getMinutes()),
pad(d.getSeconds())].join(':');
return [d.getDate(), months[d.getMonth()], time].join(' ');
}
// log is just a thin wrapper to console.log that prepends a timestamp
exports.log = function() {
console.log('%s - %s', timestamp(), exports.format.apply(exports, arguments));
};
/**
* Inherit the prototype methods from one constructor into another.
*
* The Function.prototype.inherits from lang.js rewritten as a standalone
* function (not on Function.prototype). NOTE: If this file is to be loaded
* during bootstrapping this function needs to be rewritten using some native
* functions as prototype setup using normal JavaScript does not work as
* expected during bootstrapping (see mirror.js in r114903).
*
* @param {function} ctor Constructor function which needs to inherit the
* prototype.
* @param {function} superCtor Constructor function to inherit prototype from.
*/
exports.inherits = __webpack_require__(6);
exports._extend = function(origin, add) {
// Don't do anything if add isn't an object
if (!add || !isObject(add)) return origin;
var keys = Object.keys(add);
var i = keys.length;
while (i--) {
origin[keys[i]] = add[keys[i]];
}
return origin;
};
function hasOwnProperty(obj, prop) {
return Object.prototype.hasOwnProperty.call(obj, prop);
}
/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }()), __webpack_require__(4)))
/***/ },
/* 4 */
/***/ function(module, exports) {
// shim for using process in browser
var process = module.exports = {};
var queue = [];
var draining = false;
var currentQueue;
var queueIndex = -1;
function cleanUpNextTick() {
draining = false;
if (currentQueue.length) {
queue = currentQueue.concat(queue);
} else {
queueIndex = -1;
}
if (queue.length) {
drainQueue();
}
}
function drainQueue() {
if (draining) {
return;
}
var timeout = setTimeout(cleanUpNextTick);
draining = true;
var len = queue.length;
while(len) {
currentQueue = queue;
queue = [];
while (++queueIndex < len) {
if (currentQueue) {
currentQueue[queueIndex].run();
}
}
queueIndex = -1;
len = queue.length;
}
currentQueue = null;
draining = false;
clearTimeout(timeout);
}
process.nextTick = function (fun) {
var args = new Array(arguments.length - 1);
if (arguments.length > 1) {
for (var i = 1; i < arguments.length; i++) {
args[i - 1] = arguments[i];
}
}
queue.push(new Item(fun, args));
if (queue.length === 1 && !draining) {
setTimeout(drainQueue, 0);
}
};
// v8 likes predictible objects
function Item(fun, array) {
this.fun = fun;
this.array = array;
}
Item.prototype.run = function () {
this.fun.apply(null, this.array);
};
process.title = 'browser';
process.browser = true;
process.env = {};
process.argv = [];
process.version = ''; // empty string to avoid regexp issues
process.versions = {};
function noop() {}
process.on = noop;
process.addListener = noop;
process.once = noop;
process.off = noop;
process.removeListener = noop;
process.removeAllListeners = noop;
process.emit = noop;
process.binding = function (name) {
throw new Error('process.binding is not supported');
};
process.cwd = function () { return '/' };
process.chdir = function (dir) {
throw new Error('process.chdir is not supported');
};
process.umask = function() { return 0; };
/***/ },
/* 5 */
/***/ function(module, exports) {
module.exports = function isBuffer(arg) {
return arg && typeof arg === 'object'
&& typeof arg.copy === 'function'
&& typeof arg.fill === 'function'
&& typeof arg.readUInt8 === 'function';
}
/***/ },
/* 6 */
/***/ function(module, exports) {
if (typeof Object.create === 'function') {
// implementation from standard node.js 'util' module
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
ctor.prototype = Object.create(superCtor.prototype, {
constructor: {
value: ctor,
enumerable: false,
writable: true,
configurable: true
}
});
};
} else {
// old school shim for old browsers
module.exports = function inherits(ctor, superCtor) {
ctor.super_ = superCtor
var TempCtor = function () {}
TempCtor.prototype = superCtor.prototype
ctor.prototype = new TempCtor()
ctor.prototype.constructor = ctor
}
}
/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.
// resolves . and .. elements in a path array with directory names there
// must be no slashes, empty elements, or device names (c:\) in the array
// (so also no leading and trailing slashes - it does not distinguish
// relative and absolute paths)
function normalizeArray(parts, allowAboveRoot) {
// if the path tries to go above the root, `up` ends up > 0
var up = 0;
for (var i = parts.length - 1; i >= 0; i--) {
var last = parts[i];
if (last === '.') {
parts.splice(i, 1);
} else if (last === '..') {
parts.splice(i, 1);
up++;
} else if (up) {
parts.splice(i, 1);
up--;
}
}
// if the path is allowed to go above the root, restore leading ..s
if (allowAboveRoot) {
for (; up--; up) {
parts.unshift('..');
}
}
return parts;
}
// Split a filename into [root, dir, basename, ext], unix version
// 'root' is just a slash, or nothing.
var splitPathRe =
/^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
var splitPath = function(filename) {
return splitPathRe.exec(filename).slice(1);
};
// path.resolve([from ...], to)
// posix version
exports.resolve = function() {
var resolvedPath = '',
resolvedAbsolute = false;
for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
var path = (i >= 0) ? arguments[i] : process.cwd();
// Skip empty and invalid entries
if (typeof path !== 'string') {
throw new TypeError('Arguments to path.resolve must be strings');
} else if (!path) {
continue;
}
resolvedPath = path + '/' + resolvedPath;
resolvedAbsolute = path.charAt(0) === '/';
}
// At this point the path should be resolved to a full absolute path, but
// handle relative paths to be safe (might happen when process.cwd() fails)
// Normalize the path
resolvedPath = normalizeArray(filter(resolvedPath.split('/'), function(p) {
return !!p;
}), !resolvedAbsolute).join('/');
return ((resolvedAbsolute ? '/' : '') + resolvedPath) || '.';
};
// path.normalize(path)
// posix version
exports.normalize = function(path) {
var isAbsolute = exports.isAbsolute(path),
trailingSlash = substr(path, -1) === '/';
// Normalize the path
path = normalizeArray(filter(path.split('/'), function(p) {
return !!p;
}), !isAbsolute).join('/');
if (!path && !isAbsolute) {
path = '.';
}
if (path && trailingSlash) {
path += '/';
}
return (isAbsolute ? '/' : '') + path;
};
// posix version
exports.isAbsolute = function(path) {
return path.charAt(0) === '/';
};
// posix version
exports.join = function() {
var paths = Array.prototype.slice.call(arguments, 0);
return exports.normalize(filter(paths, function(p, index) {
if (typeof p !== 'string') {
throw new TypeError('Arguments to path.join must be strings');
}
return p;
}).join('/'));
};
// path.relative(from, to)
// posix version
exports.relative = function(from, to) {
from = exports.resolve(from).substr(1);
to = exports.resolve(to).substr(1);
function trim(arr) {
var start = 0;
for (; start < arr.length; start++) {
if (arr[start] !== '') break;
}
var end = arr.length - 1;
for (; end >= 0; end--) {
if (arr[end] !== '') break;
}
if (start > end) return [];
return arr.slice(start, end - start + 1);
}
var fromParts = trim(from.split('/'));
var toParts = trim(to.split('/'));
var length = Math.min(fromParts.length, toParts.length);
var samePartsLength = length;
for (var i = 0; i < length; i++) {
if (fromParts[i] !== toParts[i]) {
samePartsLength = i;
break;
}
}
var outputParts = [];
for (var i = samePartsLength; i < fromParts.length; i++) {
outputParts.push('..');
}
outputParts = outputParts.concat(toParts.slice(samePartsLength));
return outputParts.join('/');
};
exports.sep = '/';
exports.delimiter = ':';
exports.dirname = function(path) {
var result = splitPath(path),
root = result[0],
dir = result[1];
if (!root && !dir) {
// No dirname whatsoever
return '.';
}
if (dir) {
// It has a dirname, strip trailing slash
dir = dir.substr(0, dir.length - 1);
}
return root + dir;
};
exports.basename = function(path, ext) {
var f = splitPath(path)[2];
// TODO: make this comparison case-insensitive on windows?
if (ext && f.substr(-1 * ext.length) === ext) {
f = f.substr(0, f.length - ext.length);
}
return f;
};
exports.extname = function(path) {
return splitPath(path)[3];
};
function filter (xs, f) {
if (xs.filter) return xs.filter(f);
var res = [];
for (var i = 0; i < xs.length; i++) {
if (f(xs[i], i, xs)) res.push(xs[i]);
}
return res;
}
// String.prototype.substr - negative index don't work in IE8
var substr = 'ab'.substr(-1) === 'b'
? function (str, start, len) { return str.substr(start, len) }
: function (str, start, len) {
if (start < 0) start = str.length + start;
return str.substr(start, len);
}
;
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {
var types = __webpack_require__(9);
// This core module of AST types captures ES5 as it is parsed today by
// git://github.com/ariya/esprima.git#master.
__webpack_require__(10);
// Feel free to add to or remove from this list of extension modules to
// configure the precise type hierarchy that you need.
__webpack_require__(12);
__webpack_require__(13);
__webpack_require__(14);
__webpack_require__(15);
exports.Type = types.Type;
exports.builtInTypes = types.builtInTypes;
exports.namedTypes = types.namedTypes;
exports.builders = types.builders;
exports.defineMethod = types.defineMethod;
exports.getFieldValue = types.getFieldValue;
exports.eachField = types.eachField;
exports.someField = types.someField;
exports.traverse = __webpack_require__(16);
exports.finalize = types.finalize;
exports.NodePath = __webpack_require__(17);
/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {
var assert = __webpack_require__(2);
var Ap = Array.prototype;
var slice = Ap.slice;
var map = Ap.map;
var each = Ap.forEach;
var Op = Object.prototype;
var objToStr = Op.toString;
var funObjStr = objToStr.call(function(){});
var strObjStr = objToStr.call("");
var hasOwn = Op.hasOwnProperty;
// A type is an object with a .check method that takes a value and returns
// true or false according to whether the value matches the type.
function Type(check, name) {
var self = this;
assert.ok(self instanceof Type, self);
// Unfortunately we can't elegantly reuse isFunction and isString,
// here, because this code is executed while defining those types.
assert.strictEqual(objToStr.call(check), funObjStr,
check + " is not a function");
// The `name` parameter can be either a function or a string.
var nameObjStr = objToStr.call(name);
assert.ok(nameObjStr === funObjStr ||
nameObjStr === strObjStr,
name + " is neither a function nor a string");
Object.defineProperties(self, {
name: { value: name },
check: {
value: function(value, deep) {
var result = check.call(self, value, deep);
if (!result && deep && objToStr.call(deep) === funObjStr)
deep(self, value);
return result;
}
}
});
}
var Tp = Type.prototype;
// Throughout this file we use Object.defineProperty to prevent
// redefinition of exported properties.
Object.defineProperty(exports, "Type", { value: Type });
// Like .check, except that failure triggers an AssertionError.
Tp.assert = function(value, deep) {
if (!this.check(value, deep)) {
var str = shallowStringify(value);
assert.ok(false, str + " does not match type " + this);
return false;
}
return true;
};
function shallowStringify(value) {
if (isObject.check(value))
return "{" + Object.keys(value).map(function(key) {
return key + ": " + value[key];
}).join(", ") + "}";
if (isArray.check(value))
return "[" + value.map(shallowStringify).join(", ") + "]";
return JSON.stringify(value);
}
Tp.toString = function() {
var name = this.name;
if (isString.check(name))
return name;
if (isFunction.check(name))
return name.call(this) + "";
return name + " type";
};
var builtInTypes = {};
Object.defineProperty(exports, "builtInTypes", {
enumerable: true,
value: builtInTypes
});
function defBuiltInType(example, name) {
var objStr = objToStr.call(example);
Object.defineProperty(builtInTypes, name, {
enumerable: true,
value: new Type(function(value) {
return objToStr.call(value) === objStr;
}, name)
});
return builtInTypes[name];
}
// These types check the underlying [[Class]] attribute of the given
// value, rather than using the problematic typeof operator. Note however
// that no subtyping is considered; so, for instance, isObject.check
// returns false for [], /./, new Date, and null.
var isString = defBuiltInType("", "string");
var isFunction = defBuiltInType(function(){}, "function");
var isArray = defBuiltInType([], "array");
var isObject = defBuiltInType({}, "object");
var isRegExp = defBuiltInType(/./, "RegExp");
var isDate = defBuiltInType(new Date, "Date");
var isNumber = defBuiltInType(3, "number");
var isBoolean = defBuiltInType(true, "boolean");
var isNull = defBuiltInType(null, "null");
var isUndefined = defBuiltInType(void 0, "undefined");
// There are a number of idiomatic ways of expressing types, so this
// function serves to coerce them all to actual Type objects. Note that
// providing the name argument is not necessary in most cases.
function toType(from, name) {
// The toType function should of course be idempotent.
if (from instanceof Type)
return from;
// The Def type is used as a helper for constructing compound
// interface types for AST nodes.
if (from instanceof Def)
return from.type;
// Support [ElemType] syntax.
if (isArray.check(from))
return Type.fromArray(from);
// Support { someField: FieldType, ... } syntax.
if (isObject.check(from))
return Type.fromObject(from);
// If isFunction.check(from), assume that from is a binary predicate
// function we can use to define the type.
if (isFunction.check(from))
return new Type(from, name);
// As a last resort, toType returns a type that matches any value that
// is === from. This is primarily useful for literal values like
// toType(null), but it has the additional advantage of allowing
// toType to be a total function.
return new Type(function(value) {
return value === from;
}, isUndefined.check(name) ? function() {
return from + "";
} : name);
}
// Returns a type that matches the given value iff any of type1, type2,
// etc. match the value.
Type.or = function(/* type1, type2, ... */) {
var types = [];
var len = arguments.length;
for (var i = 0; i < len; ++i)
types.push(toType(arguments[i]));
return new Type(function(value, deep) {
for (var i = 0; i < len; ++i)
if (types[i].check(value, deep))
return true;
return false;
}, function() {
return types.join(" | ");
});
};
Type.fromArray = function(arr) {
assert.ok(isArray.check(arr));
assert.strictEqual(
arr.length, 1,
"only one element type is permitted for typed arrays");
return toType(arr[0]).arrayOf();
};
Tp.arrayOf = function() {
var elemType = this;
return new Type(function(value, deep) {
return isArray.check(value) && value.every(function(elem) {
return elemType.check(elem, deep);
});
}, function() {
return "[" + elemType + "]";
});
};
Type.fromObject = function(obj) {
var fields = Object.keys(obj).map(function(name) {
return new Field(name, obj[name]);
});
return new Type(function(value, deep) {
return isObject.check(value) && fields.every(function(field) {
return field.type.check(value[field.name], deep);
});
}, function() {
return "{ " + fields.join(", ") + " }";
});
};
function Field(name, type, defaultFn, hidden) {
var self = this;
assert.ok(self instanceof Field);
isString.assert(name);
type = toType(type);
var properties = {
name: { value: name },
type: { value: type },
hidden: { value: !!hidden }
};
if (isFunction.check(defaultFn)) {
properties.defaultFn = { value: defaultFn };
}
Object.defineProperties(self, properties);
}
var Fp = Field.prototype;
Fp.toString = function() {
return JSON.stringify(this.name) + ": " + this.type;
};
Fp.getValue = function(obj) {
var value = obj[this.name];
if (!isUndefined.check(value))
return value;
if (this.defaultFn)
value = this.defaultFn.call(obj);
return value;
};
// Define a type whose name is registered in a namespace (the defCache) so
// that future definitions will return the same type given the same name.
// In particular, this system allows for circular and forward definitions.
// The Def object d returned from Type.def may be used to configure the
// type d.type by calling methods such as d.bases, d.build, and d.field.
Type.def = function(typeName) {
isString.assert(typeName);
return hasOwn.call(defCache, typeName)
? defCache[typeName]
: defCache[typeName] = new Def(typeName);
};
// In order to return the same Def instance every time Type.def is called
// with a particular name, those instances need to be stored in a cache.
var defCache = {};
function Def(typeName) {
var self = this;
assert.ok(self instanceof Def);
Object.defineProperties(self, {
typeName: { value: typeName },
baseNames: { value: [] },
ownFields: { value: {} },
// These two are populated during finalization.
allSupertypes: { value: {} }, // Includes own typeName.
allFields: { value: {} }, // Includes inherited fields.
type: {
value: new Type(function(value, deep) {
return self.check(value, deep);
}, typeName)
}
});
}
Def.fromValue = function(value) {
if (isObject.check(value) &&
hasOwn.call(value, "type") &&
hasOwn.call(defCache, value.type))
{
var vDef = defCache[value.type];
assert.strictEqual(vDef.finalized, true);
return vDef;
}
};
var Dp = Def.prototype;
Dp.isSupertypeOf = function(that) {
if (that instanceof Def) {
assert.strictEqual(this.finalized, true);
assert.strictEqual(that.finalized, true);
return hasOwn.call(that.allSupertypes, this.typeName);
} else {
assert.ok(false, that + " is not a Def");
}
};
Dp.checkAllFields = function(value, deep) {
var allFields = this.allFields;
assert.strictEqual(this.finalized, true);
function checkFieldByName(name) {
var field = allFields[name];
var type = field.type;
var child = field.getValue(value);
return type.check(child, deep);
}
return isObject.check(value)
&& Object.keys(allFields).every(checkFieldByName);
};
Dp.check = function(value, deep) {
assert.strictEqual(
this.finalized, true,
"prematurely checking unfinalized type " + this.typeName);
// A Def type can only match an object value.
if (!isObject.check(value))
return false;
var vDef = Def.fromValue(value);
if (!vDef) {
// If we couldn't infer the Def associated with the given value,
// and we expected it to be a SourceLocation or a Position, it was
// probably just missing a "type" field (because Esprima does not
// assign a type property to such nodes). Be optimistic and let
// this.checkAllFields make the final decision.
if (this.typeName === "SourceLocation" ||
this.typeName === "Position") {
return this.checkAllFields(value, deep);
}
// Calling this.checkAllFields for any other type of node is both
// bad for performance and way too forgiving.
return false;
}
// If checking deeply and vDef === this, then we only need to call
// checkAllFields once. Calling checkAllFields is too strict when deep
// is false, because then we only care about this.isSupertypeOf(vDef).
if (deep && vDef === this)
return this.checkAllFields(value, deep);
// In most cases we rely exclusively on isSupertypeOf to make O(1)
// subtyping determinations. This suffices in most situations outside
// of unit tests, since interface conformance is checked whenever new
// instances are created using builder functions.
if (!this.isSupertypeOf(vDef))
return false;
// The exception is when deep is true; then, we recursively check all
// fields.
if (!deep)
return true;
// Use the more specific Def (vDef) to perform the deep check, but
// shallow-check fields defined by the less specific Def (this).
return vDef.checkAllFields(value, deep)
&& this.checkAllFields(value, false);
};
Dp.bases = function() {
var bases = this.baseNames;
assert.strictEqual(this.finalized, false);
each.call(arguments, function(baseName) {
isString.assert(baseName);
// This indexOf lookup may be O(n), but the typical number of base
// names is very small, and indexOf is a native Array method.
if (bases.indexOf(baseName) < 0)
bases.push(baseName);
});
return this; // For chaining.
};
// False by default until .build(...) is called on an instance.
Object.defineProperty(Dp, "buildable", { value: false });
var builders = {};
Object.defineProperty(exports, "builders", {
value: builders
});
// This object is used as prototype for any node created by a builder.
var nodePrototype = {};
// Call this function to define a new method to be shared by all AST
// nodes. The replaced method (if any) is returned for easy wrapping.
Object.defineProperty(exports, "defineMethod", {
value: function(name, func) {
var old = nodePrototype[name];
// Pass undefined as func to delete nodePrototype[name].
if (isUndefined.check(func)) {
delete nodePrototype[name];
} else {
isFunction.assert(func);
Object.defineProperty(nodePrototype, name, {
enumerable: true, // For discoverability.
configurable: true, // For delete proto[name].
value: func
});
}
return old;
}
});
// Calling the .build method of a Def simultaneously marks the type as
// buildable (by defining builders[getBuilderName(typeName)]) and
// specifies the order of arguments that should be passed to the builder
// function to create an instance of the type.
Dp.build = function(/* param1, param2, ... */) {
var self = this;
var buildParams = slice.call(arguments);
var typeName = self.typeName;
assert.strictEqual(self.finalized, false);
isString.arrayOf().assert(buildParams);
// Every buildable type will have its "type" field filled in
// automatically. This includes types that are not subtypes of Node,
// like SourceLocation, but that seems harmless (TODO?).
self.field("type", typeName, function() { return typeName });
// Override Dp.buildable for this Def instance.
Object.defineProperty(self, "buildable", { value: true });
Object.defineProperty(builders, getBuilderName(typeName), {
enumerable: true,
value: function() {
var args = arguments;
var argc = args.length;
var built = Object.create(nodePrototype);
assert.ok(
self.finalized,
"attempting to instantiate unfinalized type " + typeName);
function add(param, i) {
if (hasOwn.call(built, param))
return;
var all = self.allFields;
assert.ok(hasOwn.call(all, param), param);
var field = all[param];
var type = field.type;
var value;
if (isNumber.check(i) && i < argc) {
value = args[i];
} else if (field.defaultFn) {
// Expose the partially-built object to the default
// function as its `this` object.
value = field.defaultFn.call(built);
} else {
var message = "no value or default function given for field " +
JSON.stringify(param) + " of " + typeName + "(" +
buildParams.map(function(name) {
return all[name];
}).join(", ") + ")";
assert.ok(false, message);
}
assert.ok(
type.check(value),
shallowStringify(value) +
" does not match field " + field +
" of type " + typeName);
// TODO Could attach getters and setters here to enforce
// dynamic type safety.
built[param] = value;
}
buildParams.forEach(function(param, i) {
add(param, i);
});
Object.keys(self.allFields).forEach(function(param) {
add(param); // Use the default value.
});
// Make sure that the "type" field was filled automatically.
assert.strictEqual(built.type, typeName);
return built;
}
});
return self; // For chaining.
};
function getBuilderName(typeName) {
return typeName.replace(/^[A-Z]+/, function(upperCasePrefix) {
var len = upperCasePrefix.length;
switch (len) {
case 0: return "";
// If there's only one initial capital letter, just lower-case it.
case 1: return upperCasePrefix.toLowerCase();
default:
// If there's more than one initial capital letter, lower-case
// all but the last one, so that XMLDefaultDeclaration (for
// example) becomes xmlDefaultDeclaration.
return upperCasePrefix.slice(
0, len - 1).toLowerCase() +
upperCasePrefix.charAt(len - 1);
}
});
}
// The reason fields are specified using .field(...) instead of an object
// literal syntax is somewhat subtle: the object literal syntax would
// support only one key and one value, but with .field(...) we can pass
// any number of arguments to specify the field.
Dp.field = function(name, type, defaultFn, hidden) {
assert.strictEqual(this.finalized, false);
this.ownFields[name] = new Field(name, type, defaultFn, hidden);
return this; // For chaining.
};
var namedTypes = {};
Object.defineProperty(exports, "namedTypes", {
value: namedTypes
});
// Get the value of an object property, taking object.type and default
// functions into account.
Object.defineProperty(exports, "getFieldValue", {
value: function(object, fieldName) {
var d = Def.fromValue(object);
if (d) {
var field = d.allFields[fieldName];
if (field) {
return field.getValue(object);
}
}
return object[fieldName];
}
});
// Iterate over all defined fields of an object, including those missing
// or undefined, passing each field name and effective value (as returned
// by getFieldValue) to the callback. If the object has no corresponding
// Def, the callback will never be called.
Object.defineProperty(exports, "eachField", {
value: function(object, callback, context) {
var d = Def.fromValue(object);
if (d) {
var all = d.allFields;
Object.keys(all).forEach(function(name) {
var field = all[name];
if (!field.hidden) {
callback.call(this, name, field.getValue(object));
}
}, context);
} else {
assert.strictEqual(
"type" in object, false,
"did not recognize object of type " + JSON.stringify(object.type)
);
// If we could not infer a Def type for this object, just
// iterate over its keys in the normal way.
Object.keys(object).forEach(function(name) {
callback.call(this, name, object[name]);
}, context);
}
}
});
// Similar to eachField, except that iteration stops as soon as the
// callback returns a truthy value. Like Array.prototype.some, the final
// result is either true or false to indicates whether the callback
// returned true for any element or not.
Object.defineProperty(exports, "someField", {
value: function(object, callback, context) {
var d = Def.fromValue(object);
if (d) {
var all = d.allFields;
return Object.keys(all).some(function(name) {
var field = all[name];
if (!field.hidden) {
var value = field.getValue(object);
return callback.call(this, name, value);
}
}, context);
}
assert.strictEqual(
"type" in object, false,
"did not recognize object of type " + JSON.stringify(object.type)
);
// If we could not infer a Def type for this object, just iterate
// over its keys in the normal way.
return Object.keys(object).some(function(name) {
return callback.call(this, name, object[name]);
}, context);
}
});
// This property will be overridden as true by individual Def instances
// when they are finalized.
Object.defineProperty(Dp, "finalized", { value: false });
Dp.finalize = function() {
// It's not an error to finalize a type more than once, but only the
// first call to .finalize does anything.
if (!this.finalized) {
var allFields = this.allFields;
var allSupertypes = this.allSupertypes;
this.baseNames.forEach(function(name) {
var def = defCache[name];
def.finalize();
extend(allFields, def.allFields);
extend(allSupertypes, def.allSupertypes);
});
// TODO Warn if fields are overridden with incompatible types.
extend(allFields, this.ownFields);
allSupertypes[this.typeName] = this;
// Types are exported only once they have been finalized.
Object.defineProperty(namedTypes, this.typeName, {
enumerable: true,
value: this.type
});
Object.defineProperty(this, "finalized", { value: true });
}
};
function extend(into, from) {
Object.keys(from).forEach(function(name) {
into[name] = from[name];
});
return into;
};
Object.defineProperty(exports, "finalize", {
// This function should be called at the end of any complete file of
// type definitions. It declares that everything defined so far is
// complete and needs no further modification, and defines all
// finalized types as properties of exports.namedTypes.
value: function() {
Object.keys(defCache).forEach(function(name) {
defCache[name].finalize();
});
}
});
/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {
var types = __webpack_require__(9);
var Type = types.Type;
var def = Type.def;
var or = Type.or;
var builtin = types.builtInTypes;
var isString = builtin.string;
var isNumber = builtin.number;
var isBoolean = builtin.boolean;
var isRegExp = builtin.RegExp;
var shared = __webpack_require__(11);
var defaults = shared.defaults;
var geq = shared.geq;
def("Node")
.field("type", isString)
.field("loc", or(
def("SourceLocation"),
null
), defaults["null"]);
def("SourceLocation")
.build("start", "end", "source")
.field("start", def("Position"))
.field("end", def("Position"))
.field("source", or(isString, null), defaults["null"]);
def("Position")
.build("line", "column")
.field("line", geq(1))
.field("column", geq(0));
def("Program")
.bases("Node")
.build("body")
.field("body", [def("Statement")]);
def("Function")
.bases("Node")
.field("id", or(def("Identifier"), null), defaults["null"])
.field("params", [def("Pattern")])
.field("body", or(def("BlockStatement"), def("Expression")))
.field("generator", isBoolean, defaults["false"])
.field("expression", isBoolean, defaults["false"])
.field("defaults", [def("Expression")], defaults.emptyArray)
.field("rest", or(def("Identifier"), null), defaults["null"]);
def("Statement").bases("Node");
// The empty .build() here means that an EmptyStatement can be constructed
// (i.e. it's not abstract) but that it needs no arguments.
def("EmptyStatement").bases("Statement").build();
def("BlockStatement")
.bases("Statement")
.build("body")
.field("body", [def("Statement")]);
// TODO Figure out how to silently coerce Expressions to
// ExpressionStatements where a Statement was expected.
def("ExpressionStatement")
.bases("Statement")
.build("expression")
.field("expression", def("Expression"));
def("IfStatement")
.bases("Statement")
.build("test", "consequent", "alternate")
.field("test", def("Expression"))
.field("consequent", def("Statement"))
.field("alternate", or(def("Statement"), null), defaults["null"]);
def("LabeledStatement")
.bases("Statement")
.build("label", "body")
.field("label", def("Identifier"))
.field("body", def("Statement"));
def("BreakStatement")
.bases("Statement")
.build("label")
.field("label", or(def("Identifier"), null), defaults["null"]);
def("ContinueStatement")
.bases("Statement")
.build("label")
.field("label", or(def("Identifier"), null), defaults["null"]);
def("WithStatement")
.bases("Statement")
.build("object", "body")
.field("object", def("Expression"))
.field("body", def("Statement"));
def("SwitchStatement")
.bases("Statement")
.build("discriminant", "cases", "lexical")
.field("discriminant", def("Expression"))
.field("cases", [def("SwitchCase")])
.field("lexical", isBoolean, defaults["false"]);
def("ReturnStatement")
.bases("Statement")
.build("argument")
.field("argument", or(def("Expression"), null));
def("ThrowStatement")
.bases("Statement")
.build("argument")
.field("argument", def("Expression"));
def("TryStatement")
.bases("Statement")
.build("block", "handler", "finalizer")
.field("block", def("BlockStatement"))
.field("handler", or(def("CatchClause"), null), function() {
return this.handlers && this.handlers[0] || null;
})
.field("handlers", [def("CatchClause")], function() {
return this.handler ? [this.handler] : [];
}, true) // Indicates this field is hidden from eachField iteration.
.field("guardedHandlers", [def("CatchClause")], defaults.emptyArray)
.field("finalizer", or(def("BlockStatement"), null), defaults["null"]);
def("CatchClause")
.bases("Node")
.build("param", "guard", "body")
.field("param", def("Pattern"))
.field("guard", or(def("Expression"), null), defaults["null"])
.field("body", def("BlockStatement"));
def("WhileStatement")
.bases("Statement")
.build("test", "body")
.field("test", def("Expression"))
.field("body", def("Statement"));
def("DoWhileStatement")
.bases("Statement")
.build("body", "test")
.field("body", def("Statement"))
.field("test", def("Expression"));
def("ForStatement")
.bases("Statement")
.build("init", "test", "update", "body")
.field("init", or(
def("VariableDeclaration"),
def("Expression"),
null))
.field("test", or(def("Expression"), null))
.field("update", or(def("Expression"), null))
.field("body", def("Statement"));
def("ForInStatement")
.bases("Statement")
.build("left", "right", "body", "each")
.field("left", or(
def("VariableDeclaration"),
def("Expression")))
.field("right", def("Expression"))
.field("body", def("Statement"))
.field("each", isBoolean);
def("DebuggerStatement").bases("Statement").build();
def("Declaration").bases("Statement");
def("FunctionDeclaration")
.bases("Function", "Declaration")
.build("id", "params", "body", "generator", "expression")
.field("id", def("Identifier"));
def("FunctionExpression")
.bases("Function", "Expression")
.build("id", "params", "body", "generator", "expression");
def("VariableDeclaration")
.bases("Declaration")
.build("kind", "declarations")
.field("kind", or("var", "let", "const"))
.field("declarations", [or(
def("VariableDeclarator"),
def("Identifier") // TODO Esprima deviation.
)]);
def("VariableDeclarator")
.bases("Node")
.build("id", "init")
.field("id", def("Pattern"))
.field("init", or(def("Expression"), null));
// TODO Are all Expressions really Patterns?
def("Expression").bases("Node", "Pattern");
def("ThisExpression").bases("Expression").build();
def("ArrayExpression")
.bases("Expression")
.build("elements")
.field("elements", [or(def("Expression"), null)]);
def("ObjectExpression")
.bases("Expression")
.build("properties")
.field("properties", [def("Property")]);
// TODO Not in the Mozilla Parser API, but used by Esprima.
def("Property")
.bases("Node") // Want to be able to visit Property Nodes.
.build("kind", "key", "value")
.field("kind", or("init", "get", "set"))
.field("key", or(def("Literal"), def("Identifier")))
.field("value", def("Expression"))
// Esprima extensions not mentioned in the Mozilla Parser API:
.field("method", isBoolean, defaults["false"])
.field("shorthand", isBoolean, defaults["false"]);
def("SequenceExpression")
.bases("Expression")
.build("expressions")
.field("expressions", [def("Expression")]);
var UnaryOperator = or(
"-", "+", "!", "~",
"typeof", "void", "delete");
def("UnaryExpression")
.bases("Expression")
.build("operator", "argument", "prefix")
.field("operator", UnaryOperator)
.field("argument", def("Expression"))
// TODO Esprima doesn't bother with this field, presumably because
// it's always true for unary operators.
.field("prefix", isBoolean, defaults["true"]);
var BinaryOperator = or(
"==", "!=", "===", "!==",
"<", "<=", ">", ">=",
"<<", ">>", ">>>",
"+", "-", "*", "/", "%",
"&", // TODO Missing from the Parser API.
"|", "^", "in",
"instanceof", "..");
def("BinaryExpression")
.bases("Expression")
.build("operator", "left", "right")
.field("operator", BinaryOperator)
.field("left", def("Expression"))
.field("right", def("Expression"));
var AssignmentOperator = or(
"=", "+=", "-=", "*=", "/=", "%=",
"<<=", ">>=", ">>>=",
"|=", "^=", "&=");
def("AssignmentExpression")
.bases("Expression")
.build("operator", "left", "right")
.field("operator", AssignmentOperator)
// TODO Shouldn't this be def("Pattern")?
.field("left", def("Expression"))
.field("right", def("Expression"));
var UpdateOperator = or("++", "--");
def("UpdateExpression")
.bases("Expression")
.build("operator", "argument", "prefix")
.field("operator", UpdateOperator)
.field("argument", def("Expression"))
.field("prefix", isBoolean);
var LogicalOperator = or("||", "&&");
def("LogicalExpression")
.bases("Expression")
.build("operator", "left", "right")
.field("operator", LogicalOperator)
.field("left", def("Expression"))
.field("right", def("Expression"));
def("ConditionalExpression")
.bases("Expression")
.build("test", "consequent", "alternate")
.field("test", def("Expression"))
.field("consequent", def("Expression"))
.field("alternate", def("Expression"));
def("NewExpression")
.bases("Expression")
.build("callee", "arguments")
.field("callee", def("Expression"))
// The Mozilla Parser API gives this type as [or(def("Expression"),
// null)], but null values don't really make sense at the call site.
// TODO Report this nonsense.
.field("arguments", [def("Expression")]);
def("CallExpression")
.bases("Expression")
.build("callee", "arguments")
.field("callee", def("Expression"))
// See comment for NewExpression above.
.field("arguments", [def("Expression")]);
def("MemberExpression")
.bases("Expression")
.build("object", "property", "computed")
.field("object", def("Expression"))
.field("property", or(def("Identifier"), def("Expression")))
.field("computed", isBoolean);
def("Pattern").bases("Node");
def("ObjectPattern")
.bases("Pattern")
.build("properties")
// TODO File a bug to get PropertyPattern added to the interfaces API.
.field("properties", [def("PropertyPattern")]);
def("PropertyPattern")
.bases("Pattern")
.build("key", "pattern")
.field("key", or(def("Literal"), def("Identifier")))
.field("pattern", def("Pattern"));
def("ArrayPattern")
.bases("Pattern")
.build("elements")
.field("elements", [or(def("Pattern"), null)]);
def("SwitchCase")
.bases("Node")
.build("test", "consequent")
.field("test", or(def("Expression"), null))
.field("consequent", [def("Statement")]);
def("Identifier")
// But aren't Expressions and Patterns already Nodes? TODO Report this.
.bases("Node", "Expression", "Pattern")
.build("name")
.field("name", isString);
def("Literal")
// But aren't Expressions already Nodes? TODO Report this.
.bases("Node", "Expression")
.build("value")
.field("value", or(
isString,
isBoolean,
null, // isNull would also work here.
isNumber,
isRegExp
));
types.finalize();
/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {
var types = __webpack_require__(9);
var Type = types.Type;
var builtin = types.builtInTypes;
var isNumber = builtin.number;
// An example of constructing a new type with arbitrary constraints from
// an existing type.
exports.geq = function(than) {
return new Type(function(value) {
return isNumber.check(value) && value >= than;
}, isNumber + " >= " + than);
};
// Default value-returning functions that may optionally be passed as a
// third argument to Def.prototype.field.
exports.defaults = {
// Functions were used because (among other reasons) that's the most
// elegant way to allow for the emptyArray one always to give a new
// array instance.
"null": function() { return null },
"emptyArray": function() { return [] },
"false": function() { return false },
"true": function() { return true },
"undefined": function() {}
};
var naiveIsPrimitive = Type.or(
builtin.string,
builtin.number,
builtin.boolean,
builtin.null,
builtin.undefined
);
exports.isPrimitive = new Type(function(value) {
if (value === null)
return true;
var type = typeof value;
return !(type === "object" ||
type === "function");
}, naiveIsPrimitive.toString());
/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(10);
var types = __webpack_require__(9);
var def = types.Type.def;
var or = types.Type.or;
var builtin = types.builtInTypes;
var isBoolean = builtin.boolean;
var isString = builtin.string;
var defaults = __webpack_require__(11).defaults;
// TODO The Parser API calls this ArrowExpression, but Esprima uses
// ArrowFunctionExpression.
def("ArrowFunctionExpression")
.bases("Function", "Expression")
.build("params", "body", "expression")
// The forced null value here is compatible with the overridden
// definition of the "id" field in the Function interface.
.field("id", null, defaults["null"])
// The current spec forbids arrow generators, so I have taken the
// liberty of enforcing that. TODO Report this.
.field("generator", false, defaults["false"]);
def("YieldExpression")
.bases("Expression")
.build("argument", "delegate")
.field("argument", or(def("Expression"), null))
.field("delegate", isBoolean, false);
def("GeneratorExpression")
.bases("Expression")
.build("body", "blocks", "filter")
.field("body", def("Expression"))
.field("blocks", [def("ComprehensionBlock")])
.field("filter", or(def("Expression"), null));
def("ComprehensionExpression")
.bases("Expression")
.build("body", "blocks", "filter")
.field("body", def("Expression"))
.field("blocks", [def("ComprehensionBlock")])
.field("filter", or(def("Expression"), null));
def("ComprehensionBlock")
.bases("Node")
.build("left", "right", "each")
.field("left", def("Pattern"))
.field("right", def("Expression"))
.field("each", isBoolean);
// This would be the ideal definition for ModuleSpecifier, but alas we
// can't expect ASTs parsed by Esprima to use this custom subtype:
def("ModuleSpecifier")
.bases("Specifier", "Literal")
// .build("value") // Make it abstract/non-buildable for now.
.field("value", isString);
// Instead we must settle for a cheap type alias:
var ModuleSpecifier = def("Literal");
def("ModuleDeclaration")
.bases("Declaration")
.build("id", "from", "body")
.field("id", or(def("Literal"), def("Identifier")))
.field("source", or(ModuleSpecifier, null))
.field("body", or(def("BlockStatement"), null));
def("MethodDefinition")
.bases("Declaration")
.build("kind", "key", "value")
.field("kind", or("init", "get", "set", ""))
.field("key", or(def("Literal"), def("Identifier")))
.field("value", def("Function"));
def("SpreadElement")
.bases("Pattern")
.build("argument")
.field("argument", def("Pattern"));
var ClassBodyElement = or(
def("MethodDefinition"),
def("VariableDeclarator"),
def("ClassPropertyDefinition")
);
def("ClassPropertyDefinition") // static property
.bases("Declaration")
.build("definition")
// Yes, Virginia, circular definitions are permitted.
.field("definition", ClassBodyElement);
def("ClassBody")
.bases("Declaration")
.build("body")
.field("body", [ClassBodyElement]);
def("ClassDeclaration")
.bases("Declaration")
.build("id", "body", "superClass")
.field("id", def("Identifier"))
.field("body", def("ClassBody"))
.field("superClass", or(def("Expression"), null), defaults["null"]);
def("ClassExpression")
.bases("Expression")
.build("id", "body", "superClass")
.field("id", or(def("Identifier"), null), defaults["null"])
.field("body", def("ClassBody"))
.field("superClass", or(def("Expression"), null), defaults["null"]);
// Specifier and NamedSpecifier are non-standard types that I introduced
// for definitional convenience.
def("Specifier").bases("Node");
def("NamedSpecifier")
.bases("Specifier")
.field("id", def("Identifier"))
.field("name", def("Identifier"), defaults["null"]);
def("ExportSpecifier")
.bases("NamedSpecifier")
.build("id", "name");
def("ExportBatchSpecifier")
.bases("Specifier")
.build();
def("ImportSpecifier")
.bases("NamedSpecifier")
.build("id", "name");
def("ExportDeclaration")
.bases("Declaration")
.build("default", "declaration", "specifiers", "source")
.field("default", isBoolean)
.field("declaration", or(
def("Declaration"),
def("AssignmentExpression") // Implies default.
))
.field("specifiers", [or(
def("ExportSpecifier"),
def("ExportBatchSpecifier")
)])
.field("source", or(ModuleSpecifier, null));
def("ImportDeclaration")
.bases("Declaration")
.build("specifiers", "kind", "source")
.field("specifiers", [def("ImportSpecifier")])
.field("kind", or("named", "default"))
.field("source", ModuleSpecifier);
types.finalize();
/***/ },
/* 13 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(10);
var types = __webpack_require__(9);
var def = types.Type.def;
var or = types.Type.or;
var geq = __webpack_require__(11).geq;
def("ForOfStatement")
.bases("Statement")
.build("left", "right", "body")
.field("left", or(
def("VariableDeclaration"),
def("Expression")))
.field("right", def("Expression"))
.field("body", def("Statement"));
def("LetStatement")
.bases("Statement")
.build("head", "body")
// TODO Deviating from the spec by reusing VariableDeclarator here.
.field("head", [def("VariableDeclarator")])
.field("body", def("Statement"));
def("LetExpression")
.bases("Expression")
.build("head", "body")
// TODO Deviating from the spec by reusing VariableDeclarator here.
.field("head", [def("VariableDeclarator")])
.field("body", def("Expression"));
def("GraphExpression")
.bases("Expression")
.build("index", "expression")
.field("index", geq(0))
.field("expression", def("Literal"));
def("GraphIndexExpression")
.bases("Expression")
.build("index")
.field("index", geq(0));
types.finalize();
/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(10);
var types = __webpack_require__(9);
var def = types.Type.def;
var or = types.Type.or;
var builtin = types.builtInTypes;
var isString = builtin.string;
var isBoolean = builtin.boolean;
// Note that none of these types are buildable because the Mozilla Parser
// API doesn't specify any builder functions, and nobody uses E4X anymore.
def("XMLDefaultDeclaration")
.bases("Declaration")
.field("namespace", def("Expression"));
def("XMLAnyName").bases("Expression");
def("XMLQualifiedIdentifier")
.bases("Expression")
.field("left", or(def("Identifier"), def("XMLAnyName")))
.field("right", or(def("Identifier"), def("Expression")))
.field("computed", isBoolean);
def("XMLFunctionQualifiedIdentifier")
.bases("Expression")
.field("right", or(def("Identifier"), def("Expression")))
.field("computed", isBoolean);
def("XMLAttributeSelector")
.bases("Expression")
.field("attribute", def("Expression"));
def("XMLFilterExpression")
.bases("Expression")
.field("left", def("Expression"))
.field("right", def("Expression"));
def("XMLElement")
.bases("XML", "Expression")
.field("contents", [def("XML")]);
def("XMLList")
.bases("XML", "Expression")
.field("contents", [def("XML")]);
def("XML").bases("Node");
def("XMLEscape")
.bases("XML")
.field("expression", def("Expression"));
def("XMLText")
.bases("XML")
.field("text", isString);
def("XMLStartTag")
.bases("XML")
.field("contents", [def("XML")]);
def("XMLEndTag")
.bases("XML")
.field("contents", [def("XML")]);
def("XMLPointTag")
.bases("XML")
.field("contents", [def("XML")]);
def("XMLName")
.bases("XML")
.field("contents", or(isString, [def("XML")]));
def("XMLAttribute")
.bases("XML")
.field("value", isString);
def("XMLCdata")
.bases("XML")
.field("contents", isString);
def("XMLComment")
.bases("XML")
.field("contents", isString);
def("XMLProcessingInstruction")
.bases("XML")
.field("target", isString)
.field("contents", or(isString, null));
types.finalize();
/***/ },
/* 15 */
/***/ function(module, exports, __webpack_require__) {
__webpack_require__(10);
var types = __webpack_require__(9);
var def = types.Type.def;
var or = types.Type.or;
var builtin = types.builtInTypes;
var isString = builtin.string;
var isBoolean = builtin.boolean;
var defaults = __webpack_require__(11).defaults;
def("XJSAttribute")
.bases("Node")
.build("name", "value")
.field("name", def("XJSIdentifier"))
.field("value", or(
def("Literal"), // attr="value"
def("XJSExpressionContainer"), // attr={value}
null // attr= or just attr
), defaults["null"]);
def("XJSIdentifier")
.bases("Node")
.build("name", "namespace")
.field("name", isString)
.field("namespace", or(isString, null), defaults["null"]);
def("XJSExpressionContainer")
.bases("Expression")
.build("expression")
.field("expression", def("Expression"));
def("XJSElement")
.bases("Expression")
.build("openingElement", "closingElement", "children")
.field("openingElement", def("XJSOpeningElement"))
.field("closingElement", or(def("XJSClosingElement"), null), defaults["null"])
.field("children", [or(
def("XJSElement"),
def("XJSExpressionContainer"),
def("XJSText"),
def("Literal") // TODO Esprima should return XJSText instead.
)], defaults.emptyArray)
.field("name", def("XJSIdentifier"), function() {
// Little-known fact: the `this` object inside a default function
// is none other than the partially-built object itself, and any
// fields initialized directly from builder function arguments
// (like openingElement, closingElement, and children) are
// guaranteed to be available.
return this.openingElement.name;
})
.field("selfClosing", isBoolean, function() {
return this.openingElement.selfClosing;
})
.field("attributes", [def("XJSAttribute")], function() {
return this.openingElement.attributes;
});
def("XJSOpeningElement")
.bases("Node") // TODO Does this make sense? Can't really be an XJSElement.
.build("name", "attributes", "selfClosing")
.field("name", def("XJSIdentifier"))
.field("attributes", [def("XJSAttribute")], defaults.emptyArray)
.field("selfClosing", isBoolean, defaults["false"]);
def("XJSClosingElement")
.bases("Node") // TODO Same concern.
.build("name")
.field("name", def("XJSIdentifier"));
def("XJSText")
.bases("Literal")
.build("value")
.field("value", isString);
def("XJSEmptyExpression").bases("Expression").build();
def("TypeAnnotatedIdentifier")
.bases("Pattern")
.build("annotation", "identifier")
.field("annotation", def("TypeAnnotation"))
.field("identifier", def("Identifier"));
def("TypeAnnotation")
.bases("Pattern")
.build("annotatedType", "templateTypes", "paramTypes", "returnType",
"unionType", "nullable")
.field("annotatedType", def("Identifier"))
.field("templateTypes", or([def("TypeAnnotation")], null))
.field("paramTypes", or([def("TypeAnnotation")], null))
.field("returnType", or(def("TypeAnnotation"), null))
.field("unionType", or(def("TypeAnnotation"), null))
.field("nullable", isBoolean);
types.finalize();
/***/ },
/* 16 */
/***/ function(module, exports, __webpack_require__) {
var assert = __webpack_require__(2);
var types = __webpack_require__(9);
var Node = types.namedTypes.Node;
var isObject = types.builtInTypes.object;
var isArray = types.builtInTypes.array;
var NodePath = __webpack_require__(17);
var funToStr = Function.prototype.toString;
var thisPattern = /\bthis\b/;
// Good for traversals that need to modify the syntax tree or to access
// path/scope information via `this` (a NodePath object). Somewhat slower
// than traverseWithNoPathInfo because of the NodePath bookkeeping.
function traverseWithFullPathInfo(node, callback) {
if (!thisPattern.test(funToStr.call(callback))) {
// If the callback function contains no references to `this`, then
// it will have no way of using any of the NodePath information
// that traverseWithFullPathInfo provides, so we can skip that
// bookkeeping altogether.
return traverseWithNoPathInfo(node, callback);
}
function traverse(path) {
assert.ok(path instanceof NodePath);
var value = path.value;
if (isArray.check(value)) {
path.each(traverse);
return;
}
if (Node.check(value)) {
if (callback.call(path, value, traverse) === false) {
return;
}
} else if (!isObject.check(value)) {
return;
}
types.eachField(value, function(name, child) {
var childPath = path.get(name);
if (childPath.value !== child) {
childPath.replace(child);
}
traverse(childPath);
});
}
if (node instanceof NodePath) {
traverse(node);
return node.value;
}
// Just in case we call this.replace at the root, there needs to be an
// additional parent Path to update.
var rootPath = new NodePath({ root: node });
traverse(rootPath.get("root"));
return rootPath.value.root;
}
// Good for read-only traversals that do not require any NodePath
// information. Faster than traverseWithFullPathInfo because less
// information is exposed. A context parameter is supported because `this`
// no longer has to be a NodePath object.
function traverseWithNoPathInfo(node, callback, context) {
context = context || null;
function traverse(node) {
if (isArray.check(node)) {
node.forEach(traverse);
return;
}
if (Node.check(node)) {
if (callback.call(context, node, traverse) === false) {
return;
}
} else if (!isObject.check(node)) {
return;
}
types.eachField(node, function(name, child) {
traverse(child);
});
}
traverse(node);
return node;
}
// Since we export traverseWithFullPathInfo as module.exports, we need to
// attach traverseWithNoPathInfo to it as a property. In other words, you
// should use require("ast-types").traverse.fast(ast, ...) to invoke the
// quick-and-dirty traverseWithNoPathInfo function.
traverseWithFullPathInfo.fast = traverseWithNoPathInfo;
module.exports = traverseWithFullPathInfo;
/***/ },
/* 17 */
/***/ function(module, exports, __webpack_require__) {
var assert = __webpack_require__(2);
var types = __webpack_require__(9);
var n = types.namedTypes;
var isNumber = types.builtInTypes.number;
var isArray = types.builtInTypes.array;
var Path = __webpack_require__(18).Path;
var Scope = __webpack_require__(21);
function NodePath(value, parentPath, name) {
assert.ok(this instanceof NodePath);
Path.call(this, value, parentPath, name);
}
__webpack_require__(3).inherits(NodePath, Path);
var NPp = NodePath.prototype;
Object.defineProperties(NPp, {
node: {
get: function() {
Object.defineProperty(this, "node", {
value: this._computeNode()
});
return this.node;
}
},
parent: {
get: function() {
Object.defineProperty(this, "parent", {
value: this._computeParent()
});
return this.parent;
}
},
scope: {
get: function() {
Object.defineProperty(this, "scope", {
value: this._computeScope()
});
return this.scope;
}
}
});
// The value of the first ancestor Path whose value is a Node.
NPp._computeNode = function() {
var value = this.value;
if (n.Node.check(value)) {
return value;
}
var pp = this.parentPath;
return pp && pp.node || null;
};
// The first ancestor Path whose value is a Node distinct from this.node.
NPp._computeParent = function() {
var value = this.value;
var pp = this.parentPath;
if (!n.Node.check(value)) {
while (pp && !n.Node.check(pp.value)) {
pp = pp.parentPath;
}
if (pp) {
pp = pp.parentPath;
}
}
while (pp && !n.Node.check(pp.value)) {
pp = pp.parentPath;
}
return pp || null;
};
// The closest enclosing scope that governs this node.
NPp._computeScope = function() {
var value = this.value;
var pp = this.parentPath;
var scope = pp && pp.scope;
if (n.Node.check(value) &&
Scope.isEstablishedBy(value)) {
scope = new Scope(this, scope);
}
return scope || null;
};
NPp.getValueProperty = function(name) {
return types.getFieldValue(this.value, name);
};
NPp.needsParens = function() {
if (!this.parent)
return false;
var node = this.node;
// If this NodePath object is not the direct owner of this.node, then
// we do not need parentheses here, though the direct owner might need
// parentheses.
if (node !== this.value)
return false;
var parent = this.parent.node;
assert.notStrictEqual(node, parent);
if (!n.Expression.check(node))
return false;
if (n.UnaryExpression.check(node))
return n.MemberExpression.check(parent)
&& this.name === "object"
&& parent.object === node;
if (isBinary(node)) {
if (n.CallExpression.check(parent) &&
this.name === "callee") {
assert.strictEqual(parent.callee, node);
return true;
}
if (n.UnaryExpression.check(parent))
return true;
if (n.MemberExpression.check(parent) &&
this.name === "object") {
assert.strictEqual(parent.object, node);
return true;
}
if (isBinary(parent)) {
var po = parent.operator;
var pp = PRECEDENCE[po];
var no = node.operator;
var np = PRECEDENCE[no];
if (pp > np) {
return true;
}
if (pp === np && this.name === "right") {
assert.strictEqual(parent.right, node);
return true;
}
}
}
if (n.SequenceExpression.check(node))
return n.CallExpression.check(parent)
|| n.UnaryExpression.check(parent)
|| isBinary(parent)
|| n.VariableDeclarator.check(parent)
|| n.MemberExpression.check(parent)
|| n.ArrayExpression.check(parent)
|| n.Property.check(parent)
|| n.ConditionalExpression.check(parent);
if (n.YieldExpression.check(node))
return isBinary(parent)
|| n.CallExpression.check(parent)
|| n.MemberExpression.check(parent)
|| n.NewExpression.check(parent)
|| n.ConditionalExpression.check(parent)
|| n.UnaryExpression.check(parent)
|| n.YieldExpression.check(parent);
if (n.NewExpression.check(parent) &&
this.name === "callee") {
assert.strictEqual(parent.callee, node);
return containsCallExpression(node);
}
if (n.Literal.check(node) &&
isNumber.check(node.value) &&
n.MemberExpression.check(parent) &&
this.name === "object") {
assert.strictEqual(parent.object, node);
return true;
}
if (n.AssignmentExpression.check(node) ||
n.ConditionalExpression.check(node)) {
if (n.UnaryExpression.check(parent))
return true;
if (isBinary(parent))
return true;
if (n.CallExpression.check(parent) &&
this.name === "callee") {
assert.strictEqual(parent.callee, node);
return true;
}
if (n.ConditionalExpression.check(parent) &&
this.name === "test") {
assert.strictEqual(parent.test, node);
return true;
}
if (n.MemberExpression.check(parent) &&
this.name === "object") {
assert.strictEqual(parent.object, node);
return true;
}
}
if (n.FunctionExpression.check(node) &&
this.firstInStatement())
return true;
if (n.ObjectExpression.check(node) &&
this.firstInStatement())
return true;
return false;
};
function isBinary(node) {
return n.BinaryExpression.check(node)
|| n.LogicalExpression.check(node);
}
var PRECEDENCE = {};
[["||"],
["&&"],
["|"],
["^"],
["&"],
["==", "===", "!=", "!=="],
["<", ">", "<=", ">=", "in", "instanceof"],
[">>", "<<", ">>>"],
["+", "-"],
["*", "/", "%"]
].forEach(function(tier, i) {
tier.forEach(function(op) {
PRECEDENCE[op] = i;
});
});
function containsCallExpression(node) {
if (n.CallExpression.check(node)) {
return true;
}
if (isArray.check(node)) {
return node.some(containsCallExpression);
}
if (n.Node.check(node)) {
return types.someField(node, function(name, child) {
return containsCallExpression(child);
});
}
return false;
}
NPp.firstInStatement = function() {
return firstInStatement(this);
};
function firstInStatement(path) {
for (var node, parent; path.parent; path = path.parent) {
node = path.node;
parent = path.parent.node;
if (n.BlockStatement.check(parent) &&
path.parent.name === "body" &&
path.name === 0) {
assert.strictEqual(parent.body[0], node);
return true;
}
if (n.ExpressionStatement.check(parent) &&
path.name === "expression") {
assert.strictEqual(parent.expression, node);
return true;
}
if (n.SequenceExpression.check(parent) &&
path.parent.name === "expressions" &&
path.name === 0) {
assert.strictEqual(parent.expressions[0], node);
continue;
}
if (n.CallExpression.check(parent) &&
path.name === "callee") {
assert.strictEqual(parent.callee, node);
continue;
}
if (n.MemberExpression.check(parent) &&
path.name === "object") {
assert.strictEqual(parent.object, node);
continue;
}
if (n.ConditionalExpression.check(parent) &&
path.name === "test") {
assert.strictEqual(parent.test, node);
continue;
}
if (isBinary(parent) &&
path.name === "left") {
assert.strictEqual(parent.left, node);
continue;
}
if (n.UnaryExpression.check(parent) &&
!parent.prefix &&
path.name === "argument") {
assert.strictEqual(parent.argument, node);
continue;
}
return false;
}
return true;
}
module.exports = NodePath;
/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {
exports.Path = __webpack_require__(19).Path;
/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {
var assert = __webpack_require__(2);
var getChildCache = __webpack_require__(20).makeAccessor();
var Op = Object.prototype;
var hasOwn = Op.hasOwnProperty;
var toString = Op.toString;
var arrayToString = toString.call([]);
var Ap = Array.prototype;
var slice = Ap.slice;
var map = Ap.map;
function Path(value, parentPath, name) {
assert.ok(this instanceof Path);
if (parentPath) {
assert.ok(parentPath instanceof Path);
} else {
parentPath = null;
name = null;
}
Object.defineProperties(this, {
// The value encapsulated by this Path, generally equal to
// parentPath.value[name] if we have a parentPath.
value: { value: value },
// The immediate parent Path of this Path.
parentPath: { value: parentPath },
// The name of the property of parentPath.value through which this
// Path's value was reached.
name: {
value: name,
configurable: true
}
});
}
var Pp = Path.prototype;
function getChildPath(path, name) {
var cache = getChildCache(path);
return hasOwn.call(cache, name)
? cache[name]
: cache[name] = new path.constructor(
path.getValueProperty(name), path, name);
}
// This method is designed to be overridden by subclasses that need to
// handle missing properties, etc.
Pp.getValueProperty = function(name) {
return this.value[name];
};
Pp.get = function(name) {
var path = this;
var names = arguments;
var count = names.length;
for (var i = 0; i < count; ++i) {
path = getChildPath(path, names[i]);
}
return path;
};
Pp.each = function(callback, context) {
var childPaths = [];
var len = this.value.length;
var i = 0;
// Collect all the original child paths before invoking the callback.
for (var i = 0; i < len; ++i) {
if (hasOwn.call(this.value, i)) {
childPaths[i] = this.get(i);
}
}
// Invoke the callback on just the original child paths, regardless of
// any modifications made to the array by the callback. I chose these
// semantics over cleverly invoking the callback on new elements because
// this way is much easier to reason about.
context = context || this;
for (i = 0; i < len; ++i) {
if (hasOwn.call(childPaths, i)) {
callback.call(context, childPaths[i]);
}
}
};
Pp.map = function(callback, context) {
var result = [];
this.each(function(childPath) {
result.push(callback.call(this, childPath));
}, context);
return result;
};
Pp.filter = function(callback, context) {
var result = [];
this.each(function(childPath) {
if (callback.call(this, childPath)) {
result.push(childPath);
}
}, context);
return result;
};
Pp.replace = function(replacement) {
var count = arguments.length;
assert.ok(
this.parentPath instanceof Path,
"Instead of replacing the root of the tree, create a new tree."
);
var name = this.name;
var parentValue = this.parentPath.value;
var parentCache = getChildCache(this.parentPath);
var results = [];
if (toString.call(parentValue) === arrayToString) {
delete parentCache.length;
delete parentCache[name];
var moved = {};
for (var i = name + 1; i < parentValue.length; ++i) {
var child = parentCache[i];
if (child) {
var newIndex = i - 1 + count;
moved[newIndex] = child;
Object.defineProperty(child, "name", { value: newIndex });
delete parentCache[i];
}
}
var args = slice.call(arguments);
args.unshift(name, 1);
parentValue.splice.apply(parentValue, args);
for (newIndex in moved) {
if (hasOwn.call(moved, newIndex)) {
parentCache[newIndex] = moved[newIndex];
}
}
for (i = name; i < name + count; ++i) {
results.push(this.parentPath.get(i));
}
} else if (count === 1) {
delete parentCache[name];
parentValue[name] = replacement;
results.push(this.parentPath.get(name));
} else if (count === 0) {
delete parentCache[name];
delete parentValue[name];
} else {
assert.ok(false, "Could not replace Path.");
}
return results;
};
exports.Path = Path;
/***/ },
/* 20 */
/***/ function(module, exports) {
"use strict";
var defProp = Object.defineProperty || function(obj, name, desc) {
// Normal property assignment is the best we can do if
// Object.defineProperty is not available.
obj[name] = desc.value;
};
// For functions that will be invoked using .call or .apply, we need to
// define those methods on the function objects themselves, rather than
// inheriting them from Function.prototype, so that a malicious or clumsy
// third party cannot interfere with the functionality of this module by
// redefining Function.prototype.call or .apply.
function makeSafeToCall(fun) {
defProp(fun, "call", { value: fun.call });
defProp(fun, "apply", { value: fun.apply });
return fun;
}
var hasOwn = makeSafeToCall(Object.prototype.hasOwnProperty);
var numToStr = makeSafeToCall(Number.prototype.toString);
var strSlice = makeSafeToCall(String.prototype.slice);
var cloner = function(){};
var create = Object.create || function(prototype, properties) {
cloner.prototype = prototype || null;
var obj = new cloner;
// The properties parameter is unused by this module, but I want this
// shim to be as complete as possible.
if (properties)
for (var name in properties)
if (hasOwn.call(properties, name))
defProp(obj, name, properties[name]);
return obj;
};
var rand = Math.random;
var uniqueKeys = create(null);
function makeUniqueKey() {
// Collisions are highly unlikely, but this module is in the business
// of making guarantees rather than safe bets.
do var uniqueKey = strSlice.call(numToStr.call(rand(), 36), 2);
while (hasOwn.call(uniqueKeys, uniqueKey));
return uniqueKeys[uniqueKey] = uniqueKey;
}
// External users might find this function useful, but it is not necessary
// for the typical use of this module.
defProp(exports, "makeUniqueKey", {
value: makeUniqueKey
});
function makeAccessor() {
var secrets = [];
var brand = makeUniqueKey();
function register(object) {
var key = secrets.length;
defProp(object, brand, { value: key });
secrets[key] = {
object: object,
value: create(null)
};
}
return function(object) {
if (!hasOwn.call(object, brand))
register(object);
var secret = secrets[object[brand]];
if (secret.object === object)
return secret.value;
};
}
defProp(exports, "makeAccessor", {
value: makeAccessor
});
/***/ },
/* 21 */
/***/ function(module, exports, __webpack_require__) {
var assert = __webpack_require__(2);
var types = __webpack_require__(9);
var Type = types.Type;
var namedTypes = types.namedTypes;
var Node = namedTypes.Node;
var isArray = types.builtInTypes.array;
var hasOwn = Object.prototype.hasOwnProperty;
function Scope(path, parentScope) {
assert.ok(this instanceof Scope);
assert.ok(path instanceof __webpack_require__(17));
ScopeType.assert(path.value);
var depth;
if (parentScope) {
assert.ok(parentScope instanceof Scope);
depth = parentScope.depth + 1;
} else {
parentScope = null;
depth = 0;
}
Object.defineProperties(this, {
path: { value: path },
node: { value: path.value },
isGlobal: { value: !parentScope, enumerable: true },
depth: { value: depth },
parent: { value: parentScope },
bindings: { value: {} }
});
}
var scopeTypes = [
// Program nodes introduce global scopes.
namedTypes.Program,
// Function is the supertype of FunctionExpression,
// FunctionDeclaration, ArrowExpression, etc.
namedTypes.Function,
// In case you didn't know, the caught parameter shadows any variable
// of the same name in an outer scope.
namedTypes.CatchClause
];
if (namedTypes.ModuleDeclaration) {
// Include ModuleDeclaration only if it exists (ES6).
scopeTypes.push(namedTypes.ModuleDeclaration);
}
var ScopeType = Type.or.apply(Type, scopeTypes);
Scope.isEstablishedBy = function(node) {
return ScopeType.check(node);
};
var Sp = Scope.prototype;
// Will be overridden after an instance lazily calls scanScope.
Sp.didScan = false;
Sp.declares = function(name) {
this.scan();
return hasOwn.call(this.bindings, name);
};
Sp.scan = function(force) {
if (force || !this.didScan) {
for (var name in this.bindings) {
// Empty out this.bindings, just in cases.
delete this.bindings[name];
}
scanScope(this.path, this.bindings);
this.didScan = true;
}
};
Sp.getBindings = function () {
this.scan();
return this.bindings;
};
function scanScope(path, bindings) {
var node = path.value;
ScopeType.assert(node);
if (namedTypes.CatchClause.check(node)) {
// A catch clause establishes a new scope but the only variable
// bound in that scope is the catch parameter. Any other
// declarations create bindings in the outer scope.
addPattern(path.get("param"), bindings);
} else {
recursiveScanScope(path, bindings);
}
}
function recursiveScanScope(path, bindings) {
var node = path.value;
if (isArray.check(node)) {
path.each(function(childPath) {
recursiveScanChild(childPath, bindings);
});
} else if (namedTypes.Function.check(node)) {
path.get("params").each(function(paramPath) {
addPattern(paramPath, bindings);
});
recursiveScanChild(path.get("body"), bindings);
} else if (namedTypes.VariableDeclarator.check(node)) {
addPattern(path.get("id"), bindings);
recursiveScanChild(path.get("init"), bindings);
} else if (namedTypes.ImportSpecifier &&
namedTypes.ImportSpecifier.check(node)) {
addPattern(node.name ? path.get("name") : path.get("id"));
} else if (Node.check(node)) {
types.eachField(node, function(name, child) {
var childPath = path.get(name);
assert.strictEqual(childPath.value, child);
recursiveScanChild(childPath, bindings);
});
}
}
function recursiveScanChild(path, bindings) {
var node = path.value;
if (namedTypes.FunctionDeclaration.check(node)) {
addPattern(path.get("id"), bindings);
} else if (namedTypes.ClassDeclaration &&
namedTypes.ClassDeclaration.check(node)) {
addPattern(path.get("id"), bindings);
} else if (Scope.isEstablishedBy(node)) {
if (namedTypes.CatchClause.check(node)) {
var catchParamName = node.param.name;
var hadBinding = hasOwn.call(bindings, catchParamName);
// Any declarations that occur inside the catch body that do
// not have the same name as the catch parameter should count
// as bindings in the outer scope.
recursiveScanScope(path.get("body"), bindings);
// If a new binding matching the catch parameter name was
// created while scanning the catch body, ignore it because it
// actually refers to the catch parameter and not the outer
// scope that we're currently scanning.
if (!hadBinding) {
delete bindings[catchParamName];
}
}
} else {
recursiveScanScope(path, bindings);
}
}
function addPattern(patternPath, bindings) {
var pattern = patternPath.value;
namedTypes.Pattern.assert(pattern);
if (namedTypes.Identifier.check(pattern)) {
if (hasOwn.call(bindings, pattern.name)) {
bindings[pattern.name].push(patternPath);
} else {
bindings[pattern.name] = [patternPath];
}
} else if (namedTypes.SpreadElement &&
namedTypes.SpreadElement.check(pattern)) {
addPattern(patternPath.get("argument"), bindings);
}
}
Sp.lookup = function(name) {
for (var scope = this; scope; scope = scope.parent)
if (scope.declares(name))
break;
return scope;
};
Sp.getGlobalScope = function() {
var scope = this;
while (!scope.isGlobal)
scope = scope.parent;
return scope;
};
module.exports = Scope;
/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2013, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* https://raw.github.com/facebook/regenerator/master/LICENSE file. An
* additional grant of patent rights can be found in the PATENTS file in
* the same directory.
*/
var assert = __webpack_require__(2);
var types = __webpack_require__(8);
var n = types.namedTypes;
var b = types.builders;
var hoist = __webpack_require__(23).hoist;
var Emitter = __webpack_require__(25).Emitter;
var DebugInfo = __webpack_require__(52).DebugInfo;
var escope = __webpack_require__(53);
var withLoc = __webpack_require__(24).withLoc;
exports.transform = function(ast, opts) {
n.Program.assert(ast);
var debugInfo = new DebugInfo();
var nodes = ast.body;
var asExpr = opts.asExpr;
var originalExpr = nodes[0];
var boxedVars = (opts.scope || []).reduce(function(acc, v) {
if(v.boxed) {
acc.push(v.name);
}
return acc;
}, []);
var scopes = escope.analyze(ast).scopes;
// Scan the scopes bottom-up by simply reversing the array. We need
// this because we need to detect if an identifier is boxed before
// the scope which it is declared in is scanned.
scopes.reverse();
scopes.forEach(function(scope) {
if(scope.type !== 'global' || asExpr) {
if(asExpr) {
// We need to also scan the variables to catch top-level
// definitions that aren't referenced but might be boxed
// (think function re-definitions)
scope.variables.forEach(function(v) {
if(boxedVars.indexOf(v.name) !== -1) {
v.defs.forEach(function(def) { def.name.boxed = true; });
}
});
}
scope.references.forEach(function(r) {
var defBoxed = r.resolved && r.resolved.defs.reduce(function(acc, def) {
return acc || def.name.boxed || boxedVars.indexOf(def.name) !== -1;
}, false);
// Ignore catch scopes
var from = r.from;
while(from.type == 'catch' && from.upper) {
from = from.upper;
}
if(defBoxed ||
(!r.resolved &&
boxedVars.indexOf(r.identifier.name) !== -1) ||
(r.resolved &&
r.resolved.scope.type !== 'catch' &&
r.resolved.scope !== from &&
// completely ignore references to a named function
// expression, as that binding is immutable (super weird)
!(r.resolved.defs[0].type === 'FunctionName' &&
r.resolved.defs[0].node.type === 'FunctionExpression'))) {
r.identifier.boxed = true;
if(r.resolved) {
r.resolved.defs.forEach(function(def) {
def.name.boxed = true;
});
}
}
});
}
});
if(asExpr) {
// If evaluating as an expression, return the last value if it's
// an expression
var last = nodes.length - 1;
if(n.ExpressionStatement.check(nodes[last])) {
nodes[last] = withLoc(
b.returnStatement(nodes[last].expression),
nodes[last].loc
);
}
}
nodes = b.functionExpression(
b.identifier(asExpr ? '$__eval' : '$__global'),
[],
b.blockStatement(nodes)
);
var rootFn = types.traverse(
nodes,
function(node) {
return visitNode.call(this, node, [], debugInfo);
}
);
if(asExpr) {
rootFn = rootFn.body.body;
if(opts.scope) {
var vars = opts.scope.map(function(v) { return v.name; });
var decl = rootFn[0];
if(n.VariableDeclaration.check(decl)) {
decl.declarations = decl.declarations.reduce(function(acc, v) {
if(vars.indexOf(v.id.name) === -1) {
acc.push(v);
}
return acc;
}, []);
if(!decl.declarations.length) {
rootFn[0] = b.expressionStatement(b.literal(null));
}
}
}
else {
rootFn[0] = b.expressionStatement(b.literal(null));
}
rootFn.unshift(b.expressionStatement(
b.callExpression(
b.memberExpression(
b.identifier('VM'),
b.identifier('pushState'),
false
),
[]
)
));
rootFn.push(b.variableDeclaration(
'var',
[b.variableDeclarator(
b.identifier('$__rval'),
b.callExpression(b.identifier('$__eval'), [])
)]
));
rootFn.push(b.expressionStatement(
b.callExpression(
b.memberExpression(
b.identifier('VM'),
b.identifier('popState'),
false
),
[]
)
));
rootFn.push(b.expressionStatement(b.identifier('$__rval')));
}
else {
rootFn = rootFn.body.body;
}
ast.body = rootFn;
return {
ast: ast,
debugAST: opts.includeDebug ? [debugInfo.getDebugAST()] : [],
debugInfo: debugInfo.getDebugInfo()
};
};
var id = 1;
function newFunctionName() {
return b.identifier('$anon' + id++);
}
function visitNode(node, scope, debugInfo) {
// Boxed variables need to access the box instead of used directly
// (foo => foo[0])
if(n.Identifier.check(node) &&
(!n.VariableDeclarator.check(this.parent.node) ||
this.parent.node.id !== node) &&
node.boxed) {
this.replace(withLoc(b.memberExpression(node, b.literal(0), true),
node.loc));
return;
}
if(!n.Function.check(node)) {
// Note that because we are not returning false here the traversal
// will continue into the subtree rooted at this node, as desired.
return;
}
node.generator = false;
if (node.expression) {
// Transform expression lambdas into normal functions.
node.expression = false;
// This feels very dirty, is it ok to change the type like this?
// We need to output a function that we can name so it can be
// captured.
// TODO: properly compile out arrow functions
node.type = 'FunctionExpression';
node.body = b.blockStatement([
withLoc(b.returnStatement(node.body),
node.body.loc)
]);
}
// All functions are converted with assignments (foo = function
// foo() {}) but with the function name. Rename the function though
// so that if it is referenced inside itself, it will close over the
// "outside" variable (that should be boxed)
node.id = node.id || newFunctionName();
var isGlobal = node.id.name === '$__global';
var isExpr = node.id.name === '$__eval';
var nameId = node.id;
var funcName = node.id.name;
var vars = hoist(node);
var localScope = !vars ? node.params : node.params.concat(
vars.declarations.map(function(v) {
return v.id;
})
);
// It sucks to traverse the whole function again, but we need to see
// if we need to manage a try stack
var hasTry = false;
types.traverse(node.body, function(child) {
if(n.Function.check(child)) {
return false;
}
if(n.TryStatement.check(child)) {
hasTry = true;
}
return;
});
// Traverse and compile child functions first
node.body = types.traverse(node.body, function(child) {
return visitNode.call(this,
child,
scope.concat(localScope),
debugInfo);
});
// Now compile me
var debugId = debugInfo.makeId();
var em = new Emitter(debugId, debugInfo);
var path = new types.NodePath(node);
em.explode(path.get("body"));
var finalBody = em.getMachine(node.id.name, localScope);
// construct the thing
var inner = [];
if(!isGlobal && !isExpr) {
node.params.forEach(function(arg) {
if(arg.boxed) {
inner.push(b.expressionStatement(
b.assignmentExpression(
'=',
arg,
b.arrayExpression([arg])
)
));
}
});
if(vars) {
inner = inner.concat(vars);
}
}
if(!isGlobal && !isExpr) {
inner.push.apply(inner, [
b.ifStatement(
b.unaryExpression('!', em.vmProperty('running')),
b.returnStatement(
b.callExpression(
b.memberExpression(b.identifier('VM'),
b.identifier('execute'),
false),
[node.id, b.literal(null), b.thisExpression(), b.identifier('arguments')]
)
)
)
]);
}
// internal harnesses to run the function
inner.push(em.declareVar('$__next', b.literal(0)));
inner.push(em.declareVar('$__tmpid', b.literal(0)));
for(var i=1, l=em.numTempVars(); i<=l; i++) {
inner.push(em.declareVar('$__t' + i, null));
}
if(hasTry) {
inner.push(em.declareVar('tryStack', b.arrayExpression([])));
}
var tmpSave = [];
for(var i=1, l=em.numTempVars(); i<=l; i++) {
tmpSave.push(b.property(
'init',
b.identifier('$__t' + i),
b.identifier('$__t' + i)
));
}
inner = inner.concat([
b.tryStatement(
b.blockStatement(getRestoration(em, isGlobal, localScope, hasTry)
.concat(finalBody)),
b.catchClause(b.identifier('e'), null, b.blockStatement([
b.ifStatement(
b.unaryExpression(
'!',
b.binaryExpression('instanceof',
b.identifier('e'),
b.identifier('$ContinuationExc'))
),
b.expressionStatement(
b.assignmentExpression(
'=',
b.identifier('e'),
b.newExpression(
b.identifier('$ContinuationExc'),
[b.identifier('e')]
)
)
)
),
b.ifStatement(
b.unaryExpression('!', em.getProperty('e', 'reuse')),
b.expressionStatement(
b.callExpression(em.getProperty('e', 'pushFrame'), [
b.newExpression(
b.identifier('$Frame'),
[b.literal(debugId),
b.literal(funcName.slice(1)),
b.identifier(funcName),
b.identifier('$__next'),
b.objectExpression(
localScope.map(function(id) {
return b.property('init', id, id);
}).concat(tmpSave)
),
// b.literal(null),
b.arrayExpression(localScope.concat(scope).map(function(id) {
return b.objectExpression([
b.property('init', b.literal('name'), b.literal(id.name)),
b.property('init', b.literal('boxed'), b.literal(!!id.boxed))
]);
})),
b.thisExpression(),
hasTry ? b.identifier('tryStack') : b.literal(null),
b.identifier('$__tmpid')]
)
])
)
),
em.assign(em.getProperty('e', 'reuse'), b.literal(false)),
b.throwStatement(b.identifier('e'))
]))
)
]);
if(isGlobal || isExpr) {
node.body = b.blockStatement([
vars ? vars : b.expressionStatement(b.literal(null)),
b.functionDeclaration(
nameId, [],
b.blockStatement(inner)
)
]);
}
else {
node.body = b.blockStatement(inner);
}
return false;
}
function getRestoration(self, isGlobal, localScope, hasTry) {
// restoring a frame
var restoration = [];
restoration.push(
self.declareVar(
'$__frame',
b.callExpression(self.vmProperty('popFrame'), [])
)
);
if(!isGlobal) {
restoration = restoration.concat(localScope.map(function(id) {
return b.expressionStatement(
b.assignmentExpression(
'=',
b.identifier(id.name),
self.getProperty(
self.getProperty(b.identifier('$__frame'), 'state'),
id
)
)
);
}));
}
restoration.push(
self.assign(b.identifier('$__next'),
self.getProperty(b.identifier('$__frame'), 'next'))
);
if(hasTry) {
restoration.push(
self.assign(b.identifier('tryStack'),
self.getProperty(b.identifier('$__frame'), 'tryStack'))
);
}
restoration = restoration.concat([
self.declareVar(
'$__child',
b.callExpression(self.vmProperty('nextFrame'), [])
),
self.assign(b.identifier('$__tmpid'),
self.getProperty(b.identifier('$__frame'), 'tmpid')),
b.ifStatement(
b.identifier('$__child'),
b.blockStatement([
self.assign(
self.getProperty(
self.getProperty(
'$__frame',
b.identifier('state')
),
b.binaryExpression(
'+',
b.literal('$__t'),
self.getProperty('$__frame', 'tmpid')
),
true
),
b.callExpression(
self.getProperty(self.getProperty('$__child', 'fn'), 'call'),
[self.getProperty('$__child', 'thisPtr')]
)
),
// if we are stepping, stop executing here so that it
// pauses on the "return" instruction
b.ifStatement(
self.vmProperty('stepping'),
b.throwStatement(
b.newExpression(b.identifier('$ContinuationExc'),
[b.literal(null),
b.identifier('$__frame')])
)
)
])
)
]);
for(var i=1, l=self.numTempVars(); i<=l; i++) {
restoration.push(b.expressionStatement(
b.assignmentExpression(
'=',
b.identifier('$__t' + i),
self.getProperty(
self.getProperty(b.identifier('$__frame'), 'state'),
'$__t' + i
)
)
));
}
return [
b.ifStatement(
self.vmProperty('doRestore'),
b.blockStatement(restoration),
b.ifStatement(
// if we are stepping, stop executing so it is stopped at
// the first instruction of the new frame
self.vmProperty('stepping'),
b.throwStatement(
b.newExpression(b.identifier('$ContinuationExc'), [])
)
)
)
];
}
/***/ },
/* 23 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2013, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* https://raw.github.com/facebook/regenerator/master/LICENSE file. An
* additional grant of patent rights can be found in the PATENTS file in
* the same directory.
*/
var assert = __webpack_require__(2);
var types = __webpack_require__(8);
var n = types.namedTypes;
var b = types.builders;
var hasOwn = Object.prototype.hasOwnProperty;
var withLoc = __webpack_require__(24).withLoc;
// The hoist function takes a FunctionExpression or FunctionDeclaration
// and replaces any Declaration nodes in its body with assignments, then
// returns a VariableDeclaration containing just the names of the removed
// declarations.
exports.hoist = function(fun) {
n.Function.assert(fun);
var vars = {};
var funDeclsToRaise = [];
function varDeclToExpr(vdec, includeIdentifiers) {
n.VariableDeclaration.assert(vdec);
var exprs = [];
vdec.declarations.forEach(function(dec) {
vars[dec.id.name] = dec.id;
if (dec.init) {
var assn = b.assignmentExpression('=', dec.id, dec.init);
exprs.push(withLoc(assn, dec.loc));
} else if (includeIdentifiers) {
exprs.push(dec.id);
}
});
if (exprs.length === 0)
return null;
if (exprs.length === 1)
return exprs[0];
return b.sequenceExpression(exprs);
}
types.traverse(fun.body, function(node) {
if (n.VariableDeclaration.check(node)) {
var expr = varDeclToExpr(node, false);
if (expr === null) {
this.replace();
} else {
// We don't need to traverse this expression any further because
// there can't be any new declarations inside an expression.
this.replace(withLoc(b.expressionStatement(expr), node.loc));
}
// Since the original node has been either removed or replaced,
// avoid traversing it any further.
return false;
} else if (n.ForStatement.check(node)) {
if (n.VariableDeclaration.check(node.init)) {
var expr = varDeclToExpr(node.init, false);
this.get("init").replace(expr);
}
} else if (n.ForInStatement.check(node)) {
if (n.VariableDeclaration.check(node.left)) {
var expr = varDeclToExpr(node.left, true);
this.get("left").replace(expr);
}
} else if (n.FunctionDeclaration.check(node)) {
vars[node.id.name] = node.id;
var parentNode = this.parent.node;
// Prefix the name with '$' as it introduces a new scoping rule
// and we want the original id to be referenced within the body
var funcExpr = b.functionExpression(
b.identifier('$' + node.id.name),
node.params,
node.body,
node.generator,
node.expression
);
funcExpr.loc = node.loc;
var assignment = withLoc(b.expressionStatement(
withLoc(b.assignmentExpression(
"=",
node.id,
funcExpr
), node.loc)
), node.loc);
if (n.BlockStatement.check(this.parent.node)) {
// unshift because later it will be added in reverse, so this
// will keep the original order
funDeclsToRaise.unshift({
block: this.parent.node,
assignment: assignment
});
// Remove the function declaration for now, but reinsert the assignment
// form later, at the top of the enclosing BlockStatement.
this.replace();
} else {
this.replace(assignment);
}
// Don't hoist variables out of inner functions.
return false;
} else if (n.FunctionExpression.check(node)) {
// Don't descend into nested function expressions.
return false;
}
});
funDeclsToRaise.forEach(function(entry) {
entry.block.body.unshift(entry.assignment);
});
var declarations = [];
var paramNames = {};
fun.params.forEach(function(param) {
if (n.Identifier.check(param)) {
paramNames[param.name] = param;
}
else {
// Variables declared by destructuring parameter patterns will be
// harmlessly re-declared.
}
});
Object.keys(vars).forEach(function(name) {
if(!hasOwn.call(paramNames, name)) {
var id = vars[name];
declarations.push(b.variableDeclarator(
id, id.boxed ? b.arrayExpression([b.identifier('undefined')]) : null
));
}
});
if (declarations.length === 0) {
return null; // Be sure to handle this case!
}
return b.variableDeclaration("var", declarations);
};
/***/ },
/* 24 */
/***/ function(module, exports) {
/**
* Copyright (c) 2013, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* https://raw.github.com/facebook/regenerator/master/LICENSE file. An
* additional grant of patent rights can be found in the PATENTS file in
* the same directory.
*/
var hasOwn = Object.prototype.hasOwnProperty;
exports.guessTabWidth = function(source) {
var counts = []; // Sparse array.
var lastIndent = 0;
source.split("\n").forEach(function(line) {
var indent = /^\s*/.exec(line)[0].length;
var diff = Math.abs(indent - lastIndent);
counts[diff] = ~~counts[diff] + 1;
lastIndent = indent;
});
var maxCount = -1;
var result = 2;
for (var tabWidth = 1;
tabWidth < counts.length;
tabWidth += 1) {
if (tabWidth in counts &&
counts[tabWidth] > maxCount) {
maxCount = counts[tabWidth];
result = tabWidth;
}
}
return result;
};
exports.defaults = function(obj) {
var len = arguments.length;
var extension;
for (var i = 1; i < len; ++i) {
if ((extension = arguments[i])) {
for (var key in extension) {
if (hasOwn.call(extension, key) && !hasOwn.call(obj, key)) {
obj[key] = extension[key];
}
}
}
}
return obj;
};
// tag nodes with source code locations
exports.withLoc = function(node, loc) {
node.loc = loc;
return node;
};
/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {
/**
* Copyright (c) 2013, Facebook, Inc.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* https://raw.github.com/facebook/regenerator/master/LICENSE file. An
* additional grant of patent rights can be found in the PATENTS file in
* the same directory.
*/
"use strict";
var assert = __webpack_require__(2);
var types = __webpack_require__(8);
var recast = __webpack_require__(26);
var isArray = types.builtInTypes.array;
var b = types.builders;
var n = types.namedTypes;
var leap = __webpack_require__(50);
var meta = __webpack_require__(51);
var hasOwn = Object.prototype.hasOwnProperty;
var withLoc = __webpack_require__(24).withLoc;
function makeASTGenerator(code) {
return function() {
// TODO: optimize it so it doesn't always have to parse it
var ast = b.blockStatement(recast.parse(code).program.body);
var args = arguments;
return types.traverse(ast, function(node) {
if(n.Identifier.check(node) &&
node.name[0] === '$') {
var idx = parseInt(node.name.slice(1));
return this.replace(args[idx - 1]);
}
});
}
}
var makeSetBreakpointAST = makeASTGenerator('VM.hasBreakpoints = true;\nVM.machineBreaks[$1][$2] = true;');
function Emitter(debugId, debugInfo) {
assert.ok(this instanceof Emitter);
this.tmpId = 0;
this.maxTmpId = 0;
Object.defineProperties(this, {
// An append-only list of Statements that grows each time this.emit is
// called.
listing: { value: [] },
// A sparse array whose keys correspond to locations in this.listing
// that have been marked as branch/jump targets.
marked: { value: [true] },
// Every location has a source location mapping
sourceLocations: { value: [true] },
// The last location will be marked when this.getDispatchLoop is
// called.
finalLoc: { value: loc() },
debugId: { value: debugId },
debugInfo: { value: debugInfo }
});
// The .leapManager property needs to be defined by a separate
// defineProperties call so that .finalLoc will be visible to the
// leap.LeapManager constructor.
Object.defineProperties(this, {
// Each time we evaluate the body of a loop, we tell this.leapManager
// to enter a nested loop context that determines the meaning of break
// and continue statements therein.
leapManager: { value: new leap.LeapManager(this) }
});
}
var Ep = Emitter.prototype;
exports.Emitter = Emitter;
// Offsets into this.listing that could be used as targets for branches or
// jumps are represented as numeric Literal nodes. This representation has
// the amazingly convenient benefit of allowing the exact value of the
// location to be determined at any time, even after generating code that
// refers to the location.
function loc() {
var lit = b.literal(-1);
// A little hacky, but mark is as a location object so we can do
// some quick checking later (see resolveEmptyJumps)
lit._location = true;
return lit;
}
// Sets the exact value of the given location to the offset of the next
// Statement emitted.
Ep.mark = function(loc) {
n.Literal.assert(loc);
var index = this.listing.length;
loc.value = index;
this.marked[index] = true;
return loc;
};
Ep.getLastMark = function() {
var index = this.listing.length;
while(index > 0 && !this.marked[index]) {
index--;
}
return index;
};
Ep.markAndBreak = function() {
var next = loc();
this.emitAssign(b.identifier('$__next'), next);
this.emit(b.breakStatement(null), true);
this.mark(next);
};
Ep.emit = function(node, internal) {
if (n.Expression.check(node)) {
node = withLoc(b.expressionStatement(node), node.loc);
}
n.Statement.assert(node);
this.listing.push(node);
if(!internal) {
if(!node.loc) {
throw new Error("source location missing: " + JSON.stringify(node));
}
else {
this.debugInfo.addSourceLocation(this.debugId,
node.loc,
this.listing.length - 1);
}
}
};
// Shorthand for emitting assignment statements. This will come in handy
// for assignments to temporary variables.
Ep.emitAssign = function(lhs, rhs, loc) {
this.emit(this.assign(lhs, rhs, loc), !loc);
return lhs;
};
// Shorthand for an assignment statement.
Ep.assign = function(lhs, rhs, loc) {
var node = b.expressionStatement(
b.assignmentExpression("=", lhs, rhs));
node.loc = loc;
return node;
};
Ep.declareVar = function(name, init, loc) {
return withLoc(b.variableDeclaration(
'var',
[b.variableDeclarator(b.identifier(name), init)]
), loc);
};
Ep.getProperty = function(obj, prop, computed, loc) {
return withLoc(b.memberExpression(
typeof obj === 'string' ? b.identifier(obj) : obj,
typeof prop === 'string' ? b.identifier(prop) : prop,
!!computed
), loc);
};
Ep.vmProperty = function(name, loc) {
var node = b.memberExpression(
b.identifier('VM'),
b.identifier(name),
false
);
node.loc = loc;
return node;
};
Ep.clearPendingException = function(assignee, loc) {
var cp = this.vmProperty("error");
if(assignee) {
this.emitAssign(assignee, cp, loc);
}
this.emitAssign(cp, b.literal(null));
};
// Emits code for an unconditional jump to the given location, even if the
// exact value of the location is not yet known.
Ep.jump = function(toLoc) {
this.emitAssign(b.identifier('$__next'), toLoc);
this.emit(b.breakStatement(), true);
};
// Conditional jump.
Ep.jumpIf = function(test, toLoc, srcLoc) {
n.Expression.assert(test);
n.Literal.assert(toLoc);
this.emit(withLoc(b.ifStatement(
test,
b.blockStatement([
this.assign(b.identifier('$__next'), toLoc),
b.breakStatement()
])
), srcLoc));
};
// Conditional jump, with the condition negated.
Ep.jumpIfNot = function(test, toLoc, srcLoc) {
n.Expression.assert(test);
n.Literal.assert(toLoc);
this.emit(withLoc(b.ifStatement(
b.unaryExpression("!", test),
b.blockStatement([
this.assign(b.identifier('$__next'), toLoc),
b.breakStatement()
])
), srcLoc));
};
// Make temporary ids. They should be released when not needed anymore
// so that we can generate as few of them as possible.
Ep.getTempVar = function() {
this.tmpId++;
if(this.tmpId > this.maxTmpId) {
this.maxTmpId = this.tmpId;
}
return b.identifier("$__t" + this.tmpId);
};
Ep.currentTempId = function() {
return this.tmpId;
};
Ep.releaseTempVar = function() {
this.tmpId--;
};
Ep.numTempVars = function() {
return this.maxTmpId;
};
Ep.withTempVars = function(cb) {
var prevId = this.tmpId;
var res = cb();
this.tmpId = prevId;
return res;
};
Ep.getMachine = function(funcName, varNames) {
return this.getDispatchLoop(funcName, varNames);
};
Ep.resolveEmptyJumps = function() {
var self = this;
var forwards = {};
// TODO: this is actually broken now since we removed the $ctx
// variable
self.listing.forEach(function(stmt, i) {
if(self.marked.hasOwnProperty(i) &&
self.marked.hasOwnProperty(i + 2) &&
(n.ReturnStatement.check(self.listing[i + 1]) ||
n.BreakStatement.check(self.listing[i + 1])) &&
n.ExpressionStatement.check(stmt) &&
n.AssignmentExpression.check(stmt.expression) &&
n.MemberExpression.check(stmt.expression.left) &&
stmt.expression.left.object.name == '$ctx' &&
stmt.expression.left.property.name == '$__next') {
forwards[i] = stmt.expression.right;
// TODO: actually remove these cases from the output
}
});
types.traverse(self.listing, function(node) {
if(n.Literal.check(node) &&
node._location &&
forwards.hasOwnProperty(node.value)) {
this.replace(forwards[node.value]);
}
});
};
// Turns this.listing into a loop of the form
//
// while (1) switch (context.next) {
// case 0:
// ...
// case n:
// return context.stop();
// }
//
// Each marked location in this.listing will correspond to one generated
// case statement.
Ep.getDispatchLoop = function(funcName, varNames) {
var self = this;
// If we encounter a break, continue, or return statement in a switch
// case, we can skip the rest of the statements until the next case.
var alreadyEnded = false, current, cases = [];
// If a case statement will just forward to another location, make
// the original loc jump straight to it
self.resolveEmptyJumps();
self.listing.forEach(function(stmt, i) {
if (self.marked.hasOwnProperty(i)) {
cases.push(b.switchCase(
b.literal(i),
current = []));
alreadyEnded = false;
}
if (!alreadyEnded) {
current.push(stmt);
if (isSwitchCaseEnder(stmt))
alreadyEnded = true;
}
});
// Now that we know how many statements there will be in this.listing,
// we can finally resolve this.finalLoc.value.
this.finalLoc.value = this.listing.length;
this.debugInfo.addFinalLocation(this.debugId, this.finalLoc.value);
this.debugInfo.addStepIds(this.debugId, this.marked.reduce((acc, val, i) => {
if(val) {
acc.push(i);
}
return acc;
}, []));;
cases.push.apply(cases, [
b.switchCase(null, []),
b.switchCase(this.finalLoc, [
b.returnStatement(null)
])
]);
// add an "eval" location
cases.push(
b.switchCase(b.literal(-1), [
self.assign(
self.vmProperty('evalResult'),
b.callExpression(
b.identifier('eval'),
[self.vmProperty('evalArg')]
)
),
b.throwStatement(
b.newExpression(b.identifier('$ContinuationExc'), [])
)
])
);
return [
// the state machine
b.whileStatement(
b.literal(1),
b.blockStatement([
b.ifStatement(
b.logicalExpression(
'&&',
self.vmProperty('hasBreakpoints'),
b.binaryExpression(
'!==',
self.getProperty(
self.getProperty(self.vmProperty('machineBreaks'),
b.literal(this.debugId),
true),
b.identifier('$__next'),
true
),
// is identifier right here? it doesn't seem right
b.identifier('undefined')
)
),
b.throwStatement(
b.newExpression(b.identifier('$ContinuationExc'), [])
)
),
b.switchStatement(b.identifier('$__next'), cases),
b.ifStatement(
self.vmProperty('stepping'),
b.throwStatement(
b.newExpression(b.identifier('$ContinuationExc'), [])
)
)
])
)
];
};
// See comment above re: alreadyEnded.
function isSwitchCaseEnder(stmt) {
return n.BreakStatement.check(stmt)
|| n.ContinueStatement.check(stmt)
|| n.ReturnStatement.check(stmt)
|| n.ThrowStatement.check(stmt);
}
// an "atomic" expression is one that should execute within one step
// of the VM
function isAtomic(expr) {
return n.Literal.check(expr) ||
n.Identifier.check(expr) ||
n.ThisExpression.check(expr) ||
(n.MemberExpression.check(expr) &&
!expr.computed);
}
// No destructive modification of AST nodes.
Ep.explode = function(path, ignoreResult) {
assert.ok(path instanceof types.NodePath);
var node = path.value;
var self = this;
n.Node.assert(node);
if (n.Statement.check(node))
return self.explodeStatement(path);
if (n.Expression.check(node))
return self.explodeExpression(path, ignoreResult);
if (n.Declaration.check(node))
throw getDeclError(node);
switch (node.type) {
case "Program":
return path.get("body").map(
self.explodeStatement,
self
);
case "VariableDeclarator":
throw getDeclError(node);
// These node types should be handled by their parent nodes
// (ObjectExpression, SwitchStatement, and TryStatement, respectively).
case "Property":
case "SwitchCase":
case "CatchClause":
throw new Error(
node.type + " nodes should be handled by their parents");
default:
throw new Error(
"unknown Node of type " +
JSON.stringify(node.type));
}
};
function getDeclError(node) {
return new Error(
"all declarations should have been transformed into " +
"assignments before the Exploder began its work: " +
JSON.stringify(node));
}
Ep.explodeStatement = function(path, labelId) {
assert.ok(path instanceof types.NodePath);
var stmt = path.value;
var self = this;
n.Statement.assert(stmt);
if (labelId) {
n.Identifier.assert(labelId);
} else {
labelId = null;
}
// Explode BlockStatement nodes even if they do not contain a yield,
// because we don't want or need the curly braces.
if (n.BlockStatement.check(stmt)) {
return path.get("body").each(
self.explodeStatement,
self
);
}
// if (!meta.containsLeap(stmt)) {
// // Technically we should be able to avoid emitting the statement
// // altogether if !meta.hasSideEffects(stmt), but that leads to
// // confusing generated code (for instance, `while (true) {}` just
// // disappears) and is probably a more appropriate job for a dedicated
// // dead code elimination pass.
// self.emit(stmt);
// return;
// }
switch (stmt.type) {
case "ExpressionStatement":
self.explodeExpression(path.get("expression"), true);
break;
case "LabeledStatement":
self.explodeStatement(path.get("body"), stmt.label);
break;
case "WhileStatement":
var before = loc();
var after = loc();
self.mark(before);
self.jumpIfNot(self.explodeExpression(path.get("test")),
after,
path.get("test").node.loc);
self.markAndBreak();
self.leapManager.withEntry(
new leap.LoopEntry(after, before, labelId),
function() { self.explodeStatement(path.get("body")); }
);
self.jump(before);
self.mark(after);
break;
case "DoWhileStatement":
var first = loc();
var test = loc();
var after = loc();
self.mark(first);
self.leapManager.withEntry(
new leap.LoopEntry(after, test, labelId),
function() { self.explode(path.get("body")); }
);
self.mark(test);
self.jumpIf(self.explodeExpression(path.get("test")),
first,
path.get("test").node.loc);
self.emitAssign(b.identifier('$__next'), after);
self.emit(b.breakStatement(), true);
self.mark(after);
break;
case "ForStatement":
var head = loc();
var update = loc();
var after = loc();
if (stmt.init) {
// We pass true here to indicate that if stmt.init is an expression
// then we do not care about its result.
self.explode(path.get("init"), true);
}
self.mark(head);
if (stmt.test) {
self.jumpIfNot(self.explodeExpression(path.get("test")),
after,
path.get("test").node.loc);
} else {
// No test means continue unconditionally.
}
this.markAndBreak();
self.leapManager.withEntry(
new leap.LoopEntry(after, update, labelId),
function() { self.explodeStatement(path.get("body")); }
);
self.mark(update);
if (stmt.update) {
// We pass true here to indicate that if stmt.update is an
// expression then we do not care about its result.
self.explode(path.get("update"), true);
}
self.jump(head);
self.mark(after);
break;
case "ForInStatement":
n.Identifier.assert(stmt.left);
var head = loc();
var after = loc();
var keys = self.emitAssign(
self.getTempVar(),
b.callExpression(
self.vmProperty("keys"),
[self.explodeExpression(path.get("right"))]
),
path.get("right").node.loc
);
var tmpLoc = loc();
self.mark(tmpLoc);
self.mark(head);
self.jumpIfNot(
b.memberExpression(
keys,
b.identifier("length"),
false
),
after,
stmt.right.loc
);
self.emitAssign(
stmt.left,
b.callExpression(
b.memberExpression(
keys,
b.identifier("pop"),
false
),
[]
),
stmt.left.loc
);
self.markAndBreak();
self.leapManager.withEntry(
new leap.LoopEntry(after, head, labelId),
function() { self.explodeStatement(path.get("body")); }
);
self.jump(head);
self.mark(after);
self.releaseTempVar();
break;
case "BreakStatement":
self.leapManager.emitBreak(stmt.label);
break;
case "ContinueStatement":
self.leapManager.emitContinue(stmt.label);
break;
case "SwitchStatement":
// Always save the discriminant into a temporary variable in case the
// test expressions overwrite values like context.sent.
var disc = self.emitAssign(
self.getTempVar(),
self.explodeExpression(path.get("discriminant"))
);
var after = loc();
var defaultLoc = loc();
var condition = defaultLoc;
var caseLocs = [];
// If there are no cases, .cases might be undefined.
var cases = stmt.cases || [];
for (var i = cases.length - 1; i >= 0; --i) {
var c = cases[i];
n.SwitchCase.assert(c);
if (c.test) {
condition = b.conditionalExpression(
b.binaryExpression("===", disc, c.test),
caseLocs[i] = loc(),
condition
);
} else {
caseLocs[i] = defaultLoc;
}
}
self.jump(self.explodeExpression(
new types.NodePath(condition, path, "discriminant")
));
self.leapManager.withEntry(
new leap.SwitchEntry(after),
function() {
path.get("cases").each(function(casePath) {
var c = casePath.value;
var i = casePath.name;
self.mark(caseLocs[i]);
casePath.get("consequent").each(
self.explodeStatement,
self
);
});
}
);
self.releaseTempVar();
self.mark(after);
if (defaultLoc.value === -1) {
self.mark(defaultLoc);
assert.strictEqual(after.value, defaultLoc.value);
}
break;
case "IfStatement":
var elseLoc = stmt.alternate && loc();
var after = loc();
self.jumpIfNot(
self.explodeExpression(path.get("test")),
elseLoc || after,
path.get("test").node.loc
);
self.markAndBreak();
self.explodeStatement(path.get("consequent"));
if (elseLoc) {
self.jump(after);
self.mark(elseLoc);
self.explodeStatement(path.get("alternate"));
}
self.mark(after);
break;
case "ReturnStatement":
var arg = path.get('argument');
var tmp = self.getTempVar();
var after = loc();
self.emitAssign(b.identifier('$__next'), after, arg.node.loc);
self.emitAssign(
tmp,
this.explodeExpression(arg)
);
// TODO: breaking here allowing stepping to stop on return.
// Not sure if that's desirable or not.
// self.emit(b.breakStatement(), true);
self.mark(after);
self.releaseTempVar();
self.emit(withLoc(b.returnStatement(tmp), path.node.loc));
break;
case "WithStatement":
throw new Error(
node.type + " not supported in generator functions.");
case "TryStatement":
var after = loc();
var handler = stmt.handler;
if (!handler && stmt.handlers) {
handler = stmt.handlers[0] || null;
}
var catchLoc = handler && loc();
var catchEntry = catchLoc && new leap.CatchEntry(
catchLoc,
handler.param
);
var finallyLoc = stmt.finalizer && loc();
var finallyEntry = finallyLoc && new leap.FinallyEntry(
finallyLoc,
self.getTempVar()
);
if (finallyEntry) {
// Finally blocks examine their .nextLocTempVar property to figure
// out where to jump next, so we must set that property to the
// fall-through location, by default.
self.emitAssign(finallyEntry.nextLocTempVar, after, path.node.loc);
}
var tryEntry = new leap.TryEntry(catchEntry, finallyEntry);
// Push information about this try statement so that the runtime can
// figure out what to do if it gets an uncaught exception.
self.pushTry(tryEntry, path.node.loc);
self.markAndBreak();
self.leapManager.withEntry(tryEntry, function() {
self.explodeStatement(path.get("block"));
if (catchLoc) {
// If execution leaves the try block normally, the associated
// catch block no longer applies.
self.popCatch(catchEntry, handler.loc);
if (finallyLoc) {
// If we have both a catch block and a finally block, then
// because we emit the catch block first, we need to jump over
// it to the finally block.
self.jump(finallyLoc);
} else {
// If there is no finally block, then we need to jump over the
// catch block to the fall-through location.
self.jump(after);
}
self.mark(catchLoc);
// On entering a catch block, we must not have exited the
// associated try block normally, so we won't have called
// context.popCatch yet. Call it here instead.
self.popCatch(catchEntry, handler.loc);
// self.markAndBreak();
var bodyPath = path.get("handler", "body");
var safeParam = self.getTempVar();
self.clearPendingException(safeParam, handler.loc);
self.markAndBreak();
var catchScope = bodyPath.scope;
var catchParamName = handler.param.name;
n.CatchClause.assert(catchScope.node);
assert.strictEqual(catchScope.lookup(catchParamName), catchScope);
types.traverse(bodyPath, function(node) {
if (n.Identifier.check(node) &&
node.name === catchParamName &&
this.scope.lookup(catchParamName) === catchScope) {
this.replace(safeParam);
return false;
}
});
self.leapManager.withEntry(catchEntry, function() {
self.explodeStatement(bodyPath);
});
self.releaseTempVar();
}
if (finallyLoc) {
self.mark(finallyLoc);
self.popFinally(finallyEntry, stmt.finalizer.loc);
self.markAndBreak();
self.leapManager.withEntry(finallyEntry, function() {
self.explodeStatement(path.get("finalizer"));
});
self.jump(finallyEntry.nextLocTempVar);
self.releaseTempVar();
}
});
self.mark(after);
break;
case "ThrowStatement":
self.emit(withLoc(b.throwStatement(
self.explodeExpression(path.get("argument"))
), path.node.loc));
break;
case "DebuggerStatement":
var after = loc();
self.emit(makeSetBreakpointAST(b.literal(this.debugId), after), true);
self.emitAssign(b.identifier('$__next'), after);
self.emit(b.breakStatement(), true);
self.mark(after);
after = loc();
self.emitAssign(b.identifier('$__next'), after, path.node.loc);
self.emit(b.breakStatement(), true);
self.mark(after);
break;
default:
throw new Error(
"unknown Statement of type " +
JSON.stringify(stmt.type));
}
};
// Emit a runtime call to context.pushTry(catchLoc, finallyLoc) so that
// the runtime wrapper can dispatch uncaught exceptions appropriately.
Ep.pushTry = function(tryEntry, loc) {
assert.ok(tryEntry instanceof leap.TryEntry);
var nil = b.literal(null);
var catchEntry = tryEntry.catchEntry;
var finallyEntry = tryEntry.finallyEntry;
var method = this.vmProperty("pushTry");
var args = [
b.identifier('tryStack'),
catchEntry && catchEntry.firstLoc || nil,
finallyEntry && finallyEntry.firstLoc || nil,
finallyEntry && b.literal(
parseInt(finallyEntry.nextLocTempVar.name.replace('$__t', ''))
) || nil
];
this.emit(withLoc(b.callExpression(method, args), loc));
};
// Emit a runtime call to context.popCatch(catchLoc) so that the runtime
// wrapper knows when a catch block reported to pushTry no longer applies.
Ep.popCatch = function(catchEntry, loc) {
var catchLoc;
if (catchEntry) {
assert.ok(catchEntry instanceof leap.CatchEntry);
catchLoc = catchEntry.firstLoc;
} else {
assert.strictEqual(catchEntry, null);
catchLoc = b.literal(null);
}
// TODO Think about not emitting anything when catchEntry === null. For
// now, emitting context.popCatch(null) is good for sanity checking.
this.emit(withLoc(b.callExpression(
this.vmProperty("popCatch"),
[b.identifier('tryStack'), catchLoc]
), loc));
};
// Emit a runtime call to context.popFinally(finallyLoc) so that the
// runtime wrapper knows when a finally block reported to pushTry no
// longer applies.
Ep.popFinally = function(finallyEntry, loc) {
var finallyLoc;
if (finallyEntry) {
assert.ok(finallyEntry instanceof leap.FinallyEntry);
finallyLoc = finallyEntry.firstLoc;
} else {
assert.strictEqual(finallyEntry, null);
finallyLoc = b.literal(null);
}
// TODO Think about not emitting anything when finallyEntry === null.
// For now, emitting context.popFinally(null) is good for sanity
// checking.
this.emit(withLoc(b.callExpression(
this.vmProperty("popFinally"),
[b.identifier('tryStack'), finallyLoc]
), loc));
};
Ep.explodeExpression = function(path, ignoreResult) {
assert.ok(path instanceof types.NodePath);
var expr = path.value;
if (expr) {
n.Expression.assert(expr);
} else {
return expr;
}
var self = this;
var result; // Used optionally by several cases below.
function finish(expr) {
n.Expression.assert(expr);
if (ignoreResult) {
var after = loc();
self.emit(expr);
self.emitAssign(b.identifier('$__next'), after);
self.emit(b.breakStatement(), true);
self.mark(after);
} else {
return expr;
}
}
// If the expression does not contain a leap, then we either emit the
// expression as a standalone statement or return it whole.
// if (!meta.containsLeap(expr)) {
// return finish(expr);
// }
// If any child contains a leap (such as a yield or labeled continue or
// break statement), then any sibling subexpressions will almost
// certainly have to be exploded in order to maintain the order of their
// side effects relative to the leaping child(ren).
var hasLeapingChildren = meta.containsLeap.onlyChildren(expr);
// In order to save the rest of explodeExpression from a combinatorial
// trainwreck of special cases, explodeViaTempVar is responsible for
// deciding when a subexpression needs to be "exploded," which is my
// very technical term for emitting the subexpression as an assignment
// to a temporary variable and the substituting the temporary variable
// for the original subexpression. Think of exploded view diagrams, not
// Michael Bay movies. The point of exploding subexpressions is to
// control the precise order in which the generated code realizes the
// side effects of those subexpressions.
function explodeViaTempVar(tempVar, childPath, ignoreChildResult, keepTempVar) {
assert.ok(childPath instanceof types.NodePath);
assert.ok(
!ignoreChildResult || !tempVar,
"Ignoring the result of a child expression but forcing it to " +
"be assigned to a temporary variable?"
);
if(isAtomic(childPath.node)) {
// we still explode it because only the top-level expression is
// atomic, sub-expressions may not be
return self.explodeExpression(childPath, ignoreChildResult);
}
else if (!ignoreChildResult) {
var shouldRelease = !tempVar && !keepTempVar;
tempVar = tempVar || self.getTempVar();
var result = self.explodeExpression(childPath, ignoreChildResult);
// always mark!
result = self.emitAssign(
tempVar,
result,
childPath.node.loc
);
self.markAndBreak();
if(shouldRelease) {
self.releaseTempVar();
}
}
return result;
}
// If ignoreResult is true, then we must take full responsibility for
// emitting the expression with all its side effects, and we should not
// return a result.
switch (expr.type) {
case "MemberExpression":
return finish(withLoc(b.memberExpression(
self.explodeExpression(path.get("object")),
expr.computed
? explodeViaTempVar(null, path.get("property"), false, true)
: expr.property,
expr.computed
), path.node.loc));
case "CallExpression":
var oldCalleePath = path.get("callee");
var callArgs = path.get("arguments");
if(oldCalleePath.node.type === "Identifier" &&
oldCalleePath.node.name === "callCC") {
callArgs = [new types.NodePath(
withLoc(b.callExpression(
b.memberExpression(b.identifier("VM"),
b.identifier("callCC"),
false),
[]
), oldCalleePath.node.loc)
)];
oldCalleePath = path.get("arguments").get(0);
}
var newCallee = self.explodeExpression(oldCalleePath);
var r = self.withTempVars(function() {
var after = loc();
var args = callArgs.map(function(argPath) {
return explodeViaTempVar(null, argPath, false, true);
});
var tmp = self.getTempVar();
var callee = newCallee;
self.emitAssign(b.identifier('$__next'), after, path.node.loc);
self.emitAssign(b.identifier('$__tmpid'), b.literal(self.currentTempId()));
self.emitAssign(tmp, b.callExpression(callee, args));
self.emit(b.breakStatement(), true);
self.mark(after);
return tmp;
});
return r;
case "NewExpression":
// TODO: this should be the last major expression type I need to
// fix up to be able to trace/step through. can't call native new
return self.withTempVars(function() {
return finish(b.newExpression(
explodeViaTempVar(null, path.get("callee"), false, true),
path.get("arguments").map(function(argPath) {
return explodeViaTempVar(null, argPath, false, true);
})
));
});
case "ObjectExpression":
return self.withTempVars(function() {
return finish(b.objectExpression(
path.get("properties").map(function(propPath) {
return b.property(
propPath.value.kind,
propPath.value.key,
explodeViaTempVar(null, propPath.get("value"), false, true)
);
})
));
});
case "ArrayExpression":
return self.withTempVars(function() {
return finish(b.arrayExpression(
path.get("elements").map(function(elemPath) {
return explodeViaTempVar(null, elemPath, false, true);
})
));
});
case "SequenceExpression":
var lastIndex = expr.expressions.length - 1;
path.get("expressions").each(function(exprPath) {
if (exprPath.name === lastIndex) {
result = self.explodeExpression(exprPath, ignoreResult);
} else {
self.explodeExpression(exprPath, true);
}
});
return result;
case "LogicalExpression":
var after = loc();
self.withTempVars(function() {
if (!ignoreResult) {
result = self.getTempVar();
}
var left = explodeViaTempVar(result, path.get("left"), false, true);
if (expr.operator === "&&") {
self.jumpIfNot(left, after, path.get("left").node.loc);
} else if (expr.operator === "||") {
self.jumpIf(left, after, path.get("left").node.loc);
}
explodeViaTempVar(result, path.get("right"), ignoreResult, true);
self.mark(after);
});
return result;
case "ConditionalExpression":
var elseLoc = loc();
var after = loc();
var test = self.explodeExpression(path.get("test"));
self.jumpIfNot(test, elseLoc, path.get("test").node.loc);
if (!ignoreResult) {
result = self.getTempVar();
}
explodeViaTempVar(result, path.get("consequent"), ignoreResult);
self.jump(after);
self.mark(elseLoc);
explodeViaTempVar(result, path.get("alternate"), ignoreResult);
self.mark(after);
if(!ignoreResult) {
self.releaseTempVar();
}
return result;
case "UnaryExpression":
return finish(withLoc(b.unaryExpression(
expr.operator,
// Can't (and don't need to) break up the syntax of the argument.
// Think about delete a[b].
self.explodeExpression(path.get("argument")),
!!expr.prefix
), path.node.loc));
case "BinaryExpression":
return self.withTempVars(function() {
return finish(withLoc(b.binaryExpression(
expr.operator,
explodeViaTempVar(null, path.get("left"), false, true),
explodeViaTempVar(null, path.get("right"), false, true)
), path.node.loc));
});
case "AssignmentExpression":
return finish(withLoc(b.assignmentExpression(
expr.operator,
self.explodeExpression(path.get("left")),
self.explodeExpression(path.get("right"))
), path.node.loc));
case "UpdateExpression":
return finish(withLoc(b.updateExpression(
expr.operator,
self.explodeExpression(path.get("argument")),
expr.prefix
), path.node.loc));
// case "YieldExpression":
// var after = loc();
// var arg = expr.argument && self.explodeExpression(path.get("argument"));
// if (arg && expr.delegate) {
// var result = self.getTempVar();
// self.emit(b.returnStatement(b.callExpression(
// self.contextProperty("delegateYield"), [
// arg,
// b.literal(result.property.name),
// after
// ]
// )));
// self.mark(after);
// return result;
// }
// self.emitAssign(b.identifier('$__next'), after);
// self.emit(b.returnStatement(arg || null));
// self.mark(after);
// return self.contextProperty("sent");
case "Identifier":
case "FunctionExpression":
case "ArrowFunctionExpression":
case "ThisExpression":
case "Literal":
return finish(expr);
break;
default:
throw new Error(
"unknown Expression of type " +
JSON.stringify(expr.type));
}
};
/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {
/* WEBPACK VAR INJECTION */(function(process) {var types = __webpack_require__(27);
var parse = __webpack_require__(28).parse;
var Printer = __webpack_require__(48).Printer;
function print(node, options) {
return new Printer(options).print(node);
}
function prettyPrint(node, options) {
return new Printer(options).printGenerically(node);
}
function run(transformer, options) {
return runFile(process.argv[2], transformer, options);
}
function runFile(path, transformer, options) {
__webpack_require__(49).readFile(path, "utf-8", function(err, code) {
if (err) {
console.error(err);
return;
}
runString(code, transformer, options);
});
}
function defaultWriteback(output) {
process.stdout.write(output);
}
function runString(code, transformer, options) {
var writeback = options && options.writeback || defaultWriteback;
transformer(parse(code, options), function(node) {
writeback(print(node, options).code);
});
}
Object.defineProperties(exports, {
/**
* Parse a string of code into an augmented syntax tree suitable for
* arbitrary modification and reprinting.
*/
parse: {
enumerable: true,
value: parse
},
/**
* Reprint a modified syntax tree using as much of the original source
* code as possible.
*/
print: {
enumerable: true,
value: print
},
/**
* Print without attempting to reuse any original source code.
*/
prettyPrint: {
enumerable: true,
value: prettyPrint
},
/**
* Customized version of require("ast-types").
*/
types: {
enumerable: true,
value: types
},
/**
* Convenient command-line interface (see e.g. example/add-braces).
*/
run: {
enumerable: true,
value: run
},
/**
* Useful utilities for implementing transformer functions.
*/
Syntax: {
enumerable: false,
value: (function() {
var def = types.Type.def;
var Syntax = {};
Object.keys(types.namedTypes).forEach(function(name) {
if (def(name).buildable)
Syntax[name] = name;
});
// These two types are buildable but do not technically count
// as syntax because they are not printable.
delete Syntax.SourceLocation;
delete Syntax.Position;
return Syntax;
})()
},
Visitor: {
enumerable: false,
value: __webpack_require__(45).Visitor
}
});
/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(4)))
/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {
var types = __webpack_require__(8);
var def = types.Type.def;
def("File")
.bases("Node")
.build("program")
.field("program", def("Program"));
types.finalize();
module.exports = types;
/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {
var assert = __webpack_require__(2);
var types = __webpack_require__(27);
var n = types.namedTypes;
var b = types.builders;
var Patcher = __webpack_require__(29).Patcher;
var Visitor = __webpack_require__(45).Visitor;
var normalizeOptions = __webpack_require__(40).normalize;
exports.parse = function(source, options) {
options = normalizeOptions(options);
var lines = __webpack_require__(30).fromString(source, options);
var pure = options.esprima.parse(lines.toString({
tabWidth: options.tabWidth,
reuseWhitespace: false,
useTabs: false
}), {
loc: true,
range: options.range,
comment: true,
tolerant: options.tolerant
});
new LocationFixer(lines).visit(pure);
__webpack_require__(47).add(pure, lines);
// In order to ensure we reprint leading and trailing program
// comments, wrap the original Program node with a File node.
pure = b.file(pure);
pure.loc = {
lines: lines,
start: lines.firstPos(),
end: lines.lastPos()
};
// Return a copy of the original AST so that any changes made may be
// compared to the original.
return copyAst(pure);
};
var LocationFixer = Visitor.extend({
init: function(lines) {
this.lines = lines;
},
genericVisit: function(node) {
this._super(node);
var loc = node && node.loc,
start = loc && loc.start,
end = loc && loc.end;
if (loc) {
Object.defineProperty(loc, "lines", {
value: this.lines
});
}
if (start) {
start.line = Math.max(start.line, 1);
}
if (end) {
end.line = Math.max(end.line, 1);
var lines = loc.lines, pos = {
line: end.line,
column: end.column
};
// Negative columns might indicate an Esprima bug?
// For now, treat them as reverse indices, a la Python.
if (pos.column < 0)
pos.column += lines.getLineLength(pos.line);
while (lines.prevPos(pos)) {
if (/\S/.test(lines.charAt(pos))) {
assert.ok(lines.nextPos(pos));
end.line = pos.line;
end.column = pos.column;
break;
}
}
}
}
});
function copyAst(node, parent) {
if (typeof node === "object" &&
node !== null)
{
if (node instanceof RegExp)
return node;
if (node instanceof Array) {
return node.map(function(child) {
return copyAst(child, parent);
});
}
var copy = {},
key,
val;
for (key in node) {
if (node.hasOwnProperty(key)) {
val = copyAst(node[key], node);
if (typeof val !== "function")
copy[key] = val;
}
}
if (parent && n.Node.check(node)) {
// Allow upwards traversal of the original AST.
Object.defineProperty(node, "parentNode", {
value: parent
});
}
// Provide a link from the copy to the original.
Object.defineProperty(copy, "original", {
value: node,
configurable: false,
enumerable: false,
writable: true,
});
return copy;
}
return node;
}
/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {
var assert = __webpack_require__(2);
var linesModule = __webpack_require__(30);
var typesModule = __webpack_require__(27);
var getFieldValue = typesModule.getFieldValue;
var Node = typesModule.namedTypes.Node;
var util = __webpack_require__(43);
var comparePos = util.comparePos;
var NodePath = __webpack_require__(8).NodePath;
function Patcher(lines) {
assert.ok(this instanceof Patcher);
assert.ok(lines instanceof linesModule.Lines);
var self = this,
replacements = [];
self.replace = function(loc, lines) {
if (typeof lines === "string")
lines = linesModule.fromString(lines);
replacements.push({
lines: lines,
start: loc.start,
end: loc.end
});
};
self.get = function(loc) {
// If no location is provided, return the complete Lines object.
loc = loc || {
start: { line: 1, column: 0 },
end: { line: lines.length,
column: lines.getLineLength(lines.length) }
};
var sliceFrom = loc.start,
toConcat = [];
function pushSlice(from, to) {
assert.ok(comparePos(from, to) <= 0);
toConcat.push(lines.slice(from, to));
}
replacements.sort(function(a, b) {
return comparePos(a.start, b.start);
}).forEach(function(rep) {
if (comparePos(sliceFrom, rep.start) > 0) {
// Ignore nested replacement ranges.
} else {
pushSlice(sliceFrom, rep.start);
toConcat.push(rep.lines);
sliceFrom = rep.end;
}
});
pushSlice(sliceFrom, loc.end);
return linesModule.concat(toConcat);
};
}
exports.Patcher = Patcher;
exports.getReprinter = function(path) {
assert.ok(path instanceof NodePath);
var orig = path.node.original;
var origLoc = orig && orig.loc;
var lines = origLoc && origLoc.lines;
var reprints = [];
if (!lines || !findReprints(path, reprints))
return;
return function(print) {
var patcher = new Patcher(lines);
reprints.forEach(function(reprint) {
var old = reprint.oldNode;
patcher.replace(
old.loc,
print(reprint.newPath).indentTail(
getIndent(old)));
});
return patcher.get(origLoc).indentTail(-getIndent(orig));
};
};
// Get the indentation of the first ancestor node on a line with nothing
// before it but whitespace.
function getIndent(orig) {
var naiveIndent = orig.loc.lines.getIndentAt(
orig.loc.start.line);
for (var loc, start, lines;
orig &&
(loc = orig.loc) &&
(start = loc.start) &&
(lines = loc.lines);
orig = orig.parentNode)
{
if (lines.isPrecededOnlyByWhitespace(start)) {
// The indent returned by lines.getIndentAt is the column of
// the first non-space character in the line, but start.column
// may fall before that character, as when a file begins with
// whitespace but its start.column nevertheless must be 0.
assert.ok(start.column <= lines.getIndentAt(start.line));
return start.column;
}
}
return naiveIndent;
}
function findReprints(path, reprints) {
var node = path.node;
assert.ok(node.original);
assert.deepEqual(reprints, []);
var canReprint = findChildReprints(path, node.original, reprints);
if (!canReprint) {
// Make absolutely sure the calling code does not attempt to reprint
// any nodes.
reprints.length = 0;
}
return canReprint;
}
function findAnyReprints(path, oldNode, reprints) {
var newNode = path.value;
if (newNode === oldNode)
return true;
if (newNode instanceof Array)
return findArrayReprints(path, oldNode, reprints);
if (typeof newNode === "object")
return findObjectReprints(path, oldNode, reprints);
return false;
}
function findArrayReprints(path, oldNode, reprints) {
var newNode = path.value;
assert.ok(newNode instanceof Array);
var len = newNode.length;
if (!(oldNode instanceof Array &&
oldNode.length === len))
return false;
for (var i = 0; i < len; ++i)
if (!findAnyReprints(path.get(i), oldNode[i], reprints))
return false;
return true;
}
function findObjectReprints(path, oldNode, reprints) {
var newNode = path.value;
assert.strictEqual(typeof newNode, "object");
if (!newNode || !oldNode || typeof oldNode !== "object")
return false;
var childReprints = [];
var canReprintChildren = findChildReprints(path, oldNode, childReprints);
if (Node.check(newNode)) {
// TODO Decompose this check: if (!printTheSame(newNode, oldNode))
if (newNode.type !== oldNode.type)
return false;
if (!canReprintChildren) {
reprints.push({
newPath: path,
oldNode: oldNode
});
return true;
}
}
reprints.push.apply(reprints, childReprints);
return canReprintChildren;
}
function hasParens(oldNode) {
var loc = oldNode.loc;
var lines = loc && loc.lines;
if
gitextract_9rmqceah/ ├── .gitignore ├── .travis.yml ├── LICENSE ├── README.md ├── bin/ │ ├── compile │ ├── regenerator │ └── run ├── browser/ │ ├── build/ │ │ ├── bundle.js │ │ └── styles.css │ ├── index.html │ ├── main.js │ ├── script.js │ └── style.css ├── debuggers/ │ ├── browser/ │ │ ├── main.js │ │ └── static/ │ │ ├── app-conn.js │ │ ├── app.css │ │ ├── app.js │ │ ├── conn.js │ │ ├── index.html │ │ ├── lib/ │ │ │ ├── bootstrap-3.0.3/ │ │ │ │ ├── .editorconfig │ │ │ │ ├── .gitattributes │ │ │ │ ├── .gitignore │ │ │ │ ├── .travis.yml │ │ │ │ ├── CNAME │ │ │ │ ├── CONTRIBUTING.md │ │ │ │ ├── DOCS-LICENSE │ │ │ │ ├── Gruntfile.js │ │ │ │ ├── LICENSE │ │ │ │ ├── LICENSE-MIT │ │ │ │ ├── README.md │ │ │ │ ├── _config.yml │ │ │ │ ├── _includes/ │ │ │ │ │ ├── ads.html │ │ │ │ │ ├── footer.html │ │ │ │ │ ├── header.html │ │ │ │ │ ├── nav-about.html │ │ │ │ │ ├── nav-components.html │ │ │ │ │ ├── nav-css.html │ │ │ │ │ ├── nav-customize.html │ │ │ │ │ ├── nav-getting-started.html │ │ │ │ │ ├── nav-javascript.html │ │ │ │ │ ├── nav-main.html │ │ │ │ │ ├── old-bs-docs.html │ │ │ │ │ └── social-buttons.html │ │ │ │ ├── _layouts/ │ │ │ │ │ ├── default.html │ │ │ │ │ └── home.html │ │ │ │ ├── about.html │ │ │ │ ├── bower.json │ │ │ │ ├── components.html │ │ │ │ ├── composer.json │ │ │ │ ├── css.html │ │ │ │ ├── customize.html │ │ │ │ ├── dist/ │ │ │ │ │ ├── css/ │ │ │ │ │ │ ├── bootstrap-theme.css │ │ │ │ │ │ └── bootstrap.css │ │ │ │ │ └── js/ │ │ │ │ │ └── bootstrap.js │ │ │ │ ├── docs-assets/ │ │ │ │ │ ├── css/ │ │ │ │ │ │ ├── docs.css │ │ │ │ │ │ └── pygments-manni.css │ │ │ │ │ └── js/ │ │ │ │ │ ├── application.js │ │ │ │ │ ├── customizer.js │ │ │ │ │ ├── filesaver.js │ │ │ │ │ ├── holder.js │ │ │ │ │ ├── ie8-responsive-file-warning.js │ │ │ │ │ ├── jszip.js │ │ │ │ │ ├── less.js │ │ │ │ │ ├── raw-files.js │ │ │ │ │ └── uglify.js │ │ │ │ ├── examples/ │ │ │ │ │ ├── carousel/ │ │ │ │ │ │ ├── carousel.css │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── grid/ │ │ │ │ │ │ ├── grid.css │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── jumbotron/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── jumbotron.css │ │ │ │ │ ├── jumbotron-narrow/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── jumbotron-narrow.css │ │ │ │ │ ├── justified-nav/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── justified-nav.css │ │ │ │ │ ├── navbar/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── navbar.css │ │ │ │ │ ├── navbar-fixed-top/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── navbar-fixed-top.css │ │ │ │ │ ├── navbar-static-top/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── navbar-static-top.css │ │ │ │ │ ├── non-responsive/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── non-responsive.css │ │ │ │ │ ├── offcanvas/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ ├── offcanvas.css │ │ │ │ │ │ └── offcanvas.js │ │ │ │ │ ├── signin/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── signin.css │ │ │ │ │ ├── starter-template/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── starter-template.css │ │ │ │ │ ├── sticky-footer/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── sticky-footer.css │ │ │ │ │ ├── sticky-footer-navbar/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── sticky-footer-navbar.css │ │ │ │ │ └── theme/ │ │ │ │ │ ├── index.html │ │ │ │ │ └── theme.css │ │ │ │ ├── getting-started.html │ │ │ │ ├── index.html │ │ │ │ ├── javascript.html │ │ │ │ ├── js/ │ │ │ │ │ ├── .jshintrc │ │ │ │ │ ├── affix.js │ │ │ │ │ ├── alert.js │ │ │ │ │ ├── button.js │ │ │ │ │ ├── carousel.js │ │ │ │ │ ├── collapse.js │ │ │ │ │ ├── dropdown.js │ │ │ │ │ ├── modal.js │ │ │ │ │ ├── popover.js │ │ │ │ │ ├── scrollspy.js │ │ │ │ │ ├── tab.js │ │ │ │ │ ├── tests/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ ├── unit/ │ │ │ │ │ │ │ ├── affix.js │ │ │ │ │ │ │ ├── alert.js │ │ │ │ │ │ │ ├── button.js │ │ │ │ │ │ │ ├── carousel.js │ │ │ │ │ │ │ ├── collapse.js │ │ │ │ │ │ │ ├── dropdown.js │ │ │ │ │ │ │ ├── modal.js │ │ │ │ │ │ │ ├── phantom.js │ │ │ │ │ │ │ ├── popover.js │ │ │ │ │ │ │ ├── scrollspy.js │ │ │ │ │ │ │ ├── tab.js │ │ │ │ │ │ │ ├── tooltip.js │ │ │ │ │ │ │ └── transition.js │ │ │ │ │ │ └── vendor/ │ │ │ │ │ │ ├── jquery.js │ │ │ │ │ │ ├── qunit.css │ │ │ │ │ │ └── qunit.js │ │ │ │ │ ├── tooltip.js │ │ │ │ │ └── transition.js │ │ │ │ ├── less/ │ │ │ │ │ ├── alerts.less │ │ │ │ │ ├── badges.less │ │ │ │ │ ├── bootstrap.less │ │ │ │ │ ├── breadcrumbs.less │ │ │ │ │ ├── button-groups.less │ │ │ │ │ ├── buttons.less │ │ │ │ │ ├── carousel.less │ │ │ │ │ ├── close.less │ │ │ │ │ ├── code.less │ │ │ │ │ ├── component-animations.less │ │ │ │ │ ├── dropdowns.less │ │ │ │ │ ├── forms.less │ │ │ │ │ ├── glyphicons.less │ │ │ │ │ ├── grid.less │ │ │ │ │ ├── input-groups.less │ │ │ │ │ ├── jumbotron.less │ │ │ │ │ ├── labels.less │ │ │ │ │ ├── list-group.less │ │ │ │ │ ├── media.less │ │ │ │ │ ├── mixins.less │ │ │ │ │ ├── modals.less │ │ │ │ │ ├── navbar.less │ │ │ │ │ ├── navs.less │ │ │ │ │ ├── normalize.less │ │ │ │ │ ├── pager.less │ │ │ │ │ ├── pagination.less │ │ │ │ │ ├── panels.less │ │ │ │ │ ├── popovers.less │ │ │ │ │ ├── print.less │ │ │ │ │ ├── progress-bars.less │ │ │ │ │ ├── responsive-utilities.less │ │ │ │ │ ├── scaffolding.less │ │ │ │ │ ├── tables.less │ │ │ │ │ ├── theme.less │ │ │ │ │ ├── thumbnails.less │ │ │ │ │ ├── tooltip.less │ │ │ │ │ ├── type.less │ │ │ │ │ ├── utilities.less │ │ │ │ │ ├── variables.less │ │ │ │ │ └── wells.less │ │ │ │ └── package.json │ │ │ ├── codemirror-3.20/ │ │ │ │ ├── .gitattributes │ │ │ │ ├── .gitignore │ │ │ │ ├── .travis.yml │ │ │ │ ├── AUTHORS │ │ │ │ ├── CONTRIBUTING.md │ │ │ │ ├── LICENSE │ │ │ │ ├── README.md │ │ │ │ ├── addon/ │ │ │ │ │ ├── comment/ │ │ │ │ │ │ ├── comment.js │ │ │ │ │ │ └── continuecomment.js │ │ │ │ │ ├── dialog/ │ │ │ │ │ │ ├── dialog.css │ │ │ │ │ │ └── dialog.js │ │ │ │ │ ├── display/ │ │ │ │ │ │ ├── fullscreen.css │ │ │ │ │ │ ├── fullscreen.js │ │ │ │ │ │ └── placeholder.js │ │ │ │ │ ├── edit/ │ │ │ │ │ │ ├── closebrackets.js │ │ │ │ │ │ ├── closetag.js │ │ │ │ │ │ ├── continuelist.js │ │ │ │ │ │ ├── matchbrackets.js │ │ │ │ │ │ ├── matchtags.js │ │ │ │ │ │ └── trailingspace.js │ │ │ │ │ ├── fold/ │ │ │ │ │ │ ├── brace-fold.js │ │ │ │ │ │ ├── comment-fold.js │ │ │ │ │ │ ├── foldcode.js │ │ │ │ │ │ ├── foldgutter.css │ │ │ │ │ │ ├── foldgutter.js │ │ │ │ │ │ ├── indent-fold.js │ │ │ │ │ │ └── xml-fold.js │ │ │ │ │ ├── hint/ │ │ │ │ │ │ ├── anyword-hint.js │ │ │ │ │ │ ├── css-hint.js │ │ │ │ │ │ ├── html-hint.js │ │ │ │ │ │ ├── javascript-hint.js │ │ │ │ │ │ ├── pig-hint.js │ │ │ │ │ │ ├── python-hint.js │ │ │ │ │ │ ├── show-hint.css │ │ │ │ │ │ ├── show-hint.js │ │ │ │ │ │ ├── sql-hint.js │ │ │ │ │ │ └── xml-hint.js │ │ │ │ │ ├── lint/ │ │ │ │ │ │ ├── coffeescript-lint.js │ │ │ │ │ │ ├── css-lint.js │ │ │ │ │ │ ├── javascript-lint.js │ │ │ │ │ │ ├── json-lint.js │ │ │ │ │ │ ├── lint.css │ │ │ │ │ │ └── lint.js │ │ │ │ │ ├── merge/ │ │ │ │ │ │ ├── dep/ │ │ │ │ │ │ │ └── diff_match_patch.js │ │ │ │ │ │ ├── merge.css │ │ │ │ │ │ └── merge.js │ │ │ │ │ ├── mode/ │ │ │ │ │ │ ├── loadmode.js │ │ │ │ │ │ ├── multiplex.js │ │ │ │ │ │ ├── multiplex_test.js │ │ │ │ │ │ └── overlay.js │ │ │ │ │ ├── runmode/ │ │ │ │ │ │ ├── colorize.js │ │ │ │ │ │ ├── runmode-standalone.js │ │ │ │ │ │ ├── runmode.js │ │ │ │ │ │ └── runmode.node.js │ │ │ │ │ ├── scroll/ │ │ │ │ │ │ └── scrollpastend.js │ │ │ │ │ ├── search/ │ │ │ │ │ │ ├── match-highlighter.js │ │ │ │ │ │ ├── search.js │ │ │ │ │ │ └── searchcursor.js │ │ │ │ │ ├── selection/ │ │ │ │ │ │ ├── active-line.js │ │ │ │ │ │ └── mark-selection.js │ │ │ │ │ ├── tern/ │ │ │ │ │ │ ├── tern.css │ │ │ │ │ │ ├── tern.js │ │ │ │ │ │ └── worker.js │ │ │ │ │ └── wrap/ │ │ │ │ │ └── hardwrap.js │ │ │ │ ├── bin/ │ │ │ │ │ ├── authors.sh │ │ │ │ │ ├── compress │ │ │ │ │ ├── lint │ │ │ │ │ └── source-highlight │ │ │ │ ├── bower.json │ │ │ │ ├── demo/ │ │ │ │ │ ├── activeline.html │ │ │ │ │ ├── anywordhint.html │ │ │ │ │ ├── bidi.html │ │ │ │ │ ├── btree.html │ │ │ │ │ ├── buffers.html │ │ │ │ │ ├── changemode.html │ │ │ │ │ ├── closebrackets.html │ │ │ │ │ ├── closetag.html │ │ │ │ │ ├── complete.html │ │ │ │ │ ├── emacs.html │ │ │ │ │ ├── folding.html │ │ │ │ │ ├── fullscreen.html │ │ │ │ │ ├── hardwrap.html │ │ │ │ │ ├── html5complete.html │ │ │ │ │ ├── indentwrap.html │ │ │ │ │ ├── lint.html │ │ │ │ │ ├── loadmode.html │ │ │ │ │ ├── marker.html │ │ │ │ │ ├── markselection.html │ │ │ │ │ ├── matchhighlighter.html │ │ │ │ │ ├── matchtags.html │ │ │ │ │ ├── merge.html │ │ │ │ │ ├── multiplex.html │ │ │ │ │ ├── mustache.html │ │ │ │ │ ├── placeholder.html │ │ │ │ │ ├── preview.html │ │ │ │ │ ├── resize.html │ │ │ │ │ ├── runmode.html │ │ │ │ │ ├── search.html │ │ │ │ │ ├── spanaffectswrapping_shim.html │ │ │ │ │ ├── tern.html │ │ │ │ │ ├── theme.html │ │ │ │ │ ├── trailingspace.html │ │ │ │ │ ├── variableheight.html │ │ │ │ │ ├── vim.html │ │ │ │ │ ├── visibletabs.html │ │ │ │ │ ├── widget.html │ │ │ │ │ └── xmlcomplete.html │ │ │ │ ├── doc/ │ │ │ │ │ ├── activebookmark.js │ │ │ │ │ ├── compress.html │ │ │ │ │ ├── docs.css │ │ │ │ │ ├── internals.html │ │ │ │ │ ├── manual.html │ │ │ │ │ ├── realworld.html │ │ │ │ │ ├── releases.html │ │ │ │ │ ├── reporting.html │ │ │ │ │ ├── upgrade_v2.2.html │ │ │ │ │ └── upgrade_v3.html │ │ │ │ ├── index.html │ │ │ │ ├── keymap/ │ │ │ │ │ ├── emacs.js │ │ │ │ │ ├── extra.js │ │ │ │ │ └── vim.js │ │ │ │ ├── lib/ │ │ │ │ │ ├── codemirror.css │ │ │ │ │ └── codemirror.js │ │ │ │ ├── mode/ │ │ │ │ │ ├── apl/ │ │ │ │ │ │ ├── apl.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── asterisk/ │ │ │ │ │ │ ├── asterisk.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── clike/ │ │ │ │ │ │ ├── clike.js │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── scala.html │ │ │ │ │ ├── clojure/ │ │ │ │ │ │ ├── clojure.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── cobol/ │ │ │ │ │ │ ├── cobol.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── coffeescript/ │ │ │ │ │ │ ├── coffeescript.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── commonlisp/ │ │ │ │ │ │ ├── commonlisp.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── css/ │ │ │ │ │ │ ├── css.js │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ ├── scss.html │ │ │ │ │ │ ├── scss_test.js │ │ │ │ │ │ └── test.js │ │ │ │ │ ├── d/ │ │ │ │ │ │ ├── d.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── diff/ │ │ │ │ │ │ ├── diff.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── dtd/ │ │ │ │ │ │ ├── dtd.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── ecl/ │ │ │ │ │ │ ├── ecl.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── eiffel/ │ │ │ │ │ │ ├── eiffel.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── erlang/ │ │ │ │ │ │ ├── erlang.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── fortran/ │ │ │ │ │ │ ├── fortran.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── gas/ │ │ │ │ │ │ ├── gas.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── gfm/ │ │ │ │ │ │ ├── gfm.js │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── test.js │ │ │ │ │ ├── gherkin/ │ │ │ │ │ │ ├── gherkin.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── go/ │ │ │ │ │ │ ├── go.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── groovy/ │ │ │ │ │ │ ├── groovy.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── haml/ │ │ │ │ │ │ ├── haml.js │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── test.js │ │ │ │ │ ├── haskell/ │ │ │ │ │ │ ├── haskell.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── haxe/ │ │ │ │ │ │ ├── haxe.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── htmlembedded/ │ │ │ │ │ │ ├── htmlembedded.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── htmlmixed/ │ │ │ │ │ │ ├── htmlmixed.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── http/ │ │ │ │ │ │ ├── http.js │ │ │ │ │ │ └── index.html │ │ │ │ │ ├── index.html │ │ │ │ │ ├── jade/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── jade.js │ │ │ │ │ ├── javascript/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ ├── javascript.js │ │ │ │ │ │ ├── test.js │ │ │ │ │ │ └── typescript.html │ │ │ │ │ ├── jinja2/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── jinja2.js │ │ │ │ │ ├── julia/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── julia.js │ │ │ │ │ ├── less/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── less.js │ │ │ │ │ ├── livescript/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ ├── livescript.js │ │ │ │ │ │ └── livescript.ls │ │ │ │ │ ├── lua/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── lua.js │ │ │ │ │ ├── markdown/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ ├── markdown.js │ │ │ │ │ │ └── test.js │ │ │ │ │ ├── meta.js │ │ │ │ │ ├── mirc/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── mirc.js │ │ │ │ │ ├── nginx/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── nginx.js │ │ │ │ │ ├── ntriples/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── ntriples.js │ │ │ │ │ ├── ocaml/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── ocaml.js │ │ │ │ │ ├── octave/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── octave.js │ │ │ │ │ ├── pascal/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── pascal.js │ │ │ │ │ ├── pegjs/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── pegjs.js │ │ │ │ │ ├── perl/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── perl.js │ │ │ │ │ ├── php/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── php.js │ │ │ │ │ ├── pig/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── pig.js │ │ │ │ │ ├── properties/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── properties.js │ │ │ │ │ ├── python/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── python.js │ │ │ │ │ ├── q/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── q.js │ │ │ │ │ ├── r/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── r.js │ │ │ │ │ ├── rpm/ │ │ │ │ │ │ ├── changes/ │ │ │ │ │ │ │ ├── changes.js │ │ │ │ │ │ │ └── index.html │ │ │ │ │ │ └── spec/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ ├── spec.css │ │ │ │ │ │ └── spec.js │ │ │ │ │ ├── rst/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── rst.js │ │ │ │ │ ├── ruby/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── ruby.js │ │ │ │ │ ├── rust/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── rust.js │ │ │ │ │ ├── sass/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── sass.js │ │ │ │ │ ├── scheme/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── scheme.js │ │ │ │ │ ├── shell/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── shell.js │ │ │ │ │ ├── sieve/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── sieve.js │ │ │ │ │ ├── smalltalk/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── smalltalk.js │ │ │ │ │ ├── smarty/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── smarty.js │ │ │ │ │ ├── smartymixed/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── smartymixed.js │ │ │ │ │ ├── sparql/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── sparql.js │ │ │ │ │ ├── sql/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── sql.js │ │ │ │ │ ├── stex/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ ├── stex.js │ │ │ │ │ │ └── test.js │ │ │ │ │ ├── tcl/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── tcl.js │ │ │ │ │ ├── tiddlywiki/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ ├── tiddlywiki.css │ │ │ │ │ │ └── tiddlywiki.js │ │ │ │ │ ├── tiki/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ ├── tiki.css │ │ │ │ │ │ └── tiki.js │ │ │ │ │ ├── toml/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── toml.js │ │ │ │ │ ├── turtle/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── turtle.js │ │ │ │ │ ├── vb/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── vb.js │ │ │ │ │ ├── vbscript/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── vbscript.js │ │ │ │ │ ├── velocity/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── velocity.js │ │ │ │ │ ├── verilog/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── verilog.js │ │ │ │ │ ├── xml/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── xml.js │ │ │ │ │ ├── xquery/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ ├── test.js │ │ │ │ │ │ └── xquery.js │ │ │ │ │ ├── yaml/ │ │ │ │ │ │ ├── index.html │ │ │ │ │ │ └── yaml.js │ │ │ │ │ └── z80/ │ │ │ │ │ ├── index.html │ │ │ │ │ └── z80.js │ │ │ │ ├── package.json │ │ │ │ ├── test/ │ │ │ │ │ ├── comment_test.js │ │ │ │ │ ├── doc_test.js │ │ │ │ │ ├── driver.js │ │ │ │ │ ├── emacs_test.js │ │ │ │ │ ├── index.html │ │ │ │ │ ├── lint/ │ │ │ │ │ │ ├── acorn.js │ │ │ │ │ │ ├── lint.js │ │ │ │ │ │ └── walk.js │ │ │ │ │ ├── mode_test.css │ │ │ │ │ ├── mode_test.js │ │ │ │ │ ├── phantom_driver.js │ │ │ │ │ ├── run.js │ │ │ │ │ ├── test.js │ │ │ │ │ └── vim_test.js │ │ │ │ └── theme/ │ │ │ │ ├── 3024-day.css │ │ │ │ ├── 3024-night.css │ │ │ │ ├── ambiance-mobile.css │ │ │ │ ├── ambiance.css │ │ │ │ ├── base16-dark.css │ │ │ │ ├── base16-light.css │ │ │ │ ├── blackboard.css │ │ │ │ ├── cobalt.css │ │ │ │ ├── eclipse.css │ │ │ │ ├── elegant.css │ │ │ │ ├── erlang-dark.css │ │ │ │ ├── lesser-dark.css │ │ │ │ ├── mbo.css │ │ │ │ ├── midnight.css │ │ │ │ ├── monokai.css │ │ │ │ ├── neat.css │ │ │ │ ├── night.css │ │ │ │ ├── paraiso-dark.css │ │ │ │ ├── paraiso-light.css │ │ │ │ ├── rubyblue.css │ │ │ │ ├── solarized.css │ │ │ │ ├── the-matrix.css │ │ │ │ ├── tomorrow-night-eighties.css │ │ │ │ ├── twilight.css │ │ │ │ ├── vibrant-ink.css │ │ │ │ ├── xq-dark.css │ │ │ │ └── xq-light.css │ │ │ ├── esprima.js │ │ │ └── react-0.8.0/ │ │ │ ├── README.md │ │ │ ├── build/ │ │ │ │ ├── JSXTransformer.js │ │ │ │ ├── react-with-addons.js │ │ │ │ └── react.js │ │ │ └── examples/ │ │ │ ├── ballmer-peak/ │ │ │ │ ├── example.js │ │ │ │ └── index.html │ │ │ ├── basic/ │ │ │ │ └── index.html │ │ │ ├── basic-jsx/ │ │ │ │ └── index.html │ │ │ ├── basic-jsx-external/ │ │ │ │ ├── example.js │ │ │ │ └── index.html │ │ │ ├── basic-jsx-precompile/ │ │ │ │ ├── example.js │ │ │ │ └── index.html │ │ │ ├── jquery-bootstrap/ │ │ │ │ ├── css/ │ │ │ │ │ └── example.css │ │ │ │ ├── index.html │ │ │ │ └── js/ │ │ │ │ └── app.js │ │ │ ├── requirejs/ │ │ │ │ └── build/ │ │ │ │ ├── app.js │ │ │ │ └── example-component.js │ │ │ ├── shared/ │ │ │ │ └── css/ │ │ │ │ └── base.css │ │ │ ├── todomvc-backbone/ │ │ │ │ ├── README.md │ │ │ │ ├── css/ │ │ │ │ │ └── base.css │ │ │ │ ├── index.html │ │ │ │ ├── js/ │ │ │ │ │ ├── app.js │ │ │ │ │ └── ie.js │ │ │ │ └── thirdparty/ │ │ │ │ ├── backbone-min.js │ │ │ │ └── backbone.localStorage-min.js │ │ │ ├── todomvc-director/ │ │ │ │ ├── README.md │ │ │ │ ├── bower.json │ │ │ │ ├── index.html │ │ │ │ └── js/ │ │ │ │ ├── app.jsx │ │ │ │ ├── footer.jsx │ │ │ │ ├── todoItem.jsx │ │ │ │ └── utils.jsx │ │ │ └── transitions/ │ │ │ ├── index.html │ │ │ └── transition.css │ │ ├── mouse.js │ │ ├── probe.js │ │ ├── renderers.js │ │ ├── src.js │ │ ├── src.txt │ │ ├── src2.txt │ │ ├── src3.txt │ │ ├── src4.txt │ │ ├── test.out.js │ │ └── vm.js │ └── node/ │ └── run.js ├── examples/ │ └── resumable-exceptions.js ├── lib/ │ ├── debug.js │ ├── emit.js │ ├── hoist.js │ ├── leap.js │ ├── meta.js │ ├── util.js │ └── visit.js ├── main.js ├── package.json ├── runtime/ │ └── vm.js ├── test.js └── webpack.config.js
Showing preview only (307K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (3805 symbols across 172 files)
FILE: browser/build/bundle.js
function __webpack_require__ (line 6) | function __webpack_require__(moduleId) {
function showError (line 76) | function showError(e) {
function initDebugger (line 93) | function initDebugger(node, code) {
function finishInit (line 114) | function finishInit(code, breakpoint, container, id) {
function regenerator (line 378) | function regenerator(source, options) {
function replacer (line 533) | function replacer(key, value) {
function truncate (line 546) | function truncate(s, n) {
function getMessage (line 554) | function getMessage(self) {
function fail (line 571) | function fail(actual, expected, message, operator, stackStartFunction) {
function ok (line 591) | function ok(value, message) {
function _deepEqual (line 622) | function _deepEqual(actual, expected) {
function isArguments (line 667) | function isArguments(object) {
function objEquiv (line 671) | function objEquiv(a, b) {
function expectedException (line 740) | function expectedException(actual, expected) {
function _throws (line 756) | function _throws(shouldThrow, block, expected, message) {
function deprecated (line 891) | function deprecated() {
function inspect (line 938) | function inspect(obj, opts) {
function stylizeWithColor (line 996) | function stylizeWithColor(str, styleType) {
function stylizeNoColor (line 1008) | function stylizeNoColor(str, styleType) {
function arrayToHash (line 1013) | function arrayToHash(array) {
function formatValue (line 1024) | function formatValue(ctx, value, recurseTimes) {
function formatPrimitive (line 1137) | function formatPrimitive(ctx, value) {
function formatError (line 1156) | function formatError(value) {
function formatArray (line 1161) | function formatArray(ctx, value, recurseTimes, visibleKeys, keys) {
function formatProperty (line 1181) | function formatProperty(ctx, value, recurseTimes, visibleKeys, key, arra...
function reduceToSingleString (line 1240) | function reduceToSingleString(output, base, braces) {
function isArray (line 1263) | function isArray(ar) {
function isBoolean (line 1268) | function isBoolean(arg) {
function isNull (line 1273) | function isNull(arg) {
function isNullOrUndefined (line 1278) | function isNullOrUndefined(arg) {
function isNumber (line 1283) | function isNumber(arg) {
function isString (line 1288) | function isString(arg) {
function isSymbol (line 1293) | function isSymbol(arg) {
function isUndefined (line 1298) | function isUndefined(arg) {
function isRegExp (line 1303) | function isRegExp(re) {
function isObject (line 1308) | function isObject(arg) {
function isDate (line 1313) | function isDate(d) {
function isError (line 1318) | function isError(e) {
function isFunction (line 1324) | function isFunction(arg) {
function isPrimitive (line 1329) | function isPrimitive(arg) {
function objectToString (line 1341) | function objectToString(o) {
function pad (line 1346) | function pad(n) {
function timestamp (line 1355) | function timestamp() {
function hasOwnProperty (line 1397) | function hasOwnProperty(obj, prop) {
function cleanUpNextTick (line 1415) | function cleanUpNextTick() {
function drainQueue (line 1427) | function drainQueue() {
function Item (line 1465) | function Item(fun, array) {
function noop (line 1479) | function noop() {}
function normalizeArray (line 1569) | function normalizeArray(parts, allowAboveRoot) {
function trim (line 1678) | function trim(arr) {
function filter (line 1751) | function filter (xs, f) {
function Type (line 1819) | function Type(check, name) {
function shallowStringify (line 1863) | function shallowStringify(value) {
function defBuiltInType (line 1893) | function defBuiltInType(example, name) {
function toType (line 1924) | function toType(from, name) {
function Field (line 2009) | function Field(name, type, defaultFn, hidden) {
function Def (line 2064) | function Def(typeName) {
function checkFieldByName (line 2112) | function checkFieldByName(name) {
function add (line 2257) | function add(param, i) {
function getBuilderName (line 2312) | function getBuilderName(typeName) {
function extend (line 2454) | function extend(into, from) {
function traverseWithFullPathInfo (line 3297) | function traverseWithFullPathInfo(node, callback) {
function traverseWithNoPathInfo (line 3349) | function traverseWithNoPathInfo(node, callback, context) {
function NodePath (line 3397) | function NodePath(value, parentPath, name) {
function isBinary (line 3616) | function isBinary(node) {
function containsCallExpression (line 3638) | function containsCallExpression(node) {
function firstInStatement (line 3660) | function firstInStatement(path) {
function Path (line 3746) | function Path(value, parentPath, name) {
function getChildPath (line 3775) | function getChildPath(path, name) {
function makeSafeToCall (line 3926) | function makeSafeToCall(fun) {
function makeUniqueKey (line 3954) | function makeUniqueKey() {
function makeAccessor (line 3968) | function makeAccessor() {
function Scope (line 4008) | function Scope(path, parentScope) {
function scanScope (line 4083) | function scanScope(path, bindings) {
function recursiveScanScope (line 4098) | function recursiveScanScope(path, bindings) {
function recursiveScanChild (line 4130) | function recursiveScanChild(path, bindings) {
function addPattern (line 4164) | function addPattern(patternPath, bindings) {
function newFunctionName (line 4386) | function newFunctionName() {
function visitNode (line 4390) | function visitNode(node, scope, debugInfo) {
function getRestoration (line 4606) | function getRestoration(self, isGlobal, localScope, hasTry) {
function varDeclToExpr (line 4746) | function varDeclToExpr(vdec, includeIdentifiers) {
function makeASTGenerator (line 4974) | function makeASTGenerator(code) {
function Emitter (line 4991) | function Emitter(debugId, debugInfo) {
function loc (line 5036) | function loc() {
function isSwitchCaseEnder (line 5350) | function isSwitchCaseEnder(stmt) {
function isAtomic (line 5359) | function isAtomic(expr) {
function getDeclError (line 5411) | function getDeclError(node) {
function finish (line 5928) | function finish(expr) {
function explodeViaTempVar (line 5962) | function explodeViaTempVar(tempVar, childPath, ignoreChildResult, keepTe...
function print (line 6226) | function print(node, options) {
function prettyPrint (line 6230) | function prettyPrint(node, options) {
function run (line 6234) | function run(transformer, options) {
function runFile (line 6238) | function runFile(path, transformer, options) {
function defaultWriteback (line 6249) | function defaultWriteback(output) {
function runString (line 6253) | function runString(code, transformer, options) {
function copyAst (line 6446) | function copyAst(node, parent) {
function Patcher (line 6506) | function Patcher(lines) {
function getIndent (line 6587) | function getIndent(orig) {
function findReprints (line 6611) | function findReprints(path, reprints) {
function findAnyReprints (line 6627) | function findAnyReprints(path, oldNode, reprints) {
function findArrayReprints (line 6641) | function findArrayReprints(path, oldNode, reprints) {
function findObjectReprints (line 6657) | function findObjectReprints(path, oldNode, reprints) {
function hasParens (line 6685) | function hasParens(oldNode) {
function findChildReprints (line 6705) | function findChildReprints(path, oldNode, reprints) {
function Lines (line 6756) | function Lines(infos, sourceFileName) {
function copyLineInfo (line 6794) | function copyLineInfo(info) {
function countSpaces (line 6807) | function countSpaces(spaces, tabWidth) {
function fromString (line 6840) | function fromString(string, options) {
function isOnlyWhitespace (line 6872) | function isOnlyWhitespace(string) {
function updateJSON (line 6890) | function updateJSON(json) {
function sliceInfo (line 7330) | function sliceInfo(info, startCol, endCol) {
function appendSecret (line 7464) | function appendSecret(secret) {
function appendWithSeparator (line 7499) | function appendWithSeparator(secret, i) {
function SourceMapGenerator (line 7586) | function SourceMapGenerator(aArgs) {
function toVLQSigned (line 8021) | function toVLQSigned(aValue) {
function fromVLQSigned (line 8033) | function fromVLQSigned(aValue) {
function getArg (line 8168) | function getArg(aArgs, aName, aDefaultValue) {
function urlParse (line 8182) | function urlParse(aUrl) {
function urlGenerate (line 8197) | function urlGenerate(aParsedUrl) {
function join (line 8215) | function join(aRoot, aPath) {
function toSetString (line 8240) | function toSetString(aStr) {
function fromSetString (line 8245) | function fromSetString(aStr) {
function relative (line 8250) | function relative(aRoot, aPath) {
function strcmp (line 8264) | function strcmp(aStr1, aStr2) {
function compareByOriginalPositions (line 8278) | function compareByOriginalPositions(mappingA, mappingB, onlyCompareOrigi...
function compareByGeneratedPositions (line 8319) | function compareByGeneratedPositions(mappingA, mappingB, onlyCompareGene...
function ArraySet (line 8377) | function ArraySet() {
function SourceMapConsumer (line 8507) | function SourceMapConsumer(aSourceMap) {
function recursiveSearch (line 8964) | function recursiveSearch(aLow, aHigh, aNeedle, aHaystack, aCompare) {
function SourceNode (line 9057) | function SourceNode(aLine, aColumn, aSource, aChunks, aName) {
function addMappingWithCode (line 9157) | function addMappingWithCode(mapping, code) {
function get (line 9426) | function get(key) {
function assert (line 9693) | function assert(condition, message) {
function isDecimalDigit (line 9700) | function isDecimalDigit(ch) {
function isHexDigit (line 9704) | function isHexDigit(ch) {
function isOctalDigit (line 9708) | function isOctalDigit(ch) {
function octalToDecimal (line 9712) | function octalToDecimal(ch) {
function isWhiteSpace (line 9737) | function isWhiteSpace(ch) {
function isLineTerminator (line 9744) | function isLineTerminator(ch) {
function fromCodePoint (line 9750) | function fromCodePoint(cp) {
function isIdentifierStart (line 9756) | function isIdentifierStart(ch) {
function isIdentifierPart (line 9764) | function isIdentifierPart(ch) {
function isFutureReservedWord (line 9775) | function isFutureReservedWord(id) {
function isStrictModeReservedWord (line 9787) | function isStrictModeReservedWord(id) {
function isRestrictedWord (line 9804) | function isRestrictedWord(id) {
function isKeyword (line 9810) | function isKeyword(id) {
function addComment (line 9840) | function addComment(type, value, start, end, loc) {
function skipSingleLineComment (line 9871) | function skipSingleLineComment(offset) {
function skipMultiLineComment (line 9914) | function skipMultiLineComment() {
function skipComment (line 9970) | function skipComment() {
function scanHexEscape (line 10028) | function scanHexEscape(prefix) {
function scanUnicodeCodePointEscape (line 10043) | function scanUnicodeCodePointEscape() {
function codePointAt (line 10069) | function codePointAt(i) {
function getComplexIdentifier (line 10084) | function getComplexIdentifier() {
function getIdentifier (line 10143) | function getIdentifier() {
function scanIdentifier (line 10168) | function scanIdentifier() {
function scanPunctuator (line 10203) | function scanPunctuator() {
function scanHexLiteral (line 10303) | function scanHexLiteral(start) {
function scanBinaryLiteral (line 10331) | function scanBinaryLiteral(start) {
function scanOctalLiteral (line 10367) | function scanOctalLiteral(prefix, start) {
function isImplicitOctalLiteral (line 10406) | function isImplicitOctalLiteral() {
function scanNumericLiteral (line 10424) | function scanNumericLiteral() {
function scanStringLiteral (line 10507) | function scanStringLiteral() {
function scanTemplate (line 10607) | function scanTemplate() {
function testRegExp (line 10731) | function testRegExp(pattern, flags) {
function scanRegExpBody (line 10783) | function scanRegExpBody() {
function scanRegExpFlags (line 10830) | function scanRegExpFlags() {
function scanRegExp (line 10875) | function scanRegExp() {
function collectRegex (line 10914) | function collectRegex() {
function isIdentifierName (line 10958) | function isIdentifierName(token) {
function advanceSlash (line 10968) | function advanceSlash() {
function advance (line 11007) | function advance() {
function collectToken (line 11075) | function collectToken() {
function lex (line 11125) | function lex() {
function peek (line 11146) | function peek() {
function Position (line 11163) | function Position() {
function SourceLocation (line 11168) | function SourceLocation() {
function WrappingSourceLocation (line 11173) | function WrappingSourceLocation(startToken) {
function Node (line 11181) | function Node() {
function WrappingNode (line 11190) | function WrappingNode(startToken) {
function recordError (line 11841) | function recordError(error) {
function constructError (line 11856) | function constructError(msg, column) {
function createError (line 11871) | function createError(line, pos, description) {
function throwError (line 11885) | function throwError(messageFormat) {
function tolerateError (line 11899) | function tolerateError(messageFormat) {
function unexpectedTokenError (line 11921) | function unexpectedTokenError(token, message) {
function throwUnexpectedToken (line 11954) | function throwUnexpectedToken(token, message) {
function tolerateUnexpectedToken (line 11958) | function tolerateUnexpectedToken(token, message) {
function expect (line 11970) | function expect(value) {
function expectCommaSeparator (line 11983) | function expectCommaSeparator() {
function expectKeyword (line 12004) | function expectKeyword(keyword) {
function match (line 12013) | function match(value) {
function matchKeyword (line 12019) | function matchKeyword(keyword) {
function matchContextualKeyword (line 12026) | function matchContextualKeyword(keyword) {
function matchAssign (line 12032) | function matchAssign() {
function consumeSemicolon (line 12053) | function consumeSemicolon() {
function isolateCoverGrammar (line 12105) | function isolateCoverGrammar(parser) {
function inheritCoverGrammar (line 12123) | function inheritCoverGrammar(parser) {
function parseArrayPattern (line 12140) | function parseArrayPattern(params, kind) {
function parsePropertyPattern (line 12171) | function parsePropertyPattern(params, kind) {
function parseObjectPattern (line 12196) | function parseObjectPattern(params, kind) {
function parsePattern (line 12213) | function parsePattern(params, kind) {
function parsePatternWithDefault (line 12228) | function parsePatternWithDefault(params, kind) {
function parseArrayInitializer (line 12244) | function parseArrayInitializer() {
function parsePropertyFunction (line 12279) | function parsePropertyFunction(node, paramInfo, isGenerator) {
function parsePropertyMethodFunction (line 12298) | function parsePropertyMethodFunction() {
function parseObjectPropertyKey (line 12313) | function parseObjectPropertyKey() {
function lookaheadPropertyName (line 12344) | function lookaheadPropertyName() {
function tryParseMethodDefinition (line 12365) | function tryParseMethodDefinition(token, key, computed, node) {
function parseObjectProperty (line 12446) | function parseObjectProperty(hasProto) {
function parseObjectInitializer (line 12494) | function parseObjectInitializer() {
function reinterpretExpressionAsPattern (line 12512) | function reinterpretExpressionAsPattern(expr) {
function parseTemplateElement (line 12550) | function parseTemplateElement(option) {
function parseTemplateLiteral (line 12563) | function parseTemplateLiteral() {
function parseGroupExpression (line 12581) | function parseGroupExpression() {
function parsePrimaryExpression (line 12684) | function parsePrimaryExpression() {
function parseArguments (line 12765) | function parseArguments() {
function parseNonComputedProperty (line 12792) | function parseNonComputedProperty() {
function parseNonComputedMember (line 12804) | function parseNonComputedMember() {
function parseComputedMember (line 12810) | function parseComputedMember() {
function parseNewExpression (line 12824) | function parseNewExpression() {
function parseLeftHandSideExpressionAllowCall (line 12850) | function parseLeftHandSideExpressionAllowCall() {
function parseLeftHandSideExpression (line 12897) | function parseLeftHandSideExpression() {
function parsePostfixExpression (line 12937) | function parsePostfixExpression() {
function parseUnaryExpression (line 12965) | function parseUnaryExpression() {
function binaryPrecedence (line 13006) | function binaryPrecedence(token, allowIn) {
function parseBinaryExpression (line 13085) | function parseBinaryExpression() {
function parseConditionalExpression (line 13141) | function parseConditionalExpression() {
function parseConciseBody (line 13165) | function parseConciseBody() {
function checkPatternParam (line 13172) | function checkPatternParam(options, param) {
function reinterpretAsCoverFormalsList (line 13201) | function reinterpretAsCoverFormalsList(expr) {
function parseArrowFunctionExpression (line 13275) | function parseArrowFunctionExpression(options, node) {
function parseYieldExpression (line 13304) | function parseYieldExpression() {
function parseAssignmentExpression (line 13333) | function parseAssignmentExpression() {
function parseExpression (line 13389) | function parseExpression() {
function parseStatementListItem (line 13413) | function parseStatementListItem() {
function parseStatementList (line 13442) | function parseStatementList() {
function parseBlock (line 13454) | function parseBlock() {
function parseVariableIdentifier (line 13468) | function parseVariableIdentifier(kind) {
function parseVariableDeclaration (line 13494) | function parseVariableDeclaration(options) {
function parseVariableDeclarationList (line 13514) | function parseVariableDeclarationList(options) {
function parseVariableStatement (line 13528) | function parseVariableStatement(node) {
function parseLexicalBinding (line 13542) | function parseLexicalBinding(kind, options) {
function parseBindingList (line 13565) | function parseBindingList(kind, options) {
function tokenizerState (line 13577) | function tokenizerState() {
function resetTokenizerState (line 13594) | function resetTokenizerState(ts) {
function isLexicalDeclaration (line 13611) | function isLexicalDeclaration() {
function parseLexicalDeclaration (line 13625) | function parseLexicalDeclaration(options) {
function parseRestElement (line 13638) | function parseRestElement(params) {
function parseEmptyStatement (line 13664) | function parseEmptyStatement(node) {
function parseExpressionStatement (line 13671) | function parseExpressionStatement(node) {
function parseIfStatement (line 13679) | function parseIfStatement(node) {
function parseDoWhileStatement (line 13704) | function parseDoWhileStatement(node) {
function parseWhileStatement (line 13731) | function parseWhileStatement(node) {
function parseForStatement (line 13752) | function parseForStatement(node) {
function parseContinueStatement (line 13894) | function parseContinueStatement(node) {
function parseBreakStatement (line 13938) | function parseBreakStatement(node) {
function parseReturnStatement (line 13978) | function parseReturnStatement(node) {
function parseWithStatement (line 14014) | function parseWithStatement(node) {
function parseSwitchCase (line 14036) | function parseSwitchCase() {
function parseSwitchStatement (line 14059) | function parseSwitchStatement(node) {
function parseThrowStatement (line 14106) | function parseThrowStatement(node) {
function parseCatchClause (line 14124) | function parseCatchClause() {
function parseTryStatement (line 14153) | function parseTryStatement(node) {
function parseDebuggerStatement (line 14178) | function parseDebuggerStatement(node) {
function parseStatement (line 14188) | function parseStatement() {
function parseFunctionSourceElements (line 14273) | function parseFunctionSourceElements() {
function validateParam (line 14332) | function validateParam(options, param, name) {
function parseParam (line 14358) | function parseParam(options) {
function parseParams (line 14387) | function parseParams(firstRestricted) {
function parseFunctionDeclaration (line 14424) | function parseFunctionDeclaration(node, identifierIsOptional) {
function parseFunctionExpression (line 14481) | function parseFunctionExpression() {
function parseClassBody (line 14539) | function parseClassBody() {
function parseClassDeclaration (line 14605) | function parseClassDeclaration(identifierIsOptional) {
function parseClassExpression (line 14625) | function parseClassExpression() {
function parseModuleSpecifier (line 14647) | function parseModuleSpecifier() {
function parseExportSpecifier (line 14658) | function parseExportSpecifier() {
function parseExportNamedDeclaration (line 14675) | function parseExportNamedDeclaration(node) {
function parseExportDefaultDeclaration (line 14730) | function parseExportDefaultDeclaration(node) {
function parseExportAllDeclaration (line 14769) | function parseExportAllDeclaration(node) {
function parseExportDeclaration (line 14786) | function parseExportDeclaration() {
function parseImportSpecifier (line 14805) | function parseImportSpecifier() {
function parseNamedImports (line 14818) | function parseNamedImports() {
function parseImportDefaultSpecifier (line 14835) | function parseImportDefaultSpecifier() {
function parseImportNamespaceSpecifier (line 14844) | function parseImportNamespaceSpecifier() {
function parseImportDeclaration (line 14858) | function parseImportDeclaration() {
function parseScriptBody (line 14911) | function parseScriptBody() {
function parseProgram (line 14950) | function parseProgram() {
function filterTokenLocation (line 14960) | function filterTokenLocation() {
function tokenize (line 14987) | function tokenize(code, options, delegate) {
function parse (line 15076) | function parse(code, options) {
function makeSafeToCall (line 15210) | function makeSafeToCall(fun) {
function makeUniqueKey (line 15238) | function makeUniqueKey() {
function wrap (line 15252) | function wrap(obj, value) {
function defaultCreatorFn (line 15279) | function defaultCreatorFn(object) {
function makeAccessor (line 15283) | function makeAccessor(secretCreatorFn) {
function getUnionOfKeys (line 15334) | function getUnionOfKeys(obj) {
function deepEquivalent (line 15360) | function deepEquivalent(a, b) {
function deepArrEquiv (line 15374) | function deepArrEquiv(a, b) {
function deepObjEquiv (line 15393) | function deepObjEquiv(a, b) {
function comparePos (line 15415) | function comparePos(pos1, pos2) {
function Mapping (line 15483) | function Mapping(sourceLines, sourceLoc, targetLoc) {
function skip (line 15527) | function skip(name) {
function addPos (line 15610) | function addPos(toPos, line, column) {
function subtractPos (line 15626) | function subtractPos(fromPos, line, column) {
function skipChars (line 15676) | function skipChars(
function makeClass (line 15884) | function makeClass(base, newProps) {
function populate (line 15965) | function populate(target, source, parent) {
function maybeWrap (line 15974) | function maybeWrap(name, child, parent) {
function extend (line 15995) | function extend(newProps) {
function addComment (line 16055) | function addComment(node, comment) {
function dumpTrailing (line 16062) | function dumpTrailing() {
function getKey (line 16183) | function getKey(node, which) {
function printLeadingComment (line 16189) | function printLeadingComment(comment) {
function printTrailingComment (line 16229) | function printTrailingComment(comment) {
function PrintResult (line 16321) | function PrintResult(code, sourceMap) {
function Printer (line 16363) | function Printer(options) {
function maybeAddParens (line 16450) | function maybeAddParens(path, lines) {
function genericPrint (line 16454) | function genericPrint(path, options, printPath) {
function genericPrintNoParens (line 16459) | function genericPrintNoParens(path, options, print) {
function printStatementSequence (line 17168) | function printStatementSequence(path, print, inClassBody) {
function maybeWrapParams (line 17236) | function maybeWrapParams(path, options, print) {
function adjustClause (line 17247) | function adjustClause(clause, options) {
function lastNonSpaceCharacter (line 17257) | function lastNonSpaceCharacter(lines) {
function endsWithBrace (line 17266) | function endsWithBrace(lines) {
function nodeStrEscape (line 17270) | function nodeStrEscape(str) {
function nodeStr (line 17281) | function nodeStr(n) {
function maybeAddSemicolon (line 17301) | function maybeAddSemicolon(lines) {
function Entry (line 17335) | function Entry() {
function FunctionEntry (line 17339) | function FunctionEntry(returnLoc) {
function LoopEntry (line 17352) | function LoopEntry(breakLoc, continueLoc, label) {
function SwitchEntry (line 17374) | function SwitchEntry(breakLoc) {
function TryEntry (line 17387) | function TryEntry(catchEntry, finallyEntry) {
function CatchEntry (line 17411) | function CatchEntry(firstLoc, paramId) {
function FinallyEntry (line 17426) | function FinallyEntry(firstLoc, nextLocTempVar) {
function LeapManager (line 17441) | function LeapManager(emitter) {
function getLeapLocation (line 17528) | function getLeapLocation(entry, property, label) {
function makePredicate (line 17591) | function makePredicate(propertyName, knownTypes) {
function DebugInfo (line 17686) | function DebugInfo() {
function namespace (line 17798) | function namespace(str, obj) {
function assert (line 17867) | function assert(cond, text) {
function defaultOptions (line 17873) | function defaultOptions() {
function updateDeeply (line 17880) | function updateDeeply(target, override) {
function Reference (line 17908) | function Reference(ident, scope, flag, writeExpr, maybeImplicitGlobal) {
function Variable (line 18027) | function Variable(name, scope) {
function isStrictScope (line 18081) | function isStrictScope(scope, block) {
function Scope (line 18134) | function Scope(block, opt) {
function ScopeManager (line 18513) | function ScopeManager(scopes) {
function analyze (line 18590) | function analyze(tree, providedOptions) {
function ignoreJSHintError (line 18970) | function ignoreJSHintError() { }
function deepCopy (line 18979) | function deepCopy(obj) {
function shallowCopy (line 18994) | function shallowCopy(obj) {
function upperBound (line 19008) | function upperBound(array, func) {
function lowerBound (line 19027) | function lowerBound(array, func) {
function Reference (line 19108) | function Reference(parent, key) {
function Element (line 19117) | function Element(node, path, wrap, ref) {
function Controller (line 19124) | function Controller() { }
function addToPath (line 19131) | function addToPath(result, path) {
function traverse (line 19421) | function traverse(root, visitor) {
function replace (line 19426) | function replace(root, visitor) {
function extendCommentRange (line 19431) | function extendCommentRange(comment, tokens) {
function attachComments (line 19452) | function attachComments(tree, providedComments, tokens) {
function assert (line 19823) | function assert(condition, message) {
function isDecimalDigit (line 19829) | function isDecimalDigit(ch) {
function isHexDigit (line 19833) | function isHexDigit(ch) {
function isOctalDigit (line 19837) | function isOctalDigit(ch) {
function isWhiteSpace (line 19844) | function isWhiteSpace(ch) {
function isLineTerminator (line 19855) | function isLineTerminator(ch) {
function isIdentifierStart (line 19861) | function isIdentifierStart(ch) {
function isIdentifierPart (line 19869) | function isIdentifierPart(ch) {
function isFutureReservedWord (line 19880) | function isFutureReservedWord(id) {
function isStrictModeReservedWord (line 19894) | function isStrictModeReservedWord(id) {
function isRestrictedWord (line 19911) | function isRestrictedWord(id) {
function isKeyword (line 19917) | function isKeyword(id) {
function skipComment (line 19955) | function skipComment() {
function scanHexEscape (line 20030) | function scanHexEscape(prefix) {
function scanUnicodeCodePointEscape (line 20045) | function scanUnicodeCodePointEscape() {
function getEscapedIdentifier (line 20077) | function getEscapedIdentifier() {
function getIdentifier (line 20122) | function getIdentifier() {
function scanIdentifier (line 20143) | function scanIdentifier() {
function scanPunctuator (line 20177) | function scanPunctuator() {
function scanHexLiteral (line 20380) | function scanHexLiteral(start) {
function scanOctalLiteral (line 20407) | function scanOctalLiteral(prefix, start) {
function scanNumericLiteral (line 20445) | function scanNumericLiteral() {
function scanStringLiteral (line 20552) | function scanStringLiteral() {
function scanTemplate (line 20661) | function scanTemplate() {
function scanTemplateElement (line 20784) | function scanTemplateElement(option) {
function scanRegExp (line 20803) | function scanRegExp() {
function isIdentifierName (line 20905) | function isIdentifierName(token) {
function advanceSlash (line 20912) | function advanceSlash() {
function advance (line 20972) | function advance() {
function lex (line 21026) | function lex() {
function peek (line 21043) | function peek() {
function lookahead2 (line 21055) | function lookahead2() {
function peekLineTerminator (line 21570) | function peekLineTerminator() {
function throwError (line 21587) | function throwError(token, messageFormat) {
function throwErrorTolerant (line 21614) | function throwErrorTolerant() {
function throwUnexpected (line 21629) | function throwUnexpected(token) {
function expect (line 21667) | function expect(value) {
function expectKeyword (line 21677) | function expectKeyword(keyword) {
function match (line 21686) | function match(value) {
function matchKeyword (line 21692) | function matchKeyword(keyword) {
function matchContextualKeyword (line 21699) | function matchContextualKeyword(keyword) {
function matchAssign (line 21705) | function matchAssign() {
function consumeSemicolon (line 21726) | function consumeSemicolon() {
function isLeftHandSide (line 21753) | function isLeftHandSide(expr) {
function isAssignableLeftHandSide (line 21757) | function isAssignableLeftHandSide(expr) {
function parseArrayInitialiser (line 21763) | function parseArrayInitialiser() {
function parsePropertyFunction (line 21831) | function parsePropertyFunction(options) {
function parsePropertyMethodFunction (line 21854) | function parsePropertyMethodFunction(options) {
function parseObjectPropertyKey (line 21880) | function parseObjectPropertyKey() {
function parseObjectProperty (line 21896) | function parseObjectProperty() {
function parseObjectInitialiser (line 21955) | function parseObjectInitialiser() {
function parseTemplateElement (line 22002) | function parseTemplateElement(option) {
function parseTemplateLiteral (line 22010) | function parseTemplateLiteral() {
function parseGroupExpression (line 22028) | function parseGroupExpression() {
function parsePrimaryExpression (line 22045) | function parsePrimaryExpression() {
function parseArguments (line 22120) | function parseArguments() {
function parseSpreadOrAssignmentExpression (line 22145) | function parseSpreadOrAssignmentExpression() {
function parseNonComputedProperty (line 22153) | function parseNonComputedProperty() {
function parseNonComputedMember (line 22163) | function parseNonComputedMember() {
function parseComputedMember (line 22169) | function parseComputedMember() {
function parseNewExpression (line 22181) | function parseNewExpression() {
function parseLeftHandSideExpressionAllowCall (line 22191) | function parseLeftHandSideExpressionAllowCall() {
function parseLeftHandSideExpression (line 22213) | function parseLeftHandSideExpression() {
function parsePostfixExpression (line 22233) | function parsePostfixExpression() {
function parseUnaryExpression (line 22260) | function parseUnaryExpression() {
function binaryPrecedence (line 22301) | function binaryPrecedence(token, allowIn) {
function parseBinaryExpression (line 22380) | function parseBinaryExpression() {
function parseConditionalExpression (line 22430) | function parseConditionalExpression() {
function reinterpretAsAssignmentBindingPattern (line 22452) | function reinterpretAsAssignmentBindingPattern(expr) {
function reinterpretAsDestructuredParameter (line 22489) | function reinterpretAsDestructuredParameter(options, expr) {
function reinterpretAsCoverFormalsList (line 22518) | function reinterpretAsCoverFormalsList(expressions) {
function parseArrowFunctionExpression (line 22574) | function parseArrowFunctionExpression(options) {
function parseAssignmentExpression (line 22597) | function parseAssignmentExpression() {
function parseExpression (line 22654) | function parseExpression() {
function parseStatementList (line 22705) | function parseStatementList() {
function parseBlock (line 22723) | function parseBlock() {
function parseVariableIdentifier (line 22737) | function parseVariableIdentifier() {
function parseVariableDeclaration (line 22747) | function parseVariableDeclaration(kind) {
function parseVariableDeclarationList (line 22778) | function parseVariableDeclarationList(kind) {
function parseVariableStatement (line 22792) | function parseVariableStatement() {
function parseConstLetDeclaration (line 22808) | function parseConstLetDeclaration(kind) {
function parseModuleDeclaration (line 22822) | function parseModuleDeclaration() {
function parseExportBatchSpecifier (line 22857) | function parseExportBatchSpecifier() {
function parseExportSpecifier (line 22862) | function parseExportSpecifier() {
function parseExportDeclaration (line 22874) | function parseExportDeclaration() {
function parseImportDeclaration (line 22924) | function parseImportDeclaration() {
function parseImportSpecifier (line 22962) | function parseImportSpecifier() {
function parseEmptyStatement (line 22976) | function parseEmptyStatement() {
function parseExpressionStatement (line 22983) | function parseExpressionStatement() {
function parseIfStatement (line 22991) | function parseIfStatement() {
function parseDoWhileStatement (line 23016) | function parseDoWhileStatement() {
function parseWhileStatement (line 23043) | function parseWhileStatement() {
function parseForVariableDeclaration (line 23064) | function parseForVariableDeclaration() {
function parseForStatement (line 23071) | function parseForStatement(opts) {
function parseContinueStatement (line 23164) | function parseContinueStatement() {
function parseBreakStatement (line 23208) | function parseBreakStatement() {
function parseReturnStatement (line 23252) | function parseReturnStatement() {
function parseWithStatement (line 23287) | function parseWithStatement() {
function parseSwitchCase (line 23309) | function parseSwitchCase() {
function parseSwitchStatement (line 23337) | function parseSwitchStatement() {
function parseThrowStatement (line 23384) | function parseThrowStatement() {
function parseCatchClause (line 23402) | function parseCatchClause() {
function parseTryStatement (line 23423) | function parseTryStatement() {
function parseDebuggerStatement (line 23448) | function parseDebuggerStatement() {
function parseStatement (line 23458) | function parseStatement() {
function parseConciseBody (line 23542) | function parseConciseBody() {
function parseFunctionSourceElements (line 23549) | function parseFunctionSourceElements() {
function validateParam (line 23614) | function validateParam(options, param, name) {
function parseParam (line 23640) | function parseParam(options) {
function parseParams (line 23684) | function parseParams(firstRestricted) {
function parseFunctionDeclaration (line 23716) | function parseFunctionDeclaration() {
function parseFunctionExpression (line 23772) | function parseFunctionExpression() {
function parseYieldExpression (line 23829) | function parseYieldExpression() {
function parseMethodDefinition (line 23852) | function parseMethodDefinition(existingPropNames) {
function parseClassElement (line 23955) | function parseClassElement(existingProps) {
function parseClassBody (line 23963) | function parseClassBody() {
function parseClassExpression (line 23987) | function parseClassExpression() {
function parseClassDeclaration (line 24007) | function parseClassDeclaration() {
function matchModuleDeclaration (line 24027) | function matchModuleDeclaration() {
function parseSourceElement (line 24036) | function parseSourceElement() {
function parseProgramElement (line 24062) | function parseProgramElement() {
function parseProgramElements (line 24079) | function parseProgramElements() {
function parseModuleElement (line 24117) | function parseModuleElement() {
function parseModuleElements (line 24121) | function parseModuleElements() {
function parseModuleBlock (line 24139) | function parseModuleBlock() {
function parseProgram (line 24151) | function parseProgram() {
function addComment (line 24162) | function addComment(type, value, start, end, loc) {
function scanComment (line 24183) | function scanComment() {
function filterCommentLocation (line 24305) | function filterCommentLocation() {
function collectToken (line 24326) | function collectToken() {
function collectRegex (line 24358) | function collectRegex() {
function filterTokenLocation (line 24399) | function filterTokenLocation() {
function LocationMarker (line 24420) | function LocationMarker() {
function createLocationMarker (line 24487) | function createLocationMarker() {
function trackGroupExpression (line 24491) | function trackGroupExpression() {
function trackLeftHandSideExpression (line 24508) | function trackLeftHandSideExpression() {
function trackLeftHandSideExpressionAllowCall (line 24535) | function trackLeftHandSideExpressionAllowCall() {
function filterGroup (line 24567) | function filterGroup(node) {
function wrapTrackingFunction (line 24584) | function wrapTrackingFunction(range, loc) {
function patch (line 24659) | function patch() {
function unpatch (line 24776) | function unpatch() {
function extend (line 24836) | function extend(object, properties) {
function tokenize (line 24854) | function tokenize(code, options) {
function parse (line 24957) | function parse(code, options) {
function getline (line 25100) | function getline(node) {
function isConstLet (line 25104) | function isConstLet(kind) {
function isVarConstLet (line 25108) | function isVarConstLet(kind) {
function isNonFunctionBlock (line 25112) | function isNonFunctionBlock(node) {
function isForWithConstLet (line 25116) | function isForWithConstLet(node) {
function isForInWithConstLet (line 25120) | function isForInWithConstLet(node) {
function isFunction (line 25124) | function isFunction(node) {
function isLoop (line 25128) | function isLoop(node) {
function isReference (line 25132) | function isReference(node) {
function isLvalue (line 25146) | function isLvalue(node) {
function createScopes (line 25152) | function createScopes(node, parent) {
function createTopScope (line 25248) | function createTopScope(programScope, environments, globals) {
function setupReferences (line 25295) | function setupReferences(ast, allIdentifiers, opts) {
function varify (line 25329) | function varify(ast, stats, allIdentifiers, changes) {
function detectLoopClosures (line 25443) | function detectLoopClosures(ast) {
function transformLoopClosures (line 25546) | function transformLoopClosures(root, ops, options) {
function detectConstAssignment (line 25611) | function detectConstAssignment(ast) {
function detectConstantLets (line 25622) | function detectConstantLets(ast) {
function setupScopeAndReferences (line 25635) | function setupScopeAndReferences(root, opts) {
function cleanupTree (line 25653) | function cleanupTree(root) {
function run (line 25663) | function run(src, config) {
function fmt (line 25837) | function fmt(str, var_args) {
function obj (line 25844) | function obj(str, obj) {
function repeat (line 25850) | function repeat(str, n) {
function hasOwnEnumerableProps (line 25880) | function hasOwnEnumerableProps(obj) {
function hasOwnPollutedProps (line 25891) | function hasOwnPollutedProps(obj) {
function stringmap (line 25929) | function stringmap(optional_object) {
function hasOwnEnumerableProps (line 26130) | function hasOwnEnumerableProps(obj) {
function hasOwnPollutedProps (line 26142) | function hasOwnPollutedProps(obj) {
function stringset (line 26180) | function stringset(optional_array) {
function alter (line 26314) | function alter(str, fragments) {
function exec (line 26383) | function exec(arr, comp) {
function traverse (line 26474) | function traverse(root, options) {
function Val (line 26534) | function Val(val) {
function brk (line 26538) | function brk(val) {
function breakable (line 26542) | function breakable(fn) {
function Scope (line 26579) | function Scope(args) {
function isConstLet (line 26644) | function isConstLet(kind) {
function isFunction (line 26719) | function isFunction(node) {
function detect (line 26755) | function detect(scope) {
function visit (line 26776) | function visit(scope) {
function error (line 26803) | function error(line, var_args) {
function assert (line 27027) | function assert(condition, message) {
function sliceSource (line 27033) | function sliceSource(from, to) {
function isDecimalDigit (line 27043) | function isDecimalDigit(ch) {
function isHexDigit (line 27047) | function isHexDigit(ch) {
function isOctalDigit (line 27051) | function isOctalDigit(ch) {
function isWhiteSpace (line 27058) | function isWhiteSpace(ch) {
function isLineTerminator (line 27067) | function isLineTerminator(ch) {
function isIdentifierStart (line 27073) | function isIdentifierStart(ch) {
function isIdentifierPart (line 27079) | function isIdentifierPart(ch) {
function isFutureReservedWord (line 27088) | function isFutureReservedWord(id) {
function isStrictModeReservedWord (line 27104) | function isStrictModeReservedWord(id) {
function isRestrictedWord (line 27123) | function isRestrictedWord(id) {
function isKeyword (line 27129) | function isKeyword(id) {
function skipComment (line 27183) | function skipComment() {
function scanHexEscape (line 27255) | function scanHexEscape(prefix) {
function scanIdentifier (line 27270) | function scanIdentifier() {
function scanPunctuator (line 27384) | function scanPunctuator() {
function scanNumericLiteral (line 27550) | function scanNumericLiteral() {
function scanStringLiteral (line 27691) | function scanStringLiteral() {
function scanRegExp (line 27795) | function scanRegExp() {
function isIdentifierName (line 27886) | function isIdentifierName(token) {
function advance (line 27893) | function advance() {
function lex (line 27930) | function lex() {
function lookahead (line 27946) | function lookahead() {
function peekLineTerminator (line 27966) | function peekLineTerminator() {
function throwError (line 27983) | function throwError(token, messageFormat) {
function throwErrorTolerant (line 28008) | function throwErrorTolerant() {
function throwUnexpected (line 28023) | function throwUnexpected(token) {
function expect (line 28057) | function expect(value) {
function expectKeyword (line 28067) | function expectKeyword(keyword) {
function match (line 28076) | function match(value) {
function matchKeyword (line 28083) | function matchKeyword(keyword) {
function matchAssign (line 28090) | function matchAssign() {
function consumeSemicolon (line 28111) | function consumeSemicolon() {
function isLeftHandSide (line 28139) | function isLeftHandSide(expr) {
function parseArrayInitialiser (line 28145) | function parseArrayInitialiser() {
function parsePropertyFunction (line 28173) | function parsePropertyFunction(param, first) {
function parseObjectPropertyKey (line 28195) | function parseObjectPropertyKey() {
function parseObjectProperty (line 28214) | function parseObjectProperty() {
function parseObjectInitialiser (line 28281) | function parseObjectInitialiser() {
function parseGroupExpression (line 28331) | function parseGroupExpression() {
function parsePrimaryExpression (line 28346) | function parsePrimaryExpression() {
function parseArguments (line 28410) | function parseArguments() {
function parseNonComputedProperty (line 28430) | function parseNonComputedProperty() {
function parseNonComputedMember (line 28443) | function parseNonComputedMember() {
function parseComputedMember (line 28449) | function parseComputedMember() {
function parseNewExpression (line 28461) | function parseNewExpression() {
function parseLeftHandSideExpressionAllowCall (line 28479) | function parseLeftHandSideExpressionAllowCall() {
function parseLeftHandSideExpression (line 28512) | function parseLeftHandSideExpression() {
function parsePostfixExpression (line 28540) | function parsePostfixExpression() {
function parseUnaryExpression (line 28570) | function parseUnaryExpression() {
function parseMultiplicativeExpression (line 28627) | function parseMultiplicativeExpression() {
function parseAdditiveExpression (line 28644) | function parseAdditiveExpression() {
function parseShiftExpression (line 28661) | function parseShiftExpression() {
function parseRelationalExpression (line 28677) | function parseRelationalExpression() {
function parseEqualityExpression (line 28700) | function parseEqualityExpression() {
function parseBitwiseANDExpression (line 28717) | function parseBitwiseANDExpression() {
function parseBitwiseXORExpression (line 28733) | function parseBitwiseXORExpression() {
function parseBitwiseORExpression (line 28749) | function parseBitwiseORExpression() {
function parseLogicalANDExpression (line 28767) | function parseLogicalANDExpression() {
function parseLogicalORExpression (line 28783) | function parseLogicalORExpression() {
function parseConditionalExpression (line 28801) | function parseConditionalExpression() {
function parseAssignmentExpression (line 28827) | function parseAssignmentExpression() {
function parseExpression (line 28857) | function parseExpression() {
function parseStatementList (line 28880) | function parseStatementList() {
function parseBlock (line 28898) | function parseBlock() {
function parseVariableIdentifier (line 28915) | function parseVariableIdentifier() {
function parseVariableDeclaration (line 28928) | function parseVariableDeclaration(kind) {
function parseVariableDeclarationList (line 28952) | function parseVariableDeclarationList(kind) {
function parseVariableStatement (line 28966) | function parseVariableStatement() {
function parseConstLetDeclaration (line 28986) | function parseConstLetDeclaration(kind) {
function parseEmptyStatement (line 29004) | function parseEmptyStatement() {
function parseExpressionStatement (line 29014) | function parseExpressionStatement() {
function parseIfStatement (line 29027) | function parseIfStatement() {
function parseDoWhileStatement (line 29057) | function parseDoWhileStatement() {
function parseWhileStatement (line 29088) | function parseWhileStatement() {
function parseForVariableDeclaration (line 29113) | function parseForVariableDeclaration() {
function parseForStatement (line 29123) | function parseForStatement() {
function parseContinueStatement (line 29211) | function parseContinueStatement() {
function parseBreakStatement (line 29264) | function parseBreakStatement() {
function parseReturnStatement (line 29317) | function parseReturnStatement() {
function parseWithStatement (line 29362) | function parseWithStatement() {
function parseSwitchCase (line 29388) | function parseSwitchCase() {
function parseSwitchStatement (line 29420) | function parseSwitchStatement() {
function parseThrowStatement (line 29475) | function parseThrowStatement() {
function parseCatchClause (line 29496) | function parseCatchClause() {
function parseTryStatement (line 29521) | function parseTryStatement() {
function parseDebuggerStatement (line 29552) | function parseDebuggerStatement() {
function parseStatement (line 29564) | function parseStatement() {
function parseFunctionSourceElements (line 29652) | function parseFunctionSourceElements() {
function parseFunctionDeclaration (line 29717) | function parseFunctionDeclaration() {
function parseFunctionExpression (line 29798) | function parseFunctionExpression() {
function parseSourceElement (line 29884) | function parseSourceElement() {
function parseSourceElements (line 29904) | function parseSourceElements() {
function parseProgram (line 29942) | function parseProgram() {
function addComment (line 29955) | function addComment(type, value, start, end, loc) {
function scanComment (line 29976) | function scanComment() {
function filterCommentLocation (line 30098) | function filterCommentLocation() {
function collectToken (line 30119) | function collectToken() {
function collectRegex (line 30151) | function collectRegex() {
function filterTokenLocation (line 30190) | function filterTokenLocation() {
function createLiteral (line 30211) | function createLiteral(token) {
function createRawLiteral (line 30218) | function createRawLiteral(token) {
function createLocationMarker (line 30226) | function createLocationMarker() {
function trackGroupExpression (line 30286) | function trackGroupExpression() {
function trackLeftHandSideExpression (line 30303) | function trackLeftHandSideExpression() {
function trackLeftHandSideExpressionAllowCall (line 30336) | function trackLeftHandSideExpressionAllowCall() {
function filterGroup (line 30377) | function filterGroup(node) {
function wrapTrackingFunction (line 30394) | function wrapTrackingFunction(range, loc) {
function patch (line 30467) | function patch() {
function unpatch (line 30573) | function unpatch() {
function stringToArray (line 30628) | function stringToArray(str) {
function parse (line 30638) | function parse(code, options) {
function Stats (line 30757) | function Stats() {
function Machine (line 31236) | function Machine() {
function Frame (line 31880) | function Frame(machineId, name, fn, next, state, scope,
function DebugInfo (line 32004) | function DebugInfo(data) {
function ContinuationExc (line 32074) | function ContinuationExc(error, initialFrame, savedFrames) {
function CodeMirror (line 32162) | function CodeMirror(place, options) {
function Display (line 32237) | function Display(place, doc, input) {
function loadMode (line 32339) | function loadMode(cm) {
function resetModeState (line 32344) | function resetModeState(cm) {
function wrappingChanged (line 32355) | function wrappingChanged(cm) {
function estimateHeight (line 32373) | function estimateHeight(cm) {
function estimateLineHeights (line 32391) | function estimateLineHeights(cm) {
function themeChanged (line 32399) | function themeChanged(cm) {
function guttersChanged (line 32405) | function guttersChanged(cm) {
function updateGutters (line 32413) | function updateGutters(cm) {
function updateGutterSpace (line 32428) | function updateGutterSpace(cm) {
function lineLength (line 32436) | function lineLength(line) {
function findMaxLine (line 32455) | function findMaxLine(cm) {
function setGuttersForLineNumbers (line 32471) | function setGuttersForLineNumbers(options) {
function measureForScrollbars (line 32485) | function measureForScrollbars(cm) {
function NativeScrollbars (line 32501) | function NativeScrollbars(place, scroll, cm) {
function maybeDisable (line 32573) | function maybeDisable() {
function NullScrollbars (line 32594) | function NullScrollbars() {}
function initScrollbars (line 32605) | function initScrollbars(cm) {
function updateScrollbars (line 32627) | function updateScrollbars(cm, measure) {
function updateScrollbarsInner (line 32641) | function updateScrollbarsInner(cm, measure) {
function visibleLines (line 32664) | function visibleLines(display, doc, viewport) {
function alignHorizontally (line 32689) | function alignHorizontally(cm) {
function maybeUpdateLineNumberWidth (line 32708) | function maybeUpdateLineNumberWidth(cm) {
function lineNumberFor (line 32726) | function lineNumberFor(options, i) {
function compensateForHScroll (line 32733) | function compensateForHScroll(display) {
function DisplayUpdate (line 32739) | function DisplayUpdate(cm, viewport, force) {
function maybeClipScrollbars (line 32763) | function maybeClipScrollbars(cm) {
function updateDisplayIfNeeded (line 32777) | function updateDisplayIfNeeded(cm, update) {
function postUpdateDisplay (line 32849) | function postUpdateDisplay(cm, update) {
function updateDisplaySimple (line 32878) | function updateDisplaySimple(cm, viewport) {
function setDocumentHeight (line 32891) | function setDocumentHeight(cm, measure) {
function updateHeightsInViewport (line 32899) | function updateHeightsInViewport(cm) {
function updateWidgetHeight (line 32926) | function updateWidgetHeight(line) {
function getDimensions (line 32933) | function getDimensions(cm) {
function patchDisplay (line 32951) | function patchDisplay(cm, updateNumbersFrom, dims) {
function updateLineForChanges (line 32996) | function updateLineForChanges(cm, lineView, lineN, dims) {
function ensureLineWrapped (line 33009) | function ensureLineWrapped(lineView) {
function updateLineBackground (line 33020) | function updateLineBackground(lineView) {
function getLineContent (line 33034) | function getLineContent(cm, lineView) {
function updateLineText (line 33047) | function updateLineText(cm, lineView) {
function updateLineClasses (line 33062) | function updateLineClasses(lineView) {
function updateLineGutter (line 33072) | function updateLineGutter(cm, lineView, lineN, dims) {
function updateLineWidgets (line 33112) | function updateLineWidgets(cm, lineView, dims) {
function buildLineElement (line 33123) | function buildLineElement(cm, lineView, lineN, dims) {
function insertLineWidgets (line 33137) | function insertLineWidgets(cm, lineView, dims) {
function insertLineWidgetsFor (line 33143) | function insertLineWidgetsFor(cm, line, lineView, dims, allowAbove) {
function positionLineWidget (line 33159) | function positionLineWidget(widget, node, lineView, dims) {
function copyPos (line 33189) | function copyPos(x) {return Pos(x.line, x.ch);}
function maxPos (line 33190) | function maxPos(a, b) { return cmp(a, b) < 0 ? b : a; }
function minPos (line 33191) | function minPos(a, b) { return cmp(a, b) < 0 ? a : b; }
function ensureFocus (line 33195) | function ensureFocus(cm) {
function applyTextInput (line 33204) | function applyTextInput(cm, inserted, deleted, sel, origin) {
function handlePaste (line 33249) | function handlePaste(e, cm) {
function triggerElectric (line 33259) | function triggerElectric(cm, inserted) {
function copyableRanges (line 33283) | function copyableRanges(cm) {
function disableBrowserMagic (line 33294) | function disableBrowserMagic(field) {
function TextareaInput (line 33302) | function TextareaInput(cm) {
function hiddenTextarea (line 33321) | function hiddenTextarea() {
function prepareCopyCut (line 33362) | function prepareCopyCut(e) {
function p (line 33503) | function p() {
function prepareSelectAllHack (line 33607) | function prepareSelectAllHack() {
function rehide (line 33620) | function rehide() {
function ContentEditableInput (line 33664) | function ContentEditableInput(cm) {
function onCopyCut (line 33721) | function onCopyCut(e) {
function poll (line 33854) | function poll() {
function posToDOM (line 33974) | function posToDOM(cm, pos) {
function badPos (line 33990) | function badPos(pos, bad) { if (bad) pos.bad = true; return pos; }
function domToPos (line 33992) | function domToPos(cm, node, offset) {
function locateNodeInLineView (line 34011) | function locateNodeInLineView(lineView, node, offset) {
function domTextBetween (line 34066) | function domTextBetween(cm, from, to, fromLine, toLine) {
function Selection (line 34116) | function Selection(ranges, primIndex) {
function Range (line 34153) | function Range(anchor, head) {
function normalizeSelection (line 34168) | function normalizeSelection(ranges, primIndex) {
function simpleSelection (line 34184) | function simpleSelection(anchor, head) {
function clipLine (line 34190) | function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.fi...
function clipPos (line 34191) | function clipPos(doc, pos) {
function clipToLen (line 34197) | function clipToLen(pos, linelen) {
function isLine (line 34203) | function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.si...
function clipPosArray (line 34204) | function clipPosArray(doc, array) {
function extendRange (line 34219) | function extendRange(doc, range, head, other) {
function extendSelection (line 34238) | function extendSelection(doc, head, other, options) {
function extendSelections (line 34244) | function extendSelections(doc, heads, options) {
function replaceOneSelection (line 34252) | function replaceOneSelection(doc, i, range, options) {
function setSimpleSelection (line 34259) | function setSimpleSelection(doc, anchor, head, options) {
function filterSelectionChange (line 34265) | function filterSelectionChange(doc, sel, options) {
function setSelectionReplaceHistory (line 34282) | function setSelectionReplaceHistory(doc, sel, options) {
function setSelection (line 34293) | function setSelection(doc, sel, options) {
function setSelectionNoUndo (line 34298) | function setSelectionNoUndo(doc, sel, options) {
function setSelectionInner (line 34310) | function setSelectionInner(doc, sel) {
function reCheckSelection (line 34324) | function reCheckSelection(doc) {
function skipAtomicInSelection (line 34330) | function skipAtomicInSelection(doc, sel, bias, mayClear) {
function skipAtomicInner (line 34345) | function skipAtomicInner(doc, pos, oldPos, dir, mayClear) {
function skipAtomic (line 34378) | function skipAtomic(doc, pos, oldPos, bias, mayClear) {
function movePos (line 34391) | function movePos(doc, pos, dir, line) {
function updateSelection (line 34405) | function updateSelection(cm) {
function prepareSelection (line 34409) | function prepareSelection(cm, primary) {
function drawSelectionCursor (line 34428) | function drawSelectionCursor(cm, head, output) {
function drawSelectionRange (line 34447) | function drawSelectionRange(cm, range, output) {
function restartBlink (line 34522) | function restartBlink(cm) {
function startWorker (line 34538) | function startWorker(cm, time) {
function highlightWorker (line 34543) | function highlightWorker(cm) {
function findStartLine (line 34586) | function findStartLine(cm, n, precise) {
function getStateBefore (line 34602) | function getStateBefore(cm, n, precise) {
function paddingTop (line 34620) | function paddingTop(display) {return display.lineSpace.offsetTop;}
function paddingVert (line 34621) | function paddingVert(display) {return display.mover.offsetHeight - displ...
function paddingH (line 34622) | function paddingH(display) {
function scrollGap (line 34631) | function scrollGap(cm) { return scrollerGap - cm.display.nativeBarWidth; }
function displayWidth (line 34632) | function displayWidth(cm) {
function displayHeight (line 34635) | function displayHeight(cm) {
function ensureLineHeights (line 34643) | function ensureLineHeights(cm, lineView, rect) {
function mapFromLineView (line 34664) | function mapFromLineView(lineView, line, lineN) {
function updateExternalMeasurement (line 34677) | function updateExternalMeasurement(cm, line) {
function measureChar (line 34690) | function measureChar(cm, line, ch, bias) {
function findViewForLine (line 34695) | function findViewForLine(cm, lineN) {
function prepareMeasureForLine (line 34708) | function prepareMeasureForLine(cm, line) {
function measureCharPrepared (line 34730) | function measureCharPrepared(cm, prepared, ch, bias, varHeight) {
function nodeAndOffsetInLineMap (line 34752) | function nodeAndOffsetInLineMap(map, ch, bias) {
function measureCharInner (line 34789) | function measureCharInner(cm, prepared, ch, bias) {
function maybeUpdateRectForZooming (line 34848) | function maybeUpdateRectForZooming(measure, rect) {
function clearLineMeasurementCacheFor (line 34858) | function clearLineMeasurementCacheFor(lineView) {
function clearLineMeasurementCache (line 34867) | function clearLineMeasurementCache(cm) {
function clearCaches (line 34874) | function clearCaches(cm) {
function pageScrollX (line 34881) | function pageScrollX() { return window.pageXOffset || (document.document...
function pageScrollY (line 34882) | function pageScrollY() { return window.pageYOffset || (document.document...
function intoCoordSystem (line 34888) | function intoCoordSystem(cm, lineObj, rect, context) {
function fromCoordSystem (line 34910) | function fromCoordSystem(cm, coords, context) {
function charCoords (line 34927) | function charCoords(cm, pos, context, lineObj, bias) {
function cursorCoords (line 34935) | function cursorCoords(cm, pos, context, lineObj, preparedMeasure, varHei...
function estimateCoords (line 34967) | function estimateCoords(cm, pos) {
function PosWithInfo (line 34981) | function PosWithInfo(line, ch, outside, xRel) {
function coordsChar (line 34990) | function coordsChar(cm, x, y) {
function coordsCharInner (line 35011) | function coordsCharInner(cm, lineObj, lineNo, x, y) {
function textHeight (line 35053) | function textHeight(display) {
function charWidth (line 35073) | function charWidth(display) {
function startOperation (line 35095) | function startOperation(cm) {
function fireCallbacksForOps (line 35123) | function fireCallbacksForOps(group) {
function endOperation (line 35140) | function endOperation(cm) {
function endOperations (line 35155) | function endOperations(group) {
function endOperation_R1 (line 35169) | function endOperation_R1(op) {
function endOperation_W1 (line 35182) | function endOperation_W1(op) {
function endOperation_R2 (line 35186) | function endOperation_R2(op) {
function endOperation_W2 (line 35207) | function endOperation_W2(op) {
function endOperation_finish (line 35232) | function endOperation_finish(op) {
function runInOp (line 35279) | function runInOp(cm, f) {
function operation (line 35286) | function operation(cm, f) {
function methodOp (line 35296) | function methodOp(f) {
function docMethodOp (line 35304) | function docMethodOp(f) {
function LineView (line 35319) | function LineView(doc, line, lineN) {
function buildViewArray (line 35331) | function buildViewArray(cm, from, to) {
function regChange (line 35347) | function regChange(cm, from, to, lendiff) {
function regLineChange (line 35412) | function regLineChange(cm, line, type) {
function resetView (line 35426) | function resetView(cm) {
function findViewIndex (line 35434) | function findViewIndex(cm, n) {
function viewCuttingPoint (line 35445) | function viewCuttingPoint(cm, oldN, newN, dir) {
function adjustView (line 35471) | function adjustView(cm, from, to) {
function countDirtyView (line 35492) | function countDirtyView(cm) {
function registerEventHandlers (line 35504) | function registerEventHandlers(cm) {
function dragDropChanged (line 35610) | function dragDropChanged(cm, value, old) {
function onResize (line 35624) | function onResize(cm) {
function eventInWidget (line 35637) | function eventInWidget(display, e) {
function posFromMouse (line 35650) | function posFromMouse(cm, e, liberal, forRect) {
function onMouseDown (line 35671) | function onMouseDown(e) {
function leftButtonDown (line 35713) | function leftButtonDown(cm, e, start) {
function leftButtonStartDrag (line 35740) | function leftButtonStartDrag(cm, e, start, modifier) {
function leftButtonSelect (line 35768) | function leftButtonSelect(cm, e, start, type, addNew) {
function gutterEvent (line 35914) | function gutterEvent(cm, e, type, prevent) {
function clickInGutter (line 35937) | function clickInGutter(cm, e) {
function onDrop (line 35945) | function onDrop(e) {
function onDragStart (line 36004) | function onDragStart(cm, e) {
function onDragOver (line 36027) | function onDragOver(cm, e) {
function clearDragCursor (line 36039) | function clearDragCursor(cm) {
function setScrollTop (line 36050) | function setScrollTop(cm, val) {
function setScrollLeft (line 36061) | function setScrollLeft(cm, val, isScroller) {
function onScrollWheel (line 36105) | function onScrollWheel(cm, e) {
function doHandleBinding (line 36183) | function doHandleBinding(cm, bound, dropShift) {
function lookupKeyForEditor (line 36203) | function lookupKeyForEditor(cm, name, handle) {
function dispatchKey (line 36213) | function dispatchKey(cm, name, e, handle) {
function handleKeyBinding (line 36245) | function handleKeyBinding(cm, e) {
function handleCharBinding (line 36264) | function handleCharBinding(cm, e, ch) {
function onKeyDown (line 36270) | function onKeyDown(e) {
function showCrossHair (line 36291) | function showCrossHair(cm) {
function onKeyUp (line 36306) | function onKeyUp(e) {
function onKeyPress (line 36311) | function onKeyPress(e) {
function delayBlurEvent (line 36324) | function delayBlurEvent(cm) {
function onFocus (line 36334) | function onFocus(cm) {
function onBlur (line 36353) | function onBlur(cm) {
function onContextMenu (line 36370) | function onContextMenu(cm, e) {
function contextMenuInGutter (line 36376) | function contextMenuInGutter(cm, e) {
function adjustForChange (line 36393) | function adjustForChange(pos, change) {
function computeSelAfterChange (line 36402) | function computeSelAfterChange(doc, change) {
function offsetPos (line 36412) | function offsetPos(pos, old, nw) {
function computeReplacedSel (line 36421) | function computeReplacedSel(doc, changes, hint) {
function filterChange (line 36441) | function filterChange(doc, change, update) {
function makeChange (line 36465) | function makeChange(doc, change, ignoreReadOnly) {
function makeChangeInner (line 36487) | function makeChangeInner(doc, change) {
function makeChangeFromHistory (line 36505) | function makeChangeFromHistory(doc, type, allowSelectionOnly) {
function shiftDoc (line 36571) | function shiftDoc(doc, distance) {
function makeChangeSingleDoc (line 36587) | function makeChangeSingleDoc(doc, change, selAfter, spans) {
function makeChangeSingleDocInEditor (line 36620) | function makeChangeSingleDocInEditor(cm, change, spans) {
function replaceRange (line 36679) | function replaceRange(doc, code, from, to, origin) {
function maybeScrollWindow (line 36690) | function maybeScrollWindow(cm, coords) {
function scrollPosIntoView (line 36710) | function scrollPosIntoView(cm, pos, end, margin) {
function scrollIntoView (line 36734) | function scrollIntoView(cm, x1, y1, x2, y2) {
function calculateScrollPos (line 36744) | function calculateScrollPos(cm, x1, y1, x2, y2) {
function addToScrollPos (line 36774) | function addToScrollPos(cm, left, top) {
function ensureCursorVisible (line 36784) | function ensureCursorVisible(cm) {
function resolveScrollToPos (line 36798) | function resolveScrollToPos(cm) {
function indentLine (line 36818) | function indentLine(cm, n, how, aggressive) {
function changeLine (line 36880) | function changeLine(doc, handle, changeType, op) {
function deleteNearSelection (line 36891) | function deleteNearSelection(cm, compute) {
function findPosH (line 36923) | function findPosH(doc, pos, dir, unit, visually) {
function findPosV (line 36975) | function findPosV(cm, pos, dir, unit) {
function interpret (line 37396) | function interpret(val) {
function option (line 37452) | function option(name, deflt, handle, notOnInit) {
function normalizeKeyName (line 37917) | function normalizeKeyName(name) {
function getKeyMap (line 38003) | function getKeyMap(val) {
function save (line 38024) | function save() {textarea.value = cm.getValue();}
function markText (line 38274) | function markText(doc, from, to, options, type) {
function markTextShared (line 38367) | function markTextShared(doc, from, to, options, type) {
function findSharedMarkers (line 38382) | function findSharedMarkers(doc) {
function copySharedMarkers (line 38387) | function copySharedMarkers(doc, markers) {
function detachSharedMarkers (line 38399) | function detachSharedMarkers(markers) {
function MarkedSpan (line 38415) | function MarkedSpan(marker, from, to) {
function getMarkedSpanFor (line 38421) | function getMarkedSpanFor(spans, marker) {
function removeMarkedSpan (line 38429) | function removeMarkedSpan(spans, span) {
function addMarkedSpan (line 38435) | function addMarkedSpan(line, span) {
function markedSpansBefore (line 38444) | function markedSpansBefore(old, startCh, isInsert) {
function markedSpansAfter (line 38455) | function markedSpansAfter(old, endCh, isInsert) {
function stretchSpansOverChange (line 38474) | function stretchSpansOverChange(doc, change) {
function clearEmptySpans (line 38536) | function clearEmptySpans(spans) {
function mergeOldSpans (line 38550) | function mergeOldSpans(doc, change) {
function removeReadOnlyRanges (line 38573) | function removeReadOnlyRanges(doc, from, to) {
function detachMarkedSpans (line 38602) | function detachMarkedSpans(line) {
function attachMarkedSpans (line 38609) | function attachMarkedSpans(line, spans) {
function extraLeft (line 38618) | function extraLeft(marker) { return marker.inclusiveLeft ? -1 : 0; }
function extraRight (line 38619) | function extraRight(marker) { return marker.inclusiveRight ? 1 : 0; }
function compareCollapsedMarkers (line 38624) | function compareCollapsedMarkers(a, b) {
function collapsedSpanAtSide (line 38637) | function collapsedSpanAtSide(line, start) {
function collapsedSpanAtStart (line 38647) | function collapsedSpanAtStart(line) { return collapsedSpanAtSide(line, t...
function collapsedSpanAtEnd (line 38648) | function collapsedSpanAtEnd(line) { return collapsedSpanAtSide(line, fal...
function conflictingCollapsedRange (line 38653) | function conflictingCollapsedRange(doc, lineNo, from, to, marker) {
function visualLine (line 38673) | function visualLine(line) {
function visualLineContinued (line 38682) | function visualLineContinued(line) {
function visualLineNo (line 38693) | function visualLineNo(doc, lineN) {
function visualLineEndNo (line 38700) | function visualLineEndNo(doc, lineN) {
function lineIsHidden (line 38712) | function lineIsHidden(doc, line) {
function lineIsHiddenInner (line 38723) | function lineIsHiddenInner(doc, line, span) {
function adjustScrollWhenAboveVisible (line 38751) | function adjustScrollWhenAboveVisible(cm, line, diff) {
function widgetHeight (line 38780) | function widgetHeight(widget) {
function addLineWidget (line 38795) | function addLineWidget(doc, handle, node, options) {
function updateLine (line 38830) | function updateLine(line, text, markedSpans, estimateHeight) {
function cleanUpLine (line 38842) | function cleanUpLine(line) {
function extractLineClasses (line 38847) | function extractLineClasses(type, output) {
function callBlankLine (line 38861) | function callBlankLine(mode, state) {
function readToken (line 38868) | function readToken(mode, stream, state, inner) {
function takeToken (line 38878) | function takeToken(cm, pos, precise, asArray) {
function runMode (line 38900) | function runMode(cm, text, mode, state, f, lineClasses, forceToEnd) {
function highlightLine (line 38941) | function highlightLine(cm, line, state, forceToEnd) {
function getLineStyles (line 38979) | function getLineStyles(cm, line, updateFrontier) {
function processLine (line 38995) | function processLine(cm, text, state, startAt) {
function interpretTokenStyle (line 39010) | function interpretTokenStyle(style, options) {
function buildLineContent (line 39022) | function buildLineContent(cm, lineView) {
function defaultSpecialCharPlaceholder (line 39076) | function defaultSpecialCharPlaceholder(ch) {
function buildToken (line 39085) | function buildToken(builder, text, style, startStyle, endStyle, title, c...
function splitSpaces (line 39143) | function splitSpaces(old) {
function buildTokenBadBidi (line 39152) | function buildTokenBadBidi(inner, order) {
function buildCollapsedSpan (line 39171) | function buildCollapsedSpan(builder, size, marker, ignoreWidget) {
function insertLineContent (line 39188) | function insertLineContent(line, builder, styles) {
function isWholeLineUpdate (line 39261) | function isWholeLineUpdate(doc, change) {
function updateDoc (line 39267) | function updateDoc(doc, change, markedSpans, estimateHeight) {
function LeafChunk (line 39330) | function LeafChunk(lines) {
function BranchChunk (line 39370) | function BranchChunk(children) {
function linkedDocs (line 39840) | function linkedDocs(doc, f, sharedHistOnly) {
function attachDoc (line 39855) | function attachDoc(cm, doc) {
function getLine (line 39869) | function getLine(doc, n) {
function getBetween (line 39884) | function getBetween(doc, start, end) {
function getLines (line 39896) | function getLines(doc, from, to) {
function updateLineHeight (line 39904) | function updateLineHeight(line, height) {
function lineNo (line 39911) | function lineNo(line) {
function lineAtHeight (line 39925) | function lineAtHeight(chunk, h) {
function heightAtLine (line 39946) | function heightAtLine(lineObj) {
function getOrder (line 39968) | function getOrder(line) {
function History (line 39976) | function History(startGen) {
function historyChangeFromChange (line 39993) | function historyChangeFromChange(doc, change) {
function clearSelectionEvents (line 40002) | function clearSelectionEvents(array) {
function lastChangeEvent (line 40012) | function lastChangeEvent(hist, force) {
function addChangeToHistory (line 40027) | function addChangeToHistory(doc, change, selAfter, opId) {
function selectionEventCanBeMerged (line 40069) | function selectionEventCanBeMerged(doc, origin, prev, sel) {
function addSelectionToHistory (line 40082) | function addSelectionToHistory(doc, sel, opId, options) {
function pushSelectionToHistory (line 40104) | function pushSelectionToHistory(sel, dest) {
function attachLocalSpans (line 40111) | function attachLocalSpans(doc, change, from, to) {
function removeClearedSpans (line 40122) | function removeClearedSpans(spans) {
function getOldSpans (line 40132) | function getOldSpans(doc, change) {
function copyHistoryArray (line 40142) | function copyHistoryArray(events, newGroup, instantiateSel) {
function rebaseHistSelSingle (line 40167) | function rebaseHistSelSingle(pos, from, to, diff) {
function rebaseHistArray (line 40183) | function rebaseHistArray(array, from, to, diff) {
function rebaseHist (line 40211) | function rebaseHist(hist, change) {
function e_defaultPrevented (line 40230) | function e_defaultPrevented(e) {
function e_target (line 40235) | function e_target(e) {return e.target || e.srcElement;}
function e_button (line 40236) | function e_button(e) {
function getHandlers (line 40265) | function getHandlers(emitter, type, copy) {
function signalLater (line 40299) | function signalLater(emitter, type /*, values...*/) {
function fireOrphanDelayed (line 40316) | function fireOrphanDelayed() {
function signalDOMEvent (line 40325) | function signalDOMEvent(cm, e, override) {
function signalCursorActivity (line 40332) | function signalCursorActivity(cm) {
function hasHandler (line 40340) | function hasHandler(emitter, type) {
function eventMixin (line 40346) | function eventMixin(ctor) {
function Delayed (line 40363) | function Delayed() {this.id = null;}
function spaceStr (line 40403) | function spaceStr(n) {
function lst (line 40409) | function lst(arr) { return arr[arr.length-1]; }
function indexOf (line 40417) | function indexOf(array, elt) {
function map (line 40422) | function map(array, f) {
function nothing (line 40428) | function nothing() {}
function createObj (line 40430) | function createObj(base, props) {
function copyObj (line 40442) | function copyObj(obj, target, overwrite) {
function bind (line 40450) | function bind(f) {
function isWordChar (line 40460) | function isWordChar(ch, helper) {
function isEmpty (line 40466) | function isEmpty(obj) {
function isExtendingChar (line 40477) | function isExtendingChar(ch) { return ch.charCodeAt(0) >= 768 && extendi...
function elt (line 40481) | function elt(tag, content, className, style) {
function removeChildren (line 40507) | function removeChildren(e) {
function removeChildrenAndAdd (line 40513) | function removeChildrenAndAdd(parent, e) {
function activeElt (line 40528) | function activeElt() {
function classTest (line 40541) | function classTest(cls) { return new RegExp("(^|\\s)" + cls + "(?:$|\\s)...
function joinClasses (line 40554) | function joinClasses(a, b) {
function forEachCodeMirror (line 40567) | function forEachCodeMirror(f) {
function ensureGlobalHandlers (line 40577) | function ensureGlobalHandlers() {
function registerGlobalHandlers (line 40582) | function registerGlobalHandlers() {
function zeroWidthElement (line 40609) | function zeroWidthElement(measure) {
function hasBadBidiRects (line 40624) | function hasBadBidiRects(measure) {
function hasBadZoomedRects (line 40671) | function hasBadZoomedRects(measure) {
function iterateBidiSections (line 40702) | function iterateBidiSections(order, from, to, f) {
function bidiLeft (line 40715) | function bidiLeft(part) { return part.level % 2 ? part.to : part.from; }
function bidiRight (line 40716) | function bidiRight(part) { return part.level % 2 ? part.from : part.to; }
function lineLeft (line 40718) | function lineLeft(line) { var order = getOrder(line); return order ? bid...
function lineRight (line 40719) | function lineRight(line) {
function lineStart (line 40725) | function lineStart(cm, lineN) {
function lineEnd (line 40733) | function lineEnd(cm, lineN) {
function lineStartSmart (line 40743) | function lineStartSmart(cm, pos) {
function compareBidiLevel (line 40755) | function compareBidiLevel(order, a, b) {
function getBidiPartAt (line 40762) | function getBidiPartAt(order, pos) {
function moveInLine (line 40782) | function moveInLine(line, pos, dir, byUnit) {
function moveVisually (line 40794) | function moveVisually(line, start, dir, byUnit) {
function moveLogically (line 40817) | function moveLogically(line, start, dir, byUnit) {
function charType (line 40851) | function charType(code) {
function BidiSpan (line 40866) | function BidiSpan(level, from, to) {
function expressionAllowed (line 41020) | function expressionAllowed(stream, state, backUp) {
function kw (line 41036) | function kw(type) {return {type: type, style: "keyword"};}
function readRegexp (line 41087) | function readRegexp(stream) {
function ret (line 41102) | function ret(tp, style, cont) {
function tokenBase (line 41106) | function tokenBase(stream, state) {
function tokenString (line 41163) | function tokenString(quote) {
function tokenComment (line 41179) | function tokenComment(stream, state) {
function tokenQuasi (line 41191) | function tokenQuasi(stream, state) {
function findFatArrow (line 41211) | function findFatArrow(stream, state) {
function JSLexical (line 41241) | function JSLexical(indented, column, type, align, prev, info) {
function inScope (line 41250) | function inScope(state, varname) {
function parseJS (line 41259) | function parseJS(state, style, type, content, stream) {
function pass (line 41283) | function pass() {
function cont (line 41286) | function cont() {
function register (line 41290) | function register(varname) {
function pushcontext (line 41311) | function pushcontext() {
function popcontext (line 41315) | function popcontext() {
function pushlex (line 41319) | function pushlex(type, info) {
function poplex (line 41330) | function poplex() {
function expect (line 41340) | function expect(wanted) {
function statement (line 41349) | function statement(type, value) {
function expression (line 41375) | function expression(type) {
function expressionNoComma (line 41378) | function expressionNoComma(type) {
function expressionInner (line 41381) | function expressionInner(type, noComma) {
function maybeexpression (line 41400) | function maybeexpression(type) {
function maybeexpressionNoComma (line 41404) | function maybeexpressionNoComma(type) {
function maybeoperatorComma (line 41409) | function maybeoperatorComma(type, value) {
function maybeoperatorNoComma (line 41413) | function maybeoperatorNoComma(type, value, noComma) {
function quasi (line 41428) | function quasi(type, value) {
function continueQuasi (line 41433) | function continueQuasi(type) {
function arrowBody (line 41440) | function arrowBody(type) {
function arrowBodyNoComma (line 41444) | function arrowBodyNoComma(type) {
function maybeTarget (line 41448) | function maybeTarget(noComma) {
function target (line 41454) | function target(_, value) {
function targetNoComma (line 41457) | function targetNoComma(_, value) {
function maybelabel (line 41460) | function maybelabel(type) {
function property (line 41464) | function property(type) {
function objprop (line 41467) | function objprop(type, value) {
function getterSetter (line 41485) | function getterSetter(type) {
function afterprop (line 41490) | function afterprop(type) {
function commasep (line 41494) | function commasep(what, end) {
function contCommasep (line 41509) | function contCommasep(what, end, info) {
function block (line 41514) | function block(type) {
function maybetype (line 41518) | function maybetype(type) {
function maybedefault (line 41521) | function maybedefault(_, value) {
function typedef (line 41524) | function typedef(type) {
function vardef (line 41527) | function vardef() {
function pattern (line 41530) | function pattern(type, value) {
function proppattern (line 41537) | function proppattern(type, value) {
function maybeAssign (line 41547) | function maybeAssign(_type, value) {
function vardefCont (line 41550) | function vardefCont(type) {
function maybeelse (line 41553) | function maybeelse(type, value) {
function forspec (line 41556) | function forspec(type) {
function forspec1 (line 41559) | function forspec1(type) {
function formaybeinof (line 41565) | function formaybeinof(_type, value) {
function forspec2 (line 41569) | function forspec2(type, value) {
function forspec3 (line 41574) | function forspec3(type) {
function functiondef (line 41577) | function functiondef(type, value) {
function funarg (line 41582) | function funarg(type) {
function className (line 41586) | function className(type, value) {
function classNameAfter (line 41589) | function classNameAfter(type, value) {
function classBody (line 41593) | function classBody(type, value) {
function classGetterSetter (line 41610) | function classGetterSetter(type) {
function afterExport (line 41615) | function afterExport(_type, value) {
function afterImport (line 41620) | function afterImport(type) {
function importSpec (line 41624) | function importSpec(type, value) {
function maybeAs (line 41630) | function maybeAs(_type, value) {
function maybeFrom (line 41633) | function maybeFrom(_type, value) {
function arrayLiteral (line 41636) | function arrayLiteral(type) {
function maybeArrayComprehension (line 41640) | function maybeArrayComprehension(type) {
function comprehension (line 41645) | function comprehension(type) {
function isContinuedStatement (line 41650) | function isContinuedStatement(state, textAfter) {
FILE: browser/main.js
function showError (line 30) | function showError(e) {
function initDebugger (line 47) | function initDebugger(node, code) {
function finishInit (line 68) | function finishInit(code, breakpoint, container, id) {
FILE: browser/script.js
function foo (line 1) | function foo(x) {
FILE: debuggers/browser/static/app-conn.js
function format (line 2) | function format(obj) {
FILE: debuggers/browser/static/app.js
function classes (line 4) | function classes() {
function getNodeAtPoint (line 82) | function getNodeAtPoint(nodes, cursor) {
function findDeepestFunction (line 98) | function findDeepestFunction(node, cursor) {
function makeMarker (line 276) | function makeMarker() {
FILE: debuggers/browser/static/conn.js
function Connection (line 5) | function Connection(target, name) {
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/Gruntfile.js
function getFiles (line 321) | function getFiles(type) {
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/dist/js/bootstrap.js
function transitionEnd (line 34) | function transitionEnd() {
function removeElement (line 119) | function removeElement() {
function clearMenus (line 771) | function clearMenus() {
function getParent (line 782) | function getParent($this) {
function complete (line 1343) | function complete() {
function ScrollSpy (line 1611) | function ScrollSpy(element, options) {
function next (line 1812) | function next() {
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/js/customizer.js
function showError (line 12) | function showError(msg, err) {
function showCallout (line 23) | function showCallout(msg, showUpTop) {
function getQueryParam (line 36) | function getQueryParam(key) {
function createGist (line 42) | function createGist(configJson) {
function getCustomizerData (line 67) | function getCustomizerData() {
function parseUrl (line 86) | function parseUrl() {
function generateZip (line 119) | function generateZip(css, js, fonts, config, complete) {
function generateCustomCSS (line 154) | function generateCustomCSS(vars) {
function generateFonts (line 164) | function generateFonts() {
function bootstrapLessFilenames (line 173) | function bootstrapLessFilenames() {
function generateCSS (line 185) | function generateCSS() {
function generateJavascript (line 244) | function generateJavascript() {
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/js/holder.js
function contentLoaded (line 139) | function contentLoaded(n,t){var l="complete",s="readystatechange",u=!1,h...
function selector (line 142) | function selector(a){
function extend (line 148) | function extend(a,b){
function text_size (line 172) | function text_size(width, height, template) {
function draw (line 184) | function draw(args) {
function render (line 225) | function render(mode, el, holder, src) {
function dimension_check (line 287) | function dimension_check(el, callback) {
function resizable_update (line 308) | function resizable_update(element) {
function parse_flags (line 348) | function parse_flags(flags, options) {
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/js/jszip.js
function identity (line 1103) | function identity(input) {
function stringToArrayLike (line 1113) | function stringToArrayLike(str, array) {
function arrayLikeToString (line 1125) | function arrayLikeToString(array) {
function arrayLikeToArrayLike (line 1183) | function arrayLikeToArrayLike(arrayFrom, arrayTo) {
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/js/less.js
function n (line 8) | function n(t){return e.less[t.split("/")[1]]}
function f (line 8) | function f(){r.env==="development"?(r.optimization=0,r.watchTimer=setInt...
function m (line 8) | function m(){var e=document.getElementsByTagName("style");for(var t=0;t<...
function g (line 8) | function g(e,t){for(var n=0;n<r.sheets.length;n++)w(r.sheets[n],e,t,r.sh...
function y (line 8) | function y(e,t){var n=b(e),r=b(t),i,s,o,u,a="";if(n.hostPart!==r.hostPar...
function b (line 8) | function b(e,t){var n=/^((?:[a-z-]+:)?\/\/(?:[^\/\?#]*\/)|([\/\\]))?((?:...
function w (line 8) | function w(t,n,i,s){var o=t.contents||{},u=t.files||{},a=b(t.href,e.loca...
function E (line 8) | function E(e){return e.replace(/^[a-z]+:\/\/?[^\/]+/,"").replace(/^\//,"...
function S (line 8) | function S(e,t,n){var r,i=t.href||"",s="less:"+(t.title||E(i));if((r=doc...
function x (line 8) | function x(e,t,n,i){function a(t,n,r){t.status>=200&&t.status<300?n(t.re...
function T (line 8) | function T(){if(e.XMLHttpRequest)return new XMLHttpRequest;try{return ne...
function N (line 8) | function N(e){return e&&e.parentNode.removeChild(e)}
function C (line 8) | function C(e){r.env=="development"&&typeof console!="undefined"&&console...
function k (line 8) | function k(e,t){var n="less-error-message:"+E(t),i='<li><label>{line}</l...
function g (line 8) | function g(){a=c[u],f=o,h=o}
function y (line 8) | function y(){c[u]=a,o=f,h=o}
function b (line 8) | function b(){o>h&&(c[u]=c[u].slice(o-h),h=o)}
function w (line 8) | function w(e){var t=e.charCodeAt(0);return t===32||t===10||t===9}
function E (line 8) | function E(e){var t,n,r,i,a;if(e instanceof Function)return e.call(p.par...
function S (line 8) | function S(e){var t=o,n=u,r=o+c[u].length,i=o+=e;while(o<r){if(!w(s.char...
function x (line 8) | function x(e,t){var n=E(e);if(!!n)return n;T(t||(typeof e=="string"?"exp...
function T (line 8) | function T(e,t){var n=new Error(e);throw n.index=o,n.type=t||"Syntax",n}
function N (line 8) | function N(e){return typeof e=="string"?s.charAt(o)===e:e.test(c[u])?!0:!1}
function C (line 8) | function C(e,t){return e.filename&&t.filename&&e.filename!==t.filename?p...
function k (line 8) | function k(e,t){for(var n=e,r=-1;n>=0&&t.charAt(n)!=="\n";n--)r++;return...
function L (line 8) | function L(e){return r.mode==="browser"||r.mode==="rhino"?e.filename:n("...
function A (line 8) | function A(e,t,n){return{lineNumber:k(e,t).line+1,fileName:L(n)}}
function O (line 8) | function O(e,t){var n=C(e,t),r=k(e.index,n),i=r.line,s=r.column,o=n.spli...
function t (line 8) | function t(t){return e.functions.hsla(t.h,t.s,t.l,t.a)}
function n (line 8) | function n(t,n){return t instanceof e.Dimension&&t.unit=="%"?parseFloat(...
function r (line 8) | function r(t){if(t instanceof e.Dimension)return parseFloat(t.unit=="%"?...
function i (line 8) | function i(e){return Math.min(1,Math.max(0,e))}
function u (line 8) | function u(e){return e=e<0?e+1:e>1?e-1:e,e*6<1?o+(s-o)*e*6:e*2<1?s:e*3<2...
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/js/uglify.js
function g (line 14) | function g(a,b){if(a&&a.charAt(0)==="."&&b){b=b.split("/"),b=b.slice(0,b...
function h (line 14) | function h(a,d){return function(){return c.apply(null,b.call(arguments,0...
function i (line 14) | function i(a){return function(b){return g(b,a)}}
function j (line 14) | function j(b){return function(c){a[b]=c}}
function k (line 14) | function k(b,c){var d,e,f=b.indexOf("!");return f!==-1?(d=g(b.slice(0,f)...
function l (line 14) | function l(b,c,d,e){var f=[],g,i,l,m,n,o;e||(e=b);if(typeof d=="function...
function r (line 14) | function r(a){return q.letter.test(a)}
function s (line 14) | function s(a){return a=a.charCodeAt(0),a>=48&&a<=57}
function t (line 14) | function t(a){return s(a)||r(a)}
function u (line 14) | function u(a){return q.non_spacing_mark.test(a)||q.space_combining_mark....
function v (line 14) | function v(a){return q.connector_punctuation.test(a)}
function w (line 14) | function w(a){return a=="$"||a=="_"||r(a)}
function x (line 14) | function x(a){return w(a)||u(a)||s(a)||v(a)||a==""||a==""}
function y (line 14) | function y(a){if(i.test(a))return parseInt(a.substr(2),16);if(j.test(a))...
function z (line 14) | function z(a,b,c,d){this.message=a,this.line=b,this.col=c,this.pos=d,thi...
function A (line 14) | function A(a,b,c,d){throw new z(a,b,c,d)}
function B (line 14) | function B(a,b,c){return a.type==b&&(c==null||a.value==c)}
function D (line 14) | function D(a){function c(){return b.text.charAt(b.pos)}function e(a,c){v...
function K (line 14) | function K(a,b,c){this.name=a,this.start=b,this.end=c}
function L (line 14) | function L(a,b,c){function e(a,b){return B(d.token,a,b)}function f(){ret...
function M (line 14) | function M(a){var b=P(arguments,1);return function(){return a.apply(this...
function N (line 14) | function N(a){a instanceof Function&&(a=a());for(var b=1,c=arguments.len...
function O (line 14) | function O(a){var b={};for(var c=0;c<a.length;++c)b[a[c]]=!0;return b}
function P (line 14) | function P(a,b){return Array.prototype.slice.call(a,b||0)}
function Q (line 14) | function Q(a){return a.split("")}
function R (line 14) | function R(a,b){for(var c=b.length;--c>=0;)if(b[c]===a)return!0;return!1}
function S (line 14) | function S(a,b){return Object.prototype.hasOwnProperty.call(a,b)}
function i (line 14) | function i(){function a(a){return[this[0],K(a,function(a){var b=[a[0]];r...
function j (line 14) | function j(a){this.names={},this.mangled={},this.rev_mangled={},this.cna...
function l (line 14) | function l(a){function f(a){b=new j(b);var c=b.body=a();return c.scope=b...
function m (line 14) | function m(a,b){function g(a,c){return!b.toplevel&&!e.parent?a:b.except&...
function o (line 14) | function o(a,b){return E(a).length>E(b[0]=="stat"?b[1]:b).length?b:a}
function p (line 14) | function p(a){return a[0]=="block"&&a[1]&&a[1].length>0?a[1][a[1].length...
function q (line 14) | function q(a){if(a)switch(p(a)[0]){case"return":case"break":case"continu...
function r (line 14) | function r(a){return a[0]=="unary-prefix"&&f(a[1],["!","delete"])||a[0]=...
function s (line 14) | function s(a){return!a||a[0]=="block"&&(!a[1]||a[1].length==0)}
function t (line 14) | function t(a){return a[0]=="string"||a[0]=="unary-prefix"&&a[1]=="typeof...
function v (line 14) | function v(a){s(a)||n("Dropping unreachable code: "+E(a,!0))}
function w (line 14) | function w(a){function d(a){a=K(a,c);for(var b=0;b<a.length;++b){var e=a...
function x (line 14) | function x(a,b){function g(){throw e}function h(){throw f}function j(){r...
function y (line 14) | function y(a){function e(a,b){var e=d;d=b,a=K(a,c);var f={},g=K(b.names,...
function z (line 14) | function z(a,b){function h(a){var c=["unary-prefix","!",a];switch(a[0]){...
function B (line 14) | function B(a,b){var c=0,d=0;return a=a.replace(/[\\\b\f\n\r\t\x22\x27\u2...
function C (line 14) | function C(a){return a.replace(/[\u0080-\uffff]/g,function(a){var b=a.ch...
function E (line 14) | function E(a,b){function m(a){var c=B(a,b.ascii_only);return b.inline_sc...
function F (line 14) | function F(a,b){var c=[0];return d.parse(function(){function h(a){return...
function G (line 14) | function G(a,b){if(b>0){if(b==1)return a;var c=G(a,b>>1);return c+=c,b&1...
function H (line 14) | function H(a,b){var c={};a===!0&&(a={});for(var d in b)J(b,d)&&(c[d]=a&&...
function I (line 14) | function I(a){return/^[a-z_$][a-z0-9_$]*$/i.test(a)&&a!="this"&&!J(d.KEY...
function J (line 14) | function J(a,b){return Object.prototype.hasOwnProperty.call(a,b)}
function b (line 14) | function b(c){switch(c[0]){case"string":case"num":return c[1];case"name"...
function b (line 14) | function b(a){this.v=a}
function c (line 14) | function c(a){this.v=a}
function j (line 14) | function j(){var j=e.call(f,d[i],i);j instanceof b?(j=j.v,j instanceof c...
function d (line 14) | function d(a,b){b||(b={});var c=d.parser,e=d.uglify,f=c.parse(a,b.strict...
function l (line 14) | function l(a){function f(a,b){var c=d,e;return d=a,e=b(),d=c,e}function ...
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/js/alert.js
function removeElement (line 54) | function removeElement() {
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/js/dropdown.js
function clearMenus (line 93) | function clearMenus() {
function getParent (line 104) | function getParent($this) {
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/js/scrollspy.js
function ScrollSpy (line 26) | function ScrollSpy(element, options) {
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/js/tab.js
function next (line 68) | function next() {
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/unit/phantom.js
function sendMessage (line 19) | function sendMessage() {
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/vendor/jquery.js
function M (line 4) | function M(e){var t=e.length,n=x.type(e);return x.isWindow(e)?!1:1===e.n...
function at (line 4) | function at(e,t,n,i){var o,a,s,l,u,c,d,m,y,x;if((t?t.ownerDocument||t:w)...
function st (line 4) | function st(){var e=[];function t(n,r){return e.push(n+=" ")>o.cacheLeng...
function lt (line 4) | function lt(e){return e[b]=!0,e}
function ut (line 4) | function ut(e){var t=f.createElement("div");try{return!!e(t)}catch(n){re...
function ct (line 4) | function ct(e,t){var n=e.split("|"),r=e.length;while(r--)o.attrHandle[n[...
function pt (line 4) | function pt(e,t){var n=t&&e,r=n&&1===e.nodeType&&1===t.nodeType&&(~t.sou...
function ft (line 4) | function ft(e){return function(t){var n=t.nodeName.toLowerCase();return"...
function dt (line 4) | function dt(e){return function(t){var n=t.nodeName.toLowerCase();return(...
function ht (line 4) | function ht(e){return lt(function(t){return t=+t,lt(function(n,r){var i,...
function gt (line 4) | function gt(){}
function mt (line 4) | function mt(e,t){var n,r,i,a,s,l,u,c=k[e+" "];if(c)return t?0:c.slice(0)...
function yt (line 4) | function yt(e){var t=0,n=e.length,r="";for(;n>t;t++)r+=e[t].value;return r}
function vt (line 4) | function vt(e,t,n){var r=t.dir,o=n&&"parentNode"===r,a=C++;return t.firs...
function bt (line 4) | function bt(e){return e.length>1?function(t,n,r){var i=e.length;while(i-...
function xt (line 4) | function xt(e,t,n,r,i){var o,a=[],s=0,l=e.length,u=null!=t;for(;l>s;s++)...
function wt (line 4) | function wt(e,t,n,r,i,o){return r&&!r[b]&&(r=wt(r)),i&&!i[b]&&(i=wt(i,o)...
function Tt (line 4) | function Tt(e){var t,n,r,i=e.length,a=o.relative[e[0].type],s=a||o.relat...
function Ct (line 4) | function Ct(e,t){var n=0,r=t.length>0,a=e.length>0,s=function(s,l,c,p,d)...
function Nt (line 4) | function Nt(e,t,n){var r=0,i=t.length;for(;i>r;r++)at(e,t[r],n);return n}
function kt (line 4) | function kt(e,t,n,i){var a,s,u,c,p,f=mt(e);if(!i&&1===f.length){if(s=f[0...
function F (line 4) | function F(e){var t=O[e]={};return x.each(e.match(T)||[],function(e,n){t...
function R (line 5) | function R(e,n,r,i){if(x.acceptData(e)){var o,a,s=x.expando,l=e.nodeType...
function W (line 5) | function W(e,t,n){if(x.acceptData(e)){var r,i,o=e.nodeType,a=o?x.cache:e...
function $ (line 5) | function $(e,n,r){if(r===t&&1===e.nodeType){var i="data-"+n.replace(P,"-...
function I (line 5) | function I(e){var t;for(t in e)if(("data"!==t||!x.isEmptyObject(e[t]))&&...
function it (line 5) | function it(){return!0}
function ot (line 5) | function ot(){return!1}
function at (line 5) | function at(){try{return a.activeElement}catch(e){}}
function pt (line 5) | function pt(e,t){do e=e[t];while(e&&1!==e.nodeType);return e}
function ft (line 5) | function ft(e,t,n){if(x.isFunction(t))return x.grep(e,function(e,r){retu...
function dt (line 5) | function dt(e){var t=ht.split("|"),n=e.createDocumentFragment();if(n.cre...
function Lt (line 5) | function Lt(e,t){return x.nodeName(e,"table")&&x.nodeName(1===t.nodeType...
function Ht (line 5) | function Ht(e){return e.type=(null!==x.find.attr(e,"type"))+"/"+e.type,e}
function qt (line 5) | function qt(e){var t=Et.exec(e.type);return t?e.type=t[1]:e.removeAttrib...
function _t (line 5) | function _t(e,t){var n,r=0;for(;null!=(n=e[r]);r++)x._data(n,"globalEval...
function Mt (line 5) | function Mt(e,t){if(1===t.nodeType&&x.hasData(e)){var n,r,i,o=x._data(e)...
function Ot (line 5) | function Ot(e,t){var n,r,i;if(1===t.nodeType){if(n=t.nodeName.toLowerCas...
function Ft (line 5) | function Ft(e,n){var r,o,a=0,s=typeof e.getElementsByTagName!==i?e.getEl...
function Bt (line 5) | function Bt(e){Ct.test(e.type)&&(e.defaultChecked=e.checked)}
function tn (line 6) | function tn(e,t){if(t in e)return t;var n=t.charAt(0).toUpperCase()+t.sl...
function nn (line 6) | function nn(e,t){return e=t||e,"none"===x.css(e,"display")||!x.contains(...
function rn (line 6) | function rn(e,t){var n,r,i,o=[],a=0,s=e.length;for(;s>a;a++)r=e[a],r.sty...
function on (line 6) | function on(e,t,n){var r=Vt.exec(t);return r?Math.max(0,r[1]-(n||0))+(r[...
function an (line 6) | function an(e,t,n,r,i){var o=n===(r?"border":"content")?4:"width"===t?1:...
function sn (line 6) | function sn(e,t,n){var r=!0,i="width"===t?e.offsetWidth:e.offsetHeight,o...
function ln (line 6) | function ln(e){var t=a,n=Gt[e];return n||(n=un(e,t),"none"!==n&&n||(Pt=(...
function un (line 6) | function un(e,t){var n=x(t.createElement(e)).appendTo(t.body),r=x.css(n[...
function gn (line 6) | function gn(e,t,n,r){var i;if(x.isArray(t))x.each(t,function(t,i){n||pn....
function Hn (line 6) | function Hn(e){return function(t,n){"string"!=typeof t&&(n=t,t="*");var ...
function qn (line 6) | function qn(e,n,r,i){var o={},a=e===jn;function s(l){var u;return o[l]=!...
function _n (line 6) | function _n(e,n){var r,i,o=x.ajaxSettings.flatOptions||{};for(i in n)n[i...
function k (line 6) | function k(e,n,r,i){var c,y,v,w,T,N=n;2!==b&&(b=2,s&&clearTimeout(s),u=t...
function Mn (line 6) | function Mn(e,n,r){var i,o,a,s,l=e.contents,u=e.dataTypes;while("*"===u[...
function On (line 6) | function On(e,t,n,r){var i,o,a,s,l,u={},c=e.dataTypes.slice();if(c[1])fo...
function In (line 6) | function In(){try{return new e.XMLHttpRequest}catch(t){}}
function zn (line 6) | function zn(){try{return new e.ActiveXObject("Microsoft.XMLHTTP")}catch(...
function Kn (line 6) | function Kn(){return setTimeout(function(){Xn=t}),Xn=x.now()}
function Zn (line 6) | function Zn(e,t,n){var r,i=(Qn[t]||[]).concat(Qn["*"]),o=0,a=i.length;fo...
function er (line 6) | function er(e,t,n){var r,i,o=0,a=Gn.length,s=x.Deferred().always(functio...
function tr (line 6) | function tr(e,t){var n,r,i,o,a;for(n in e)if(r=x.camelCase(n),i=t[r],o=e...
function nr (line 6) | function nr(e,t,n){var r,i,o,a,s,l,u=this,c={},p=e.style,f=e.nodeType&&n...
function rr (line 6) | function rr(e,t,n,r,i){return new rr.prototype.init(e,t,n,r,i)}
function ir (line 6) | function ir(e,t){var n,r={height:e},i=0;for(t=t?1:0;4>i;i+=2-t)n=Zt[i],r...
function or (line 6) | function or(e){return x.isWindow(e)?e:9===e.nodeType?e.defaultView||e.pa...
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/vendor/qunit.js
function run (line 226) | function run() {
function done (line 759) | function done() {
function validTest (line 814) | function validTest( name ) {
function sourceFromStacktrace (line 840) | function sourceFromStacktrace() {
function escapeHtml (line 858) | function escapeHtml(s) {
function synchronize (line 875) | function synchronize( callback ) {
function process (line 883) | function process() {
function saveGlobal (line 899) | function saveGlobal() {
function checkPollution (line 909) | function checkPollution( name ) {
function diff (line 925) | function diff( a, b ) {
function fail (line 939) | function fail(message, exception, callback) {
function extend (line 950) | function extend(a, b) {
function addEvent (line 962) | function addEvent(elem, type, fn) {
function id (line 972) | function id(name) {
function bindCallbacks (line 988) | function bindCallbacks(o, callbacks, args) {
function useStrictEquality (line 1002) | function useStrictEquality(b, a) {
function quote (line 1165) | function quote( str ) {
function literal (line 1168) | function literal( o ) {
function join (line 1171) | function join( pre, arr, post ) {
function array (line 1181) | function array( arr, stack ) {
function getText (line 1339) | function getText( elems ) {
function inArray (line 1359) | function inArray( elem, array ) {
function diff (line 1388) | function diff(o, n) {
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/js/tooltip.js
function complete (line 263) | function complete() {
FILE: debuggers/browser/static/lib/bootstrap-3.0.3/js/transition.js
function transitionEnd (line 26) | function transitionEnd() {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/comment/comment.js
function firstNonWS (line 8) | function firstNonWS(str) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/comment/continuecomment.js
function continueComment (line 6) | function continueComment(cm) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/dialog/dialog.js
function dialogDiv (line 4) | function dialogDiv(cm, template, bottom) {
function closeNotification (line 21) | function closeNotification(cm, newVal) {
function close (line 31) | function close() {
function close (line 69) | function close() {
function close (line 107) | function close() {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/display/fullscreen.js
function setFullscreen (line 11) | function setFullscreen(cm) {
function setNormal (line 22) | function setNormal(cm) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/display/placeholder.js
function clearPlaceholder (line 19) | function clearPlaceholder(cm) {
function setPlaceholder (line 25) | function setPlaceholder(cm) {
function onBlur (line 34) | function onBlur(cm) {
function onChange (line 37) | function onChange(cm) {
function isEmpty (line 45) | function isEmpty(cm) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/edit/closebrackets.js
function charsAround (line 21) | function charsAround(cm, pos) {
function buildKeymap (line 27) | function buildKeymap(pairs) {
function buildExplodeHandler (line 70) | function buildExplodeHandler(pairs) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/edit/closetag.js
function autoCloseGT (line 43) | function autoCloseGT(cm) {
function autoCloseSlash (line 72) | function autoCloseSlash(cm) {
function indexOf (line 83) | function indexOf(collection, elt) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/edit/matchbrackets.js
function findMatchingBracket (line 8) | function findMatchingBracket(cm, where, strict) {
function matchBrackets (line 45) | function matchBrackets(cm, autoclear) {
function doMatchBrackets (line 67) | function doMatchBrackets(cm) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/edit/matchtags.js
function clear (line 18) | function clear(cm) {
function doMatchTags (line 24) | function doMatchTags(cm) {
function maybeUpdateMatch (line 45) | function maybeUpdateMatch(cm) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/fold/brace-fold.js
function findOpening (line 5) | function findOpening(openCh) {
function hasImport (line 51) | function hasImport(line) {
function hasInclude (line 76) | function hasInclude(line) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/fold/foldcode.js
function doFold (line 4) | function doFold(cm, pos, options, force) {
function makeWidget (line 45) | function makeWidget(options) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/fold/foldgutter.js
function State (line 29) | function State(options) {
function parseOptions (line 34) | function parseOptions(opts) {
function isFolded (line 42) | function isFolded(cm, line) {
function marker (line 48) | function marker(spec) {
function updateFoldInfo (line 58) | function updateFoldInfo(cm, from, to) {
function updateInViewport (line 75) | function updateInViewport(cm) {
function onGutterClick (line 84) | function onGutterClick(cm, line, gutter) {
function onChange (line 90) | function onChange(cm) {
function onViewportChange (line 97) | function onViewportChange(cm) {
function onFold (line 119) | function onFold(cm, from) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/fold/xml-fold.js
function cmp (line 5) | function cmp(a, b) { return a.line - b.line || a.ch - b.ch; }
function Iter (line 11) | function Iter(cm, line, ch, range) {
function tagAt (line 18) | function tagAt(iter, ch) {
function nextLine (line 23) | function nextLine(iter) {
function prevLine (line 29) | function prevLine(iter) {
function toTagEnd (line 36) | function toTagEnd(iter) {
function toTagStart (line 47) | function toTagStart(iter) {
function toNextTag (line 59) | function toNextTag(iter) {
function toPrevTag (line 69) | function toPrevTag(iter) {
function findMatchingClose (line 81) | function findMatchingClose(iter, tag) {
function findMatchingOpen (line 102) | function findMatchingOpen(iter, tag) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/hint/anyword-hint.js
function scan (line 16) | function scan(dir) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/hint/css-hint.js
function getHints (line 4) | function getHints(cm) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/hint/html-hint.js
function populate (line 320) | function populate(obj) {
function htmlHint (line 330) | function htmlHint(cm, options) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/hint/javascript-hint.js
function forEach (line 4) | function forEach(arr, f) {
function arrayContains (line 8) | function arrayContains(arr, item) {
function scriptHint (line 21) | function scriptHint(editor, keywords, getToken, options) {
function javascriptHint (line 45) | function javascriptHint(editor, options) {
function getCoffeeScriptToken (line 53) | function getCoffeeScriptToken(editor, cur) {
function coffeescriptHint (line 71) | function coffeescriptHint(editor, options) {
function getCompletions (line 87) | function getCompletions(token, context, keywords, options) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/hint/pig-hint.js
function forEach (line 4) | function forEach(arr, f) {
function arrayContains (line 8) | function arrayContains(arr, item) {
function scriptHint (line 21) | function scriptHint(editor, _keywords, getToken) {
function pigHint (line 46) | function pigHint(editor) {
function getCompletions (line 84) | function getCompletions(token, context) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/hint/python-hint.js
function forEach (line 2) | function forEach(arr, f) {
function arrayContains (line 6) | function arrayContains(arr, item) {
function scriptHint (line 19) | function scriptHint(editor, _keywords, getToken) {
function pythonHint (line 44) | function pythonHint(editor) {
function getCompletions (line 66) | function getCompletions(token, context) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/hint/show-hint.js
function Completion (line 23) | function Completion(cm, getHints, options) {
function done (line 68) | function done() {
function update (line 76) | function update() {
function finishUpdate (line 84) | function finishUpdate(data_) {
function activity (line 91) | function activity() {
function getText (line 108) | function getText(completion) {
function buildKeyMap (line 113) | function buildKeyMap(options, handle) {
function getHintElement (line 146) | function getHintElement(stopAt, el) {
function Widget (line 153) | function Widget(completion, data) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/hint/sql-hint.js
function getKeywords (line 7) | function getKeywords(editor) {
function match (line 13) | function match(string, word) {
function addMatches (line 19) | function addMatches(result, search, wordlist, formatter) {
function columnCompletion (line 31) | function columnCompletion(result, editor) {
function eachWord (line 49) | function eachWord(line, f) {
function findTableByAlias (line 57) | function findTableByAlias(alias, editor) {
function sqlHint (line 78) | function sqlHint(editor, options) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/hint/xml-hint.js
function getHints (line 6) | function getHints(cm, options) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/lint/javascript-lint.js
function validator (line 14) | function validator(text, options) {
function cleanup (line 24) | function cleanup(error) {
function fixWith (line 32) | function fixWith(error, fixes, severity, force) {
function isBogus (line 52) | function isBogus(error) {
function parseErrors (line 62) | function parseErrors(errors, output) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/lint/lint.js
function showTooltip (line 6) | function showTooltip(e, content) {
function rm (line 22) | function rm(elt) {
function hideTooltip (line 25) | function hideTooltip(tt) {
function showTooltipFor (line 32) | function showTooltipFor(e, content, node) {
function LintState (line 48) | function LintState(cm, options, hasGutter) {
function parseOptions (line 56) | function parseOptions(cm, options) {
function clearMarks (line 64) | function clearMarks(cm) {
function makeMarker (line 72) | function makeMarker(labels, severity, multiple, tooltips) {
function getMaxSeverity (line 87) | function getMaxSeverity(a, b) {
function groupByLine (line 92) | function groupByLine(annotations) {
function annotationTooltip (line 101) | function annotationTooltip(ann) {
function startLinting (line 110) | function startLinting(cm) {
function updateLinting (line 118) | function updateLinting(cm, annotationsNotSorted) {
function onChange (line 153) | function onChange(cm) {
function popupSpanTooltip (line 159) | function popupSpanTooltip(ann, e) {
function onMouseOver (line 169) | function onMouseOver(cm, e) {
function optionHandler (line 181) | function optionHandler(cm, val, old) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/merge/dep/diff_match_patch.js
function diff_match_patch (line 2) | function diff_match_patch(){this.Diff_Timeout=1;this.Diff_EditCost=4;thi...
function c (line 11) | function c(a){for(var b="",c=0,f=-1,g=d.length;f<a.length-1;){f=a.indexO...
function c (line 15) | function c(a,b,c){for(var d=a.substring(c,c+Math.floor(a.length/4)),e=-1...
function b (line 19) | function b(a,b){if(!a||!b)return 6;var c=a.charAt(a.length-1),d=b.charAt...
function d (line 31) | function d(a,d){var e=a/b.length,g=Math.abs(c-d);return!f.Match_Distance...
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/merge/merge.js
function DiffView (line 8) | function DiffView(mv, type) {
function registerUpdate (line 49) | function registerUpdate(dv) {
function registerScroll (line 91) | function registerScroll(dv) {
function syncScroll (line 100) | function syncScroll(dv, type) {
function getOffsets (line 137) | function getOffsets(editor, around) {
function setScrollLock (line 144) | function setScrollLock(dv, val, action) {
function clearMarks (line 152) | function clearMarks(editor, arr, classes) {
function updateMarks (line 167) | function updateMarks(editor, diff, state, type, classes) {
function markChanges (line 187) | function markChanges(editor, diff, type, marks, from, to, classes) {
function drawConnectors (line 234) | function drawConnectors(dv) {
function copyChunk (line 272) | function copyChunk(dv, chunk) {
function buildGap (line 325) | function buildGap(dv) {
function getDiff (line 358) | function getDiff(a, b) {
function iterateChunks (line 374) | function iterateChunks(diff, f) {
function endOfLineClean (line 397) | function endOfLineClean(diff, i) {
function startOfLineClean (line 406) | function startOfLineClean(diff, i) {
function chunkBoundariesAround (line 415) | function chunkBoundariesAround(diff, n, nInEdit) {
function elt (line 432) | function elt(tag, content, className, style) {
function clear (line 441) | function clear(node) {
function attrs (line 446) | function attrs(elt) {
function copyObj (line 451) | function copyObj(obj, target) {
function moveOver (line 457) | function moveOver(pos, str, copy, other) {
function posMin (line 471) | function posMin(a, b) { return (a.line - b.line || a.ch - b.ch) < 0 ? a ...
function posMax (line 472) | function posMax(a, b) { return (a.line - b.line || a.ch - b.ch) > 0 ? a ...
function posEq (line 473) | function posEq(a, b) { return a.line == b.line && a.ch == b.ch; }
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/mode/loadmode.js
function splitCallback (line 5) | function splitCallback(cont, n) {
function ensureDeps (line 9) | function ensureDeps(mode, cont) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/mode/multiplex.js
function indexOf (line 6) | function indexOf(string, pattern, from) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/mode/multiplex_test.js
function MT (line 19) | function MT(name) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/runmode/colorize.js
function textContent (line 5) | function textContent(node, out) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/runmode/runmode-standalone.js
function splitLines (line 8) | function splitLines(string){ return string.split(/\r?\n|\r/); }
function StringStream (line 10) | function StringStream(string) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/runmode/runmode.node.js
function splitLines (line 3) | function splitLines(string){ return string.split(/\r?\n|\r/); }
function StringStream (line 5) | function StringStream(string) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/scroll/scrollpastend.js
function onChange (line 16) | function onChange(cm, change) {
function updateBottomMargin (line 21) | function updateBottomMargin(cm) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/search/match-highlighter.js
function State (line 20) | function State(options) {
function cursorActivity (line 48) | function cursorActivity(cm) {
function highlightMatches (line 54) | function highlightMatches(cm) {
function boundariesAround (line 77) | function boundariesAround(stream, re) {
function makeOverlay (line 82) | function makeOverlay(query, hasBoundary, style) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/search/search.js
function searchOverlay (line 10) | function searchOverlay(query) {
function SearchState (line 25) | function SearchState() {
function getSearchState (line 29) | function getSearchState(cm) {
function getSearchCursor (line 32) | function getSearchCursor(cm, query, pos) {
function dialog (line 36) | function dialog(cm, text, shortText, f) {
function confirmDialog (line 40) | function confirmDialog(cm, text, shortText, fs) {
function parseQuery (line 44) | function parseQuery(query) {
function doSearch (line 50) | function doSearch(cm, rev) {
function findNext (line 65) | function findNext(cm, rev) {cm.operation(function() {
function clearSearch (line 76) | function clearSearch(cm) {cm.operation(function() {
function replace (line 87) | function replace(cm, all) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/search/searchcursor.js
function SearchCursor (line 4) | function SearchCursor(doc, query, pos, caseFold) {
function savePosAndFail (line 100) | function savePosAndFail(line) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/selection/active-line.js
function clearActiveLine (line 24) | function clearActiveLine(cm) {
function updateActiveLine (line 31) | function updateActiveLine(cm) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/selection/mark-selection.js
function onCursorActivity (line 26) | function onCursorActivity(cm) {
function onChange (line 30) | function onChange(cm) {
function cmp (line 38) | function cmp(pos1, pos2) {
function coverRange (line 42) | function coverRange(cm, from, to, addAt) {
function clear (line 58) | function clear(cm) {
function reset (line 64) | function reset(cm) {
function update (line 70) | function update(cm) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/tern/tern.js
function getFile (line 126) | function getFile(ts, name, c) {
function findDoc (line 136) | function findDoc(ts, doc, name) {
function trackChange (line 148) | function trackChange(ts, doc, change) {
function sendDoc (line 168) | function sendDoc(ts, doc) {
function hint (line 177) | function hint(ts, cm, c) {
function typeToIcon (line 212) | function typeToIcon(type) {
function showType (line 224) | function showType(ts, cm, pos) {
function updateArgHints (line 244) | function updateArgHints(ts, cm) {
function showArgHints (line 286) | function showArgHints(ts, cm, pos) {
function parseFnType (line 307) | function parseFnType(text) {
function jumpToDef (line 340) | function jumpToDef(ts, cm) {
function jumpBack (line 368) | function jumpBack(ts, cm) {
function moveTo (line 374) | function moveTo(ts, curDoc, doc, start, end) {
function findContext (line 383) | function findContext(doc, data) {
function atInterestingExpression (line 413) | function atInterestingExpression(cm) {
function rename (line 421) | function rename(ts, cm) {
function applyChanges (line 433) | function applyChanges(ts, changes) {
function buildRequest (line 453) | function buildRequest(ts, doc, query, pos) {
function getFragmentAround (line 495) | function getFragmentAround(data, start, end) {
function cmpPos (line 524) | function cmpPos(a, b) { return a.line - b.line || a.ch - b.ch; }
function elt (line 526) | function elt(tagname, cls /*, ... elts*/) {
function dialog (line 537) | function dialog(cm, text, f) {
function tempTooltip (line 546) | function tempTooltip(cm, content) {
function makeTooltip (line 558) | function makeTooltip(x, y, content) {
function remove (line 566) | function remove(node) {
function fadeOut (line 571) | function fadeOut(tooltip) {
function showError (line 576) | function showError(ts, cm, msg) {
function closeArgHints (line 583) | function closeArgHints(ts) {
function docValue (line 587) | function docValue(ts, doc) {
function WorkerServer (line 595) | function WorkerServer(ts) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/tern/worker.js
function getFile (line 23) | function getFile(file, c) {
function startServer (line 28) | function startServer(defs, plugins, scripts) {
FILE: debuggers/browser/static/lib/codemirror-3.20/addon/wrap/hardwrap.js
function findParagraph (line 6) | function findParagraph(cm, pos, options) {
function findBreakPoint (line 22) | function findBreakPoint(text, column, wrapOn, killTrailingSpace) {
function wrapRange (line 32) | function wrapRange(cm, from, to, options) {
FILE: debuggers/browser/static/lib/codemirror-3.20/doc/activebookmark.js
function updateSoon (line 4) | function updateSoon() {
function update (line 11) | function update() {
FILE: debuggers/browser/static/lib/codemirror-3.20/keymap/emacs.js
function posEq (line 5) | function posEq(a, b) { return a.line == b.line && a.ch == b.ch; }
function addToRing (line 10) | function addToRing(str) {
function growRingTop (line 14) | function growRingTop(str) {
function getFromRing (line 18) | function getFromRing(n) { return killRing[killRing.length - (n ? Math.mi...
function popFromRing (line 19) | function popFromRing() { if (killRing.length > 1) killRing.pop(); return...
function kill (line 23) | function kill(cm, from, to, mayGrow, text) {
function byChar (line 38) | function byChar(cm, pos, dir) {
function byWord (line 42) | function byWord(cm, pos, dir) {
function byLine (line 46) | function byLine(cm, pos, dir) {
function byPage (line 50) | function byPage(cm, pos, dir) {
function byParagraph (line 54) | function byParagraph(cm, pos, dir) {
function bySentence (line 69) | function bySentence(cm, pos, dir) {
function byExpr (line 88) | function byExpr(cm, pos, dir) {
function getPrefix (line 109) | function getPrefix(cm, precise) {
function repeated (line 116) | function repeated(cmd) {
function findEnd (line 125) | function findEnd(cm, by, dir) {
function move (line 136) | function move(by, dir) {
function killTo (line 144) | function killTo(cm, by, dir) {
function addPrefix (line 148) | function addPrefix(cm, digit) {
function maybeClearPrefix (line 161) | function maybeClearPrefix(cm, arg) {
function clearPrefix (line 166) | function clearPrefix(cm) {
function maybeDuplicateInput (line 172) | function maybeDuplicateInput(cm, event) {
function addPrefixMap (line 181) | function addPrefixMap(cm) {
function maybeRemovePrefixMap (line 188) | function maybeRemovePrefixMap(cm, arg) {
function setMark (line 198) | function setMark(cm) {
function getInput (line 204) | function getInput(cm, msg, f) {
function operateOnWord (line 211) | function operateOnWord(cm, op) {
function toEnclosingExpr (line 217) | function toEnclosingExpr(cm) {
function regPrefix (line 380) | function regPrefix(d) {
FILE: debuggers/browser/static/lib/codemirror-3.20/keymap/extra.js
function moveLines (line 9) | function moveLines(cm, start, end, dist) {
function moveSelectedLines (line 30) | function moveSelectedLines(cm, dist) {
FILE: debuggers/browser/static/lib/codemirror-3.20/keymap/vim.js
function beforeSelectionChange (line 336) | function beforeSelectionChange(cm, cur) {
function makeKeyRange (line 348) | function makeKeyRange(start, size) {
function isLine (line 364) | function isLine(cm, line) {
function isLowerCase (line 367) | function isLowerCase(k) {
function isMatchableSymbol (line 370) | function isMatchableSymbol(k) {
function isNumber (line 373) | function isNumber(k) {
function isUpperCase (line 376) | function isUpperCase(k) {
function isWhiteSpaceString (line 379) | function isWhiteSpaceString(k) {
function inArray (line 382) | function inArray(val, arr) {
function add (line 397) | function add(cm, oldCur, newCur) {
function move (line 424) | function move(cm, offset) {
function maybeInitVimState (line 482) | function maybeInitVimState(cm) {
function resetVimGlobalState (line 517) | function resetVimGlobalState() {
function InputState (line 621) | function InputState() {
function Register (line 659) | function Register(text, linewise) {
function RegisterController (line 694) | function RegisterController(registers) {
function getFullyMatchedCommandOrNull (line 811) | function getFullyMatchedCommandOrNull(command) {
function handleQuery (line 951) | function handleQuery(query, ignoreCase, smartCase) {
function onPromptClose (line 964) | function onPromptClose(query) {
function onPromptKeyUp (line 968) | function onPromptKeyUp(_e, query) {
function onPromptKeyDown (line 983) | function onPromptKeyDown(e, _query, close) {
function onPromptClose (line 1038) | function onPromptClose(input) {
function onPromptKeyDown (line 1043) | function onPromptKeyDown(e, _input, close) {
function clipCursorToContent (line 1989) | function clipCursorToContent(cm, cur, includeLineBreak) {
function copyArgs (line 1996) | function copyArgs(args) {
function offsetCursor (line 2005) | function offsetCursor(cur, offsetLine, offsetCh) {
function matchKeysPartial (line 2008) | function matchKeysPartial(pressed, mapped) {
function repeatFn (line 2017) | function repeatFn(cm, fn, repeat) {
function copyCursor (line 2024) | function copyCursor(cur) {
function cursorEqual (line 2027) | function cursorEqual(cur1, cur2) {
function cursorIsBefore (line 2030) | function cursorIsBefore(cur1, cur2) {
function cusrorIsBetween (line 2039) | function cusrorIsBetween(cur1, cur2, cur3) {
function lineLength (line 2045) | function lineLength(cm, lineNum) {
function reverse (line 2048) | function reverse(s){
function trim (line 2051) | function trim(s) {
function escapeRegex (line 2057) | function escapeRegex(s) {
function exitVisualMode (line 2061) | function exitVisualMode(cm) {
function clipToLine (line 2081) | function clipToLine(cm, curStart, curEnd) {
function expandSelectionToLine (line 2110) | function expandSelectionToLine(_cm, curStart, curEnd) {
function findFirstNonWhiteSpaceCharacter (line 2116) | function findFirstNonWhiteSpaceCharacter(text) {
function expandWordUnderCursor (line 2124) | function expandWordUnderCursor(cm, inclusive, _forward, bigWord, noSymbo...
function recordJumpPosition (line 2186) | function recordJumpPosition(cm, oldCur, newCur) {
function recordLastCharacterSearch (line 2192) | function recordLastCharacterSearch(increment, args) {
function findSymbol (line 2270) | function findSymbol(cm, repeat, forward, symb) {
function findWord (line 2336) | function findWord(cm, cur, forward, bigWord, emptyLineIsWord) {
function moveToWord (line 2409) | function moveToWord(cm, repeat, forward, wordEnd, bigWord) {
function moveToCharacter (line 2455) | function moveToCharacter(cm, repeat, forward, character) {
function moveToColumn (line 2470) | function moveToColumn(cm, repeat) {
function updateMark (line 2477) | function updateMark(cm, vim, markName, pos) {
function charIdxInLine (line 2487) | function charIdxInLine(start, line, character, forward, includeChar) {
function getContextLevel (line 2508) | function getContextLevel(ctx) {
function findMatchedSymbol (line 2512) | function findMatchedSymbol(cm, cur, symb) {
function selectCompanionObject (line 2570) | function selectCompanionObject(cm, revSymb, inclusive) {
function findBeginningAndEnd (line 2584) | function findBeginningAndEnd(cm, symb, inclusive) {
function SearchState (line 2643) | function SearchState() {}
function getSearchState (line 2664) | function getSearchState(cm) {
function dialog (line 2668) | function dialog(cm, template, shortText, onClose, options) {
function findUnescapedSlashes (line 2678) | function findUnescapedSlashes(str) {
function parseQuery (line 2700) | function parseQuery(query, ignoreCase, smartCase) {
function showConfirm (line 2728) | function showConfirm(cm, text) {
function makePrompt (line 2736) | function makePrompt(prefix, desc) {
function showPrompt (line 2751) | function showPrompt(cm, options) {
function regexEqual (line 2756) | function regexEqual(r1, r2) {
function updateSearchQuery (line 2770) | function updateSearchQuery(cm, rawQuery, ignoreCase, smartCase) {
function searchOverlay (line 2786) | function searchOverlay(query) {
function highlightSearchMatches (line 2822) | function highlightSearchMatches(cm, query) {
function findNext (line 2833) | function findNext(cm, prev, query, repeat) {
function clearSearchHighlight (line 2854) | function clearSearchHighlight(cm) {
function isInRange (line 2869) | function isInRange(pos, start, end) {
function getUserVisibleLines (line 2884) | function getUserVisibleLines(cm) {
function parseKeyString (line 3079) | function parseKeyString(str) {
function parseArgs (line 3113) | function parseArgs() {
function compareFn (line 3156) | function compareFn(a, b) {
function doReplace (line 3327) | function doReplace(cm, confirm, lineStart, lineEnd, searchCursor, query,
function buildVimKeyMap (line 3410) | function buildVimKeyMap() {
function exitInsertMode (line 3477) | function exitInsertMode(cm) {
function parseRegisterToKeyBuffer (line 3520) | function parseRegisterToKeyBuffer(macroModeState, registerName) {
function parseKeyBufferToRegister (line 3536) | function parseKeyBufferToRegister(registerName, keyBuffer) {
function emptyMacroKeyBuffer (line 3541) | function emptyMacroKeyBuffer(macroModeState) {
function executeMacroKeyBuffer (line 3547) | function executeMacroKeyBuffer(cm, macroModeState, keyBuffer) {
function logKey (line 3555) | function logKey(macroModeState, key) {
function onChange (line 3565) | function onChange(_cm, changeObj) {
function onCursorActivity (line 3585) | function onCursorActivity() {
function InsertModeKey (line 3597) | function InsertModeKey(keyName) {
function onKeyEventTargetKeyDown (line 3606) | function onKeyEventTargetKeyDown(e) {
function repeatLastEdit (line 3628) | function repeatLastEdit(cm, vim, repeat, repeatForInsert) {
function repeatLastInsertModeChanges (line 3674) | function repeatLastInsertModeChanges(cm, repeat, macroModeState) {
FILE: debuggers/browser/static/lib/codemirror-3.20/lib/codemirror.js
function CodeMirror (line 47) | function CodeMirror(place, options) {
function makeDisplay (line 99) | function makeDisplay(place, docStart) {
function loadMode (line 198) | function loadMode(cm) {
function wrappingChanged (line 210) | function wrappingChanged(cm) {
function estimateHeight (line 224) | function estimateHeight(cm) {
function estimateLineHeights (line 237) | function estimateLineHeights(cm) {
function keyMapChanged (line 245) | function keyMapChanged(cm) {
function themeChanged (line 252) | function themeChanged(cm) {
function guttersChanged (line 258) | function guttersChanged(cm) {
function updateGutters (line 264) | function updateGutters(cm) {
function lineLength (line 278) | function lineLength(doc, line) {
function computeMaxLength (line 296) | function computeMaxLength(cm) {
function setGuttersForLineNumbers (line 312) | function setGuttersForLineNumbers(options) {
function updateScrollbars (line 326) | function updateScrollbars(cm) {
function visibleLines (line 368) | function visibleLines(display, doc, viewPort) {
function alignHorizontally (line 379) | function alignHorizontally(cm) {
function maybeUpdateLineNumberWidth (line 391) | function maybeUpdateLineNumberWidth(cm) {
function lineNumberFor (line 408) | function lineNumberFor(options, i) {
function compensateForHScroll (line 411) | function compensateForHScroll(display) {
function updateDisplay (line 417) | function updateDisplay(cm, changes, viewPort, forced) {
function updateDisplayInner (line 453) | function updateDisplayInner(cm, changes, visible, forced) {
function updateHeightsInViewport (line 546) | function updateHeightsInViewport(cm) {
function updateViewOffset (line 569) | function updateViewOffset(cm) {
function computeIntact (line 575) | function computeIntact(intact, changes) {
function getDimensions (line 596) | function getDimensions(cm) {
function patchDisplay (line 609) | function patchDisplay(cm, from, to, intact, updateNumbersFrom) {
function buildLineElement (line 676) | function buildLineElement(cm, line, lineNo, dims, reuse) {
function positionLineWidget (line 754) | function positionLineWidget(widget, node, wrap, dims) {
function updateSelection (line 774) | function updateSelection(cm) {
function updateSelectionCursor (line 798) | function updateSelectionCursor(cm) {
function updateSelectionRange (line 814) | function updateSelectionRange(cm) {
function restartBlink (line 886) | function restartBlink(cm) {
function startWorker (line 900) | function startWorker(cm, time) {
function highlightWorker (line 905) | function highlightWorker(cm) {
function findStartLine (line 945) | function findStartLine(cm, n, precise) {
function getStateBefore (line 961) | function getStateBefore(cm, n, precise) {
function paddingTop (line 979) | function paddingTop(display) {return display.lineSpace.offsetTop;}
function paddingVert (line 980) | function paddingVert(display) {return display.mover.offsetHeight - displ...
function paddingLeft (line 981) | function paddingLeft(display) {
function measureChar (line 986) | function measureChar(cm, line, ch, data, bias) {
function findCachedMeasurement (line 1008) | function findCachedMeasurement(cm, line) {
function clearCachedMeasurement (line 1019) | function clearCachedMeasurement(cm, line) {
function measureLine (line 1024) | function measureLine(cm, line) {
function measureLineInner (line 1040) | function measureLineInner(cm, line) {
function crudelyMeasureLine (line 1130) | function crudelyMeasureLine(cm, line) {
function measureLineWidth (line 1139) | function measureLineWidth(cm, line) {
function clearCaches (line 1155) | function clearCaches(cm) {
function pageScrollX (line 1162) | function pageScrollX() { return window.pageXOffset || (document.document...
function pageScrollY (line 1163) | function pageScrollY() { return window.pageYOffset || (document.document...
function intoCoordSystem (line 1166) | function intoCoordSystem(cm, lineObj, rect, context) {
function fromCoordSystem (line 1188) | function fromCoordSystem(cm, coords, context) {
function charCoords (line 1205) | function charCoords(cm, pos, context, lineObj, bias) {
function cursorCoords (line 1210) | function cursorCoords(cm, pos, context, lineObj, measurement) {
function PosWithInfo (line 1240) | function PosWithInfo(line, ch, outside, xRel) {
function coordsChar (line 1248) | function coordsChar(cm, x, y) {
function coordsCharInner (line 1269) | function coordsCharInner(cm, lineObj, lineNo, x, y) {
function textHeight (line 1311) | function textHeight(display) {
function charWidth (line 1330) | function charWidth(display) {
function startOperation (line 1348) | function startOperation(cm) {
function endOperation (line 1366) | function endOperation(cm) {
function operation (line 1426) | function operation(cm1, f) {
function docOperation (line 1435) | function docOperation(f) {
function runInOp (line 1444) | function runInOp(cm, f) {
function regChange (line 1452) | function regChange(cm, from, to, lendiff) {
function slowPoll (line 1460) | function slowPoll(cm) {
function fastPoll (line 1468) | function fastPoll(cm) {
function readInput (line 1484) | function readInput(cm) {
function resetInput (line 1523) | function resetInput(cm, user) {
function focusInput (line 1540) | function focusInput(cm) {
function isReadOnly (line 1545) | function isReadOnly(cm) {
function registerEventHandlers (line 1551) | function registerEventHandlers(cm) {
function eventInWidget (line 1678) | function eventInWidget(display, e) {
function posFromMouse (line 1684) | function posFromMouse(cm, e, liberal) {
function onMouseDown (line 1699) | function onMouseDown(e) {
function gutterEvent (line 1840) | function gutterEvent(cm, e, type, prevent, signalfn) {
function contextMenuInGutter (line 1863) | function contextMenuInGutter(cm, e) {
function clickInGutter (line 1868) | function clickInGutter(cm, e) {
function onDrop (line 1876) | function onDrop(e) {
function onDragStart (line 1920) | function onDragStart(cm, e) {
function setScrollTop (line 1943) | function setScrollTop(cm, val) {
function setScrollLeft (line 1952) | function setScrollLeft(cm, val, isScroller) {
function onScrollWheel (line 1982) | function onScrollWheel(cm, e) {
function doHandleBinding (line 2050) | function doHandleBinding(cm, bound, dropShift) {
function allKeyMaps (line 2070) | function allKeyMaps(cm) {
function handleKeyBinding (line 2078) | function handleKeyBinding(cm, e) {
function handleCharBinding (line 2115) | function handleCharBinding(cm, e, ch) {
function onKeyDown (line 2127) | function onKeyDown(e) {
function onKeyPress (line 2145) | function onKeyPress(e) {
function onFocus (line 2161) | function onFocus(cm) {
function onBlur (line 2176) | function onBlur(cm) {
function onContextMenu (line 2187) | function onContextMenu(cm, e) {
function clipPostChange (line 2260) | function clipPostChange(doc, change, pos) {
function computeSelAfterChange (line 2276) | function computeSelAfterChange(doc, change, hint) {
function filterChange (line 2299) | function filterChange(doc, change, update) {
function makeChange (line 2323) | function makeChange(doc, change, selUpdate, ignoreReadOnly) {
function makeChangeNoReadonly (line 2347) | function makeChangeNoReadonly(doc, change, selUpdate) {
function makeChangeFromHistory (line 2364) | function makeChangeFromHistory(doc, type) {
function shiftDoc (line 2404) | function shiftDoc(doc, distance) {
function makeChangeSingleDoc (line 2412) | function makeChangeSingleDoc(doc, change, selAfter, spans) {
function makeChangeSingleDocInEditor (line 2442) | function makeChangeSingleDocInEditor(cm, change, spans, selAfter) {
function replaceRange (line 2494) | function replaceRange(doc, code, from, to, origin) {
function Pos (line 2503) | function Pos(line, ch) {
function posEq (line 2509) | function posEq(a, b) {return a.line == b.line && a.ch == b.ch;}
function posLess (line 2510) | function posLess(a, b) {return a.line < b.line || (a.line == b.line && a...
function copyPos (line 2511) | function copyPos(x) {return Pos(x.line, x.ch);}
function clipLine (line 2515) | function clipLine(doc, n) {return Math.max(doc.first, Math.min(n, doc.fi...
function clipPos (line 2516) | function clipPos(doc, pos) {
function clipToLen (line 2522) | function clipToLen(pos, linelen) {
function isLine (line 2528) | function isLine(doc, l) {return l >= doc.first && l < doc.first + doc.si...
function extendSelection (line 2532) | function extendSelection(doc, pos, other, bias) {
function filterSelectionChange (line 2551) | function filterSelectionChange(doc, anchor, head) {
function setSelection (line 2562) | function setSelection(doc, anchor, head, bias, checkAtomic) {
function reCheckSelection (line 2592) | function reCheckSelection(cm) {
function skipAtomic (line 2596) | function skipAtomic(doc, pos, bias, mayClear) {
function scrollCursorIntoView (line 2648) | function scrollCursorIntoView(cm) {
function scrollPosIntoView (line 2666) | function scrollPosIntoView(cm, pos, end, margin) {
function scrollIntoView (line 2688) | function scrollIntoView(cm, x1, y1, x2, y2) {
function calculateScrollPos (line 2694) | function calculateScrollPos(cm, x1, y1, x2, y2) {
function updateScrollPos (line 2720) | function updateScrollPos(cm, left, top) {
function addToScrollPos (line 2725) | function addToScrollPos(cm, left, top) {
function indentLine (line 2734) | function indentLine(cm, n, how, aggressive) {
function changeLine (line 2776) | function changeLine(cm, handle, op) {
function findPosH (line 2786) | function findPosH(doc, pos, dir, unit, visually) {
function findPosV (line 2831) | function findPosV(cm, pos, dir, unit) {
function findWordAt (line 2848) | function findWordAt(line, pos) {
function selectLine (line 2862) | function selectLine(cm, line) {
function interpret (line 3215) | function interpret(val) {
function option (line 3260) | function option(name, deflt, handle, notOnInit) {
function copyState (line 3446) | function copyState(mode, state) {
function startState (line 3459) | function startState(mode, a1, a2) {
function getKeyMap (line 3601) | function getKeyMap(val) {
function lookupKey (line 3606) | function lookupKey(name, maps, handle) {
function isModifierKey (line 3630) | function isModifierKey(event) {
function keyName (line 3634) | function keyName(event, noShift) {
function save (line 3667) | function save() {textarea.value = cm.getValue();}
function StringStream (line 3709) | function StringStream(string, tabSize) {
function TextMarker (line 3775) | function TextMarker(doc, type) {
function markText (line 3869) | function markText(doc, from, to, options, type) {
function SharedTextMarker (line 3933) | function SharedTextMarker(markers, primary) {
function markTextShared (line 3955) | function markTextShared(doc, from, to, options, type) {
function getMarkedSpanFor (line 3972) | function getMarkedSpanFor(spans, marker) {
function removeMarkedSpan (line 3978) | function removeMarkedSpan(spans, span) {
function addMarkedSpan (line 3983) | function addMarkedSpan(line, span) {
function markedSpansBefore (line 3988) | function markedSpansBefore(old, startCh, isInsert) {
function markedSpansAfter (line 4004) | function markedSpansAfter(old, endCh, isInsert) {
function stretchSpansOverChange (line 4018) | function stretchSpansOverChange(doc, change) {
function mergeOldSpans (line 4081) | function mergeOldSpans(doc, change) {
function removeReadOnlyRanges (line 4103) | function removeReadOnlyRanges(doc, from, to) {
function collapsedSpanAt (line 4131) | function collapsedSpanAt(line, ch) {
function collapsedSpanAtStart (line 4143) | function collapsedSpanAtStart(line) { return collapsedSpanAt(line, -1); }
function collapsedSpanAtEnd (line 4144) | function collapsedSpanAtEnd(line) { return collapsedSpanAt(line, line.te...
function visualLine (line 4146) | function visualLine(doc, line) {
function lineIsHidden (line 4153) | function lineIsHidden(doc, line) {
function lineIsHiddenInner (line 4164) | function lineIsHiddenInner(doc, line, span) {
function detachMarkedSpans (line 4179) | function detachMarkedSpans(line) {
function attachMarkedSpans (line 4187) | function attachMarkedSpans(line, spans) {
function widgetOperation (line 4203) | function widgetOperation(f) {
function widgetHeight (line 4232) | function widgetHeight(widget) {
function addLineWidget (line 4239) | function addLineWidget(cm, handle, node, options) {
function updateLine (line 4269) | function updateLine(line, text, markedSpans, estimateHeight) {
function cleanUpLine (line 4280) | function cleanUpLine(line) {
function runMode (line 4288) | function runMode(cm, text, mode, state, f, forceToEnd) {
function highlightLine (line 4317) | function highlightLine(cm, line, state, forceToEnd) {
function getLineStyles (line 4355) | function getLineStyles(cm, line) {
function processLine (line 4363) | function processLine(cm, text, state, startAt) {
function interpretTokenStyle (line 4375) | function interpretTokenStyle(style, builder) {
function buildLineContent (line 4391) | function buildLineContent(cm, realLine, measure, copyWidgets) {
function defaultSpecialCharPlaceholder (line 4442) | function defaultSpecialCharPlaceholder(ch) {
function buildToken (line 4448) | function buildToken(builder, text, style, startStyle, endStyle, title) {
function buildTokenMeasure (line 4488) | function buildTokenMeasure(builder, text, style, startStyle, endStyle) {
function buildTokenSplitSpaces (line 4514) | function buildTokenSplitSpaces(inner) {
function buildCollapsedSpan (line 4526) | function buildCollapsedSpan(builder, size, marker, ignoreWidget) {
function insertLineContent (line 4551) | function insertLineContent(line, builder, styles) {
function updateDoc (line 4612) | function updateDoc(doc, change, markedSpans, selAfter, estimateHeight) {
function LeafChunk (line 4659) | function LeafChunk(lines) {
function BranchChunk (line 4694) | function BranchChunk(children) {
function linkedDocs (line 5035) | function linkedDocs(doc, f, sharedHistOnly) {
function attachDoc (line 5049) | function attachDoc(cm, doc) {
function getLine (line 5062) | function getLine(chunk, n) {
function getBetween (line 5074) | function getBetween(doc, start, end) {
function getLines (line 5085) | function getLines(doc, from, to) {
function updateLineHeight (line 5091) | function updateLineHeight(line, height) {
function lineNo (line 5096) | function lineNo(line) {
function lineAtHeight (line 5108) | function lineAtHeight(chunk, h) {
function heightAtLine (line 5127) | function heightAtLine(cm, lineObj) {
function getOrder (line 5146) | function getOrder(line) {
function makeHistory (line 5154) | function makeHistory(startGen) {
function attachLocalSpans (line 5168) | function attachLocalSpans(doc, change, from, to) {
function historyChangeFromChange (line 5177) | function historyChangeFromChange(doc, change) {
function addToHistory (line 5185) | function addToHistory(doc, change, selAfter, opId) {
function removeClearedSpans (line 5222) | function removeClearedSpans(spans) {
function getOldSpans (line 5231) | function getOldSpans(doc, change) {
function copyHistoryArray (line 5241) | function copyHistoryArray(events, newGroup) {
function rebaseHistSel (line 5262) | function rebaseHistSel(pos, from, to, diff) {
function rebaseHistArray (line 5278) | function rebaseHistArray(array, from, to, diff) {
function rebaseHist (line 5307) | function rebaseHist(hist, change) {
function stopMethod (line 5315) | function stopMethod() {e_stop(this);}
function addStop (line 5317) | function addStop(event) {
function e_preventDefault (line 5322) | function e_preventDefault(e) {
function e_stopPropagation (line 5326) | function e_stopPropagation(e) {
function e_defaultPrevented (line 5330) | function e_defaultPrevented(e) {
function e_stop (line 5333) | function e_stop(e) {e_preventDefault(e); e_stopPropagation(e);}
function e_target (line 5338) | function e_target(e) {return e.target || e.srcElement;}
function e_button (line 5339) | function e_button(e) {
function on (line 5352) | function on(emitter, type, f) {
function off (line 5364) | function off(emitter, type, f) {
function signal (line 5377) | function signal(emitter, type /*, values...*/) {
function signalLater (line 5385) | function signalLater(emitter, type /*, values...*/) {
function signalDOMEvent (line 5399) | function signalDOMEvent(cm, e, override) {
function fireDelayed (line 5404) | function fireDelayed() {
function hasHandler (line 5411) | function hasHandler(emitter, type) {
function eventMixin (line 5418) | function eventMixin(ctor) {
function Delayed (line 5432) | function Delayed() {this.id = null;}
function countColumn (line 5437) | function countColumn(string, end, tabSize, startIndex, startValue) {
function spaceStr (line 5451) | function spaceStr(n) {
function lst (line 5457) | function lst(arr) { return arr[arr.length-1]; }
function selectInput (line 5459) | function selectInput(node) {
function indexOf (line 5470) | function indexOf(collection, elt) {
function createObj (line 5477) | function createObj(base, props) {
function copyObj (line 5485) | function copyObj(obj, target) {
function emptyArray (line 5491) | function emptyArray(size) {
function bind (line 5496) | function bind(f) {
function isWordChar (line 5502) | function isWordChar(ch) {
function isEmpty (line 5507) | function isEmpty(obj) {
function elt (line 5516) | function elt(tag, content, className, style) {
function removeChildren (line 5525) | function removeChildren(e) {
function removeChildrenAndAdd (line 5531) | function removeChildrenAndAdd(parent, e) {
function setTextContent (line 5535) | function setTextContent(e, str) {
function getRect (line 5542) | function getRect(node) {
function spanAffectsWrapping (line 5565) | function spanAffectsWrapping() { return false; }
function scrollbarWidth (line 5589) | function scrollbarWidth(measure) {
function zeroWidthElement (line 5599) | function zeroWidthElement(measure) {
function iterateBidiSections (line 5669) | function iterateBidiSections(order, from, to, f) {
function bidiLeft (line 5682) | function bidiLeft(part) { return part.level % 2 ? part.to : part.from; }
function bidiRight (line 5683) | function bidiRight(part) { return part.level % 2 ? part.from : part.to; }
function lineLeft (line 5685) | function lineLeft(line) { var order = getOrder(line); return order ? bid...
function lineRight (line 5686) | function lineRight(line) {
function lineStart (line 5692) | function lineStart(cm, lineN) {
function lineEnd (line 5700) | function lineEnd(cm, lineN) {
function compareBidiLevel (line 5709) | function compareBidiLevel(order, a, b) {
function getBidiPartAt (line 5716) | function getBidiPartAt(order, pos) {
function moveInLine (line 5736) | function moveInLine(line, pos, dir, byUnit) {
function moveVisually (line 5749) | function moveVisually(line, start, dir, byUnit) {
function moveLogically (line 5772) | function moveLogically(line, start, dir, byUnit) {
function charType (line 5806) | function charType(code) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/asterisk/asterisk.js
function basicToken (line 53) | function basicToken(stream,state){
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/clike/clike.js
function tokenBase (line 15) | function tokenBase(stream, state) {
function tokenString (line 61) | function tokenString(quote) {
function tokenComment (line 74) | function tokenComment(stream, state) {
function Context (line 86) | function Context(indented, column, type, align, prev) {
function pushContext (line 93) | function pushContext(state, col, type) {
function popContext (line 99) | function popContext(state) {
function words (line 167) | function words(str) {
function cppHook (line 176) | function cppHook(stream, state) {
function tokenAtString (line 195) | function tokenAtString(stream, state) {
function mimes (line 206) | function mimes(ms, mode) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/clojure/clojure.js
function makeKeywords (line 10) | function makeKeywords(str) {
function stateStack (line 50) | function stateStack(indent, type, prev) { // represents a state stack ob...
function pushStack (line 56) | function pushStack(state, indent, type) {
function popStack (line 60) | function popStack(state) {
function isNumber (line 64) | function isNumber(ch, stream){
function eatCharacter (line 98) | function eatCharacter(stream) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/cobol/cobol.js
function makeKeywords (line 9) | function makeKeywords(str) {
function isNumber (line 137) | function isNumber(ch, stream){
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/coffeescript/coffeescript.js
function wordRegexp (line 8) | function wordRegexp(words) {
function tokenBase (line 37) | function tokenBase(stream, state) {
function tokenFactory (line 164) | function tokenFactory(delimiter, outclass) {
function longComment (line 192) | function longComment(stream, state) {
function indent (line 204) | function indent(stream, state, type) {
function dedent (line 228) | function dedent(stream, state) {
function tokenLexer (line 252) | function tokenLexer(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/commonlisp/commonlisp.js
function readSym (line 7) | function readSym(stream) {
function base (line 16) | function base(stream, state) {
function inString (line 49) | function inString(stream, state) {
function inComment (line 58) | function inComment(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/css/css.js
function ret (line 16) | function ret(style, tp) { type = tp; return style; }
function tokenBase (line 18) | function tokenBase(stream, state) {
function tokenString (line 75) | function tokenString(quote, nonInclusive) {
function tokenParenthesized (line 91) | function tokenParenthesized(stream, state) {
function keySet (line 316) | function keySet(array) {
function tokenCComment (line 544) | function tokenCComment(stream, state) {
function tokenSGMLComment (line 564) | function tokenSGMLComment(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/css/scss_test.js
function MT (line 3) | function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arg...
function IT (line 4) | function IT(name) { test.indentation(name, mode, Array.prototype.slice.c...
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/css/test.js
function MT (line 3) | function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arg...
function IT (line 4) | function IT(name) { test.indentation(name, mode, Array.prototype.slice.c...
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/d/d.js
function tokenBase (line 14) | function tokenBase(stream, state) {
function tokenString (line 64) | function tokenString(quote) {
function tokenComment (line 77) | function tokenComment(stream, state) {
function tokenNestedComment (line 89) | function tokenNestedComment(stream, state) {
function Context (line 101) | function Context(indented, column, type, align, prev) {
function pushContext (line 108) | function pushContext(state, col, type) {
function popContext (line 114) | function popContext(state) {
function words (line 177) | function words(str) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/dtd/dtd.js
function ret (line 10) | function ret(style, tp) {type = tp; return style;}
function tokenBase (line 12) | function tokenBase(stream, state) {
function tokenSGMLComment (line 41) | function tokenSGMLComment(stream, state) {
function tokenString (line 53) | function tokenString(quote) {
function inBlock (line 67) | function inBlock(style, terminator) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/ecl/ecl.js
function words (line 3) | function words(str) {
function metaHook (line 9) | function metaHook(stream, state) {
function tokenBase (line 29) | function tokenBase(stream, state) {
function tokenString (line 95) | function tokenString(quote) {
function tokenComment (line 108) | function tokenComment(stream, state) {
function Context (line 120) | function Context(indented, column, type, align, prev) {
function pushContext (line 127) | function pushContext(state, col, type) {
function popContext (line 130) | function popContext(state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/eiffel/eiffel.js
function wordObj (line 2) | function wordObj(words) {
function chain (line 76) | function chain(newtok, stream, state) {
function tokenBase (line 81) | function tokenBase(stream, state) {
function readQuoted (line 108) | function readQuoted(quote, style, unescaped) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/erlang/erlang.js
function rval (line 14) | function rval(state,_stream,type) {
function tokenize (line 108) | function tokenize(stream, state) {
function isPrev (line 280) | function isPrev(stream,string) {
function nongreedy (line 291) | function nongreedy(stream,re,words) {
function greedy (line 305) | function greedy(stream,re,words) {
function doubleQuote (line 322) | function doubleQuote(stream) {
function singleQuote (line 326) | function singleQuote(stream) {
function quote (line 330) | function quote(stream,quoteChar,escapeChar) {
function isMember (line 342) | function isMember(element,list) {
function myIndent (line 347) | function myIndent(state,textAfter) {
function takewhile (line 379) | function takewhile(str,re) {
function Token (line 384) | function Token(stream) {
function popToken (line 390) | function popToken(state) {
function peekToken (line 394) | function peekToken(state,depth) {
function pushToken (line 404) | function pushToken(state,stream) {
function drop_last (line 429) | function drop_last(open, close) {
function drop_first (line 436) | function drop_first(open, close) {
function drop_both (line 444) | function drop_both(open, close) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/fortran/fortran.js
function words (line 2) | function words(array) {
function tokenBase (line 104) | function tokenBase(stream, state) {
function tokenString (line 142) | function tokenString(quote) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/gas/gas.js
function x86 (line 131) | function x86(_parserConfig) {
function armv6 (line 178) | function armv6(_parserConfig) {
function nextUntilUnescaped (line 221) | function nextUntilUnescaped(stream, end) {
function clikeComment (line 232) | function clikeComment(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/gfm/gfm.js
function blankLine (line 3) | function blankLine(state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/gfm/test.js
function MT (line 3) | function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arg...
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/go/go.js
function tokenBase (line 27) | function tokenBase(stream, state) {
function tokenString (line 71) | function tokenString(quote) {
function tokenComment (line 84) | function tokenComment(stream, state) {
function Context (line 96) | function Context(indented, column, type, align, prev) {
function pushContext (line 103) | function pushContext(state, col, type) {
function popContext (line 106) | function popContext(state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/groovy/groovy.js
function words (line 2) | function words(str) {
function tokenBase (line 17) | function tokenBase(stream, state) {
function startString (line 66) | function startString(quote, stream, state) {
function tokenBaseUntilBrace (line 92) | function tokenBaseUntilBrace() {
function tokenComment (line 110) | function tokenComment(stream, state) {
function expectExpression (line 122) | function expectExpression(last) {
function Context (line 127) | function Context(indented, column, type, align, prev) {
function pushContext (line 134) | function pushContext(state, col, type) {
function popContext (line 137) | function popContext(state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/haml/haml.js
function rubyInQuote (line 9) | function rubyInQuote(endQuote) {
function ruby (line 23) | function ruby(stream, state) {
function html (line 31) | function html(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/haml/test.js
function MT (line 3) | function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arg...
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/haskell/haskell.js
function switchState (line 3) | function switchState(source, setState, f) {
function normal (line 19) | function normal(source, setState) {
function ncomment (line 110) | function ncomment(type, nest) {
function stringLiteral (line 134) | function stringLiteral(source, setState) {
function stringGap (line 157) | function stringGap(source, setState) {
function setType (line 169) | function setType(t) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/haxe/haxe.js
function kw (line 7) | function kw(type) {return {type: type, style: "keyword"};}
function chain (line 26) | function chain(stream, state, f) {
function nextUntilUnescaped (line 31) | function nextUntilUnescaped(stream, end) {
function ret (line 44) | function ret(tp, style, cont) {
function haxeTokenBase (line 49) | function haxeTokenBase(stream, state) {
function haxeTokenString (line 112) | function haxeTokenString(quote) {
function haxeTokenComment (line 120) | function haxeTokenComment(stream, state) {
function HaxeLexical (line 136) | function HaxeLexical(indented, column, type, align, prev, info) {
function inScope (line 145) | function inScope(state, varname) {
function parseHaxe (line 150) | function parseHaxe(state, style, type, content, stream) {
function imported (line 172) | function imported(state, typename)
function registerimport (line 182) | function registerimport(importname) {
function pass (line 191) | function pass() {
function cont (line 194) | function cont() {
function register (line 198) | function register(varname) {
function pushcontext (line 211) | function pushcontext() {
function popcontext (line 215) | function popcontext() {
function pushlex (line 219) | function pushlex(type, info) {
function poplex (line 227) | function poplex() {
function expect (line 237) | function expect(wanted) {
function statement (line 245) | function statement(type) {
function expression (line 267) | function expression(type) {
function maybeexpression (line 277) | function maybeexpression(type) {
function maybeoperator (line 282) | function maybeoperator(type, value) {
function maybeattribute (line 291) | function maybeattribute(type) {
function metadef (line 297) | function metadef(type) {
function metaargs (line 302) | function metaargs(type) {
function importdef (line 306) | function importdef (type, value) {
function typedef (line 311) | function typedef (type, value)
function maybelabel (line 316) | function maybelabel(type) {
function property (line 320) | function property(type) {
function objprop (line 323) | function objprop(type) {
function commasep (line 327) | function commasep(what, end) {
function block (line 338) | function block(type) {
function vardef1 (line 342) | function vardef1(type, value) {
function vardef2 (line 346) | function vardef2(type, value) {
function forspec1 (line 350) | function forspec1(type, value) {
function forin (line 356) | function forin(_type, value) {
function functiondef (line 359) | function functiondef(type, value) {
function typeuse (line 364) | function typeuse(type) {
function typestring (line 367) | function typestring(type) {
function typeprop (line 372) | function typeprop(type) {
function funarg (line 375) | function funarg(type, value) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/htmlembedded/htmlembedded.js
function htmlDispatch (line 11) | function htmlDispatch(stream, state) {
function scriptingDispatch (line 21) | function scriptingDispatch(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/htmlmixed/htmlmixed.js
function html (line 15) | function html(stream, state) {
function maybeBackup (line 41) | function maybeBackup(stream, pat, style) {
function script (line 51) | function script(stream, state) {
function css (line 60) | function css(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/http/http.js
function failFirstLine (line 2) | function failFirstLine(stream, state) {
function start (line 8) | function start(stream, state) {
function responseStatusCode (line 20) | function responseStatusCode(stream, state) {
function responseStatusText (line 41) | function responseStatusText(stream, state) {
function requestPath (line 47) | function requestPath(stream, state) {
function requestProtocol (line 53) | function requestProtocol(stream, state) {
function header (line 62) | function header(stream) {
function body (line 76) | function body(stream) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/javascript/javascript.js
function kw (line 12) | function kw(type) {return {type: type, style: "keyword"};}
function nextUntilUnescaped (line 57) | function nextUntilUnescaped(stream, end) {
function ret (line 70) | function ret(tp, style, cont) {
function tokenBase (line 74) | function tokenBase(stream, state) {
function tokenString (line 126) | function tokenString(quote) {
function tokenComment (line 134) | function tokenComment(stream, state) {
function tokenQuasi (line 146) | function tokenQuasi(stream, state) {
function findFatArrow (line 166) | function findFatArrow(stream, state) {
function JSLexical (line 194) | function JSLexical(indented, column, type, align, prev, info) {
function inScope (line 203) | function inScope(state, varname) {
function parseJS (line 212) | function parseJS(state, style, type, content, stream) {
function pass (line 236) | function pass() {
function cont (line 239) | function cont() {
function register (line 243) | function register(varname) {
function pushcontext (line 264) | function pushcontext() {
function popcontext (line 268) | function popcontext() {
function pushlex (line 272) | function pushlex(type, info) {
function poplex (line 281) | function poplex() {
function expect (line 291) | function expect(wanted) {
function statement (line 299) | function statement(type, value) {
function expression (line 321) | function expression(type) {
function expressionNoComma (line 324) | function expressionNoComma(type) {
function expressionInner (line 327) | function expressionInner(type, noComma) {
function maybeexpression (line 344) | function maybeexpression(type) {
function maybeexpressionNoComma (line 348) | function maybeexpressionNoComma(type) {
function maybeoperatorComma (line 353) | function maybeoperatorComma(type, value) {
function maybeoperatorNoComma (line 357) | function maybeoperatorNoComma(type, value, noComma) {
function quasi (line 372) | function quasi(value) {
function continueQuasi (line 377) | function continueQuasi(type) {
function arrowBody (line 384) | function arrowBody(type) {
function arrowBodyNoComma (line 389) | function arrowBodyNoComma(type) {
function maybelabel (line 394) | function maybelabel(type) {
function property (line 398) | function property(type) {
function objprop (line 401) | function objprop(type, value) {
function getterSetter (line 412) | function getterSetter(type) {
function afterprop (line 417) | function afterprop(type) {
function commasep (line 421) | function commasep(what, end, info) {
function block (line 437) | function block(type) {
function maybetype (line 441) | function maybetype(type) {
function typedef (line 444) | function typedef(type) {
function vardef (line 447) | function vardef() {
function pattern (line 450) | function pattern(type, value) {
function proppattern (line 455) | function proppattern(type, value) {
function maybeAssign (line 463) | function maybeAssign(_type, value) {
function vardefCont (line 466) | function vardefCont(type) {
function maybeelse (line 469) | function maybeelse(type, value) {
function forspec (line 472) | function forspec(type) {
function forspec1 (line 475) | function forspec1(type) {
function formaybeinof (line 481) | function formaybeinof(_type, value) {
function forspec2 (line 485) | function forspec2(type, value) {
function forspec3 (line 490) | function forspec3(type) {
function functiondef (line 493) | function functiondef(type, value) {
function funarg (line 498) | function funarg(type) {
function className (line 502) | function className(type, value) {
function classNameAfter (line 505) | function classNameAfter(_type, value) {
function objlit (line 508) | function objlit(type) {
function afterModule (line 511) | function afterModule(type, value) {
function afterExport (line 515) | function afterExport(_type, value) {
function afterImport (line 520) | function afterImport(type) {
function importSpec (line 524) | function importSpec(type, value) {
function maybeFrom (line 529) | function maybeFrom(_type, value) {
function maybeArrayComprehension (line 532) | function maybeArrayComprehension(type) {
function comprehension (line 537) | function comprehension(type) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/javascript/test.js
function MT (line 3) | function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arg...
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/jinja2/jinja2.js
function tokenBase (line 7) | function tokenBase (stream, state) {
function inTag (line 17) | function inTag (close) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/julia/julia.js
function wordRegexp (line 4) | function wordRegexp(words) {
function in_array (line 25) | function in_array(state) {
function cur_scope (line 35) | function cur_scope(state) {
function tokenBase (line 43) | function tokenBase(stream, state) {
function tokenStringFactory (line 177) | function tokenStringFactory(delimiter) {
function tokenLexer (line 212) | function tokenLexer(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/less/less.js
function ret (line 10) | function ret(style, tp) {type = tp; return style;}
function tokenBase (line 14) | function tokenBase(stream, state) {
function tokenSComment (line 244) | function tokenSComment(stream, state) { // SComment = Slash comment
function tokenCComment (line 250) | function tokenCComment(stream, state) {
function tokenSGMLComment (line 262) | function tokenSGMLComment(stream, state) {
function tokenString (line 274) | function tokenString(quote) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/lua/lua.js
function prefixRE (line 8) | function prefixRE(words) {
function wordRE (line 11) | function wordRE(words) {
function readBracket (line 57) | function readBracket(stream) {
function normal (line 64) | function normal(stream, state) {
function bracketed (line 87) | function bracketed(level, style) {
function string (line 100) | function string(quote) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/markdown/markdown.js
function switchInline (line 81) | function switchInline(stream, state, f) {
function switchBlock (line 86) | function switchBlock(stream, state, f) {
function blankLine (line 94) | function blankLine(state) {
function blockNormal (line 115) | function blockNormal(stream, state) {
function htmlBlock (line 172) | function htmlBlock(stream, state) {
function local (line 186) | function local(stream, state) {
function getType (line 201) | function getType(state) {
function handleText (line 236) | function handleText(stream, state) {
function inlineNormal (line 243) | function inlineNormal(stream, state) {
function linkHref (line 401) | function linkHref(stream, state) {
function footnoteLink (line 413) | function footnoteLink(stream, state) {
function footnoteUrl (line 421) | function footnoteUrl(stream, state) {
function inlineRE (line 439) | function inlineRE(endChar) {
function inlineElement (line 450) | function inlineElement(type, endChar, next) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/markdown/test.js
function MT (line 3) | function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arg...
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/mirc/mirc.js
function parseWords (line 4) | function parseWords(str) {
function chain (line 72) | function chain(stream, state, f) {
function tokenBase (line 76) | function tokenBase(stream, state) {
function tokenComment (line 139) | function tokenComment(stream, state) {
function tokenUnparsed (line 150) | function tokenUnparsed(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/nginx/nginx.js
function words (line 3) | function words(str) {
function ret (line 23) | function ret(style, tp) {type = tp; return style;}
function tokenBase (line 25) | function tokenBase(stream, state) {
function tokenCComment (line 84) | function tokenCComment(stream, state) {
function tokenSGMLComment (line 96) | function tokenSGMLComment(stream, state) {
function tokenString (line 108) | function tokenString(quote) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/ntriples/ntriples.js
function transitState (line 45) | function transitState(currState, c) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/ocaml/ocaml.js
function tokenBase (line 39) | function tokenBase(stream, state) {
function tokenString (line 76) | function tokenString(stream, state) {
function tokenComment (line 91) | function tokenComment(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/octave/octave.js
function wordRegexp (line 2) | function wordRegexp(words) {
function tokenTranspose (line 31) | function tokenTranspose(stream, state) {
function tokenComment (line 42) | function tokenComment(stream, state) {
function tokenBase (line 51) | function tokenBase(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/pascal/pascal.js
function words (line 2) | function words(str) {
function tokenBase (line 14) | function tokenBase(stream, state) {
function tokenString (line 52) | function tokenString(quote) {
function tokenComment (line 64) | function tokenComment(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/pegjs/pegjs.js
function identifier (line 4) | function identifier(stream) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/perl/perl.js
function tokenChain (line 469) | function tokenChain(stream,state,chain,style,tail){ // NOTE: chain.l...
function tokenSOMETHING (line 489) | function tokenSOMETHING(stream,state,string){
function tokenPerl (line 497) | function tokenPerl(stream,state){
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/php/php.js
function keywords (line 2) | function keywords(str) {
function heredoc (line 7) | function heredoc(delim) {
function dispatch (line 57) | function dispatch(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/pig/pig.js
function chain (line 15) | function chain(stream, state, f) {
function ret (line 21) | function ret(tp, style) {
function tokenComment (line 26) | function tokenComment(stream, state) {
function tokenString (line 39) | function tokenString(quote) {
function tokenBase (line 54) | function tokenBase(stream, state) {
function keywords (line 137) | function keywords(str) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/python/python.js
function wordRegexp (line 4) | function wordRegexp(words) {
function tokenBase (line 60) | function tokenBase(stream, state) {
function tokenStringFactory (line 165) | function tokenStringFactory(delimiter) {
function indent (line 200) | function indent(stream, state, type) {
function dedent (line 223) | function dedent(stream, state, type) {
function tokenLexer (line 256) | function tokenLexer(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/q/q.js
function buildRE (line 6) | function buildRE(w){return new RegExp("^("+w.join("|")+")$");}
function tokenBase (line 7) | function tokenBase(stream,state){
function tokenLineComment (line 49) | function tokenLineComment(stream,state){
function tokenBlockComment (line 52) | function tokenBlockComment(stream,state){
function tokenCommentToEOF (line 59) | function tokenCommentToEOF(stream){return stream.skipToEnd(),"comment";}
function tokenString (line 60) | function tokenString(stream,state){
function pushContext (line 69) | function pushContext(state,type,col){state.context={prev:state.context,i...
function popContext (line 70) | function popContext(state){state.indent=state.context.indent;state.conte...
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/r/r.js
function wordObj (line 2) | function wordObj(str) {
function tokenBase (line 14) | function tokenBase(stream, state) {
function tokenString (line 64) | function tokenString(quote) {
function push (line 85) | function push(state, type, stream) {
function pop (line 92) | function pop(state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/rst/rst.js
function format (line 6) | function format(string) {
function AssertException (line 13) | function AssertException(message) {
function assert (line 21) | function assert(expression, message) {
function to_normal (line 99) | function to_normal(stream, state) {
function to_explicit (line 304) | function to_explicit(stream, state) {
function to_comment (line 414) | function to_comment(stream, state) {
function to_verbatim (line 418) | function to_verbatim(stream, state) {
function as_block (line 422) | function as_block(stream, state, token) {
function to_mode (line 435) | function to_mode(stream, state) {
function context (line 454) | function context(phase, stage, mode, local) {
function change (line 458) | function change(state, tok, ctx) {
function stage (line 463) | function stage(state) {
function phase (line 467) | function phase(state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/ruby/ruby.js
function wordObj (line 2) | function wordObj(words) {
function chain (line 21) | function chain(newtok, stream, state) {
function tokenBase (line 26) | function tokenBase(stream, state) {
function tokenBaseUntilBrace (line 123) | function tokenBaseUntilBrace() {
function tokenBaseOnce (line 138) | function tokenBaseOnce() {
function readQuoted (line 149) | function readQuoted(quote, style, embed, unescaped) {
function readHereDoc (line 180) | function readHereDoc(phrase) {
function readBlockComment (line 187) | function readBlockComment(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/rust/rust.js
function r (line 27) | function r(tc, style) {
function tokenBase (line 32) | function tokenBase(stream, state) {
function tokenString (line 91) | function tokenString(stream, state) {
function tokenComment (line 105) | function tokenComment(depth) {
function pass (line 131) | function pass() {
function cont (line 134) | function cont() {
function pushlex (line 139) | function pushlex(type, info) {
function poplex (line 148) | function poplex() {
function typecx (line 156) | function typecx() { cx.state.keywords = typeKeywords; }
function valcx (line 157) | function valcx() { cx.state.keywords = valKeywords; }
function commasep (line 160) | function commasep(comb, end) {
function stat_of (line 172) | function stat_of(comb, tag) {
function block (line 175) | function block(type) {
function endstatement (line 188) | function endstatement(type) {
function expression (line 192) | function expression(type) {
function maybeop (line 205) | function maybeop(type) {
function maybeprop (line 212) | function maybeprop() {
function exprbrace (line 216) | function exprbrace(type) {
function record_of (line 226) | function record_of(comb) {
function blockvars (line 236) | function blockvars(type) {
function letdef1 (line 242) | function letdef1(type) {
function letdef2 (line 248) | function letdef2(type) {
function maybetype (line 252) | function maybetype(type) {
function inop (line 256) | function inop(type) {
function fndef (line 260) | function fndef(type) {
function tydef (line 270) | function tydef(type) {
function enumdef (line 276) | function enumdef(type) {
function enumblock (line 283) | function enumblock(type) {
function mod (line 289) | function mod(type) {
function iface (line 294) | function iface(type) {
function impl (line 300) | function impl(type) {
function typarams (line 307) | function typarams() {
function argdef (line 313) | function argdef(type) {
function rtype (line 318) | function rtype(type) {
function rtypemaybeparam (line 327) | function rtypemaybeparam() {
function fntype (line 331) | function fntype(type) {
function pattern (line 336) | function pattern(type) {
function patternmaybeop (line 343) | function patternmaybeop(type) {
function altbody (line 348) | function altbody(type) {
function altblock1 (line 352) | function altblock1(type) {
function altblock2 (line 359) | function altblock2(type) {
function macro (line 364) | function macro(type) {
function matchBrackets (line 368) | function matchBrackets(type, comb) {
function parse (line 375) | function parse(state, stream, style) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/sass/sass.js
function stringTokenizer (line 49) | function stringTokenizer(stream, state){
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/scheme/scheme.js
function makeKeywords (line 9) | function makeKeywords(str) {
function stateStack (line 18) | function stateStack(indent, type, prev) { // represents a state stack ob...
function pushStack (line 24) | function pushStack(state, indent, type) {
function popStack (line 28) | function popStack(state) {
function isBinaryNumber (line 37) | function isBinaryNumber (stream) {
function isOctalNumber (line 41) | function isOctalNumber (stream) {
function isDecimalNumber (line 45) | function isDecimalNumber (stream, backup) {
function isHexNumber (line 52) | function isHexNumber (stream) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/shell/shell.js
function define (line 4) | function define(style, string) {
function tokenBase (line 25) | function tokenBase(stream, state) {
function tokenString (line 66) | function tokenString(quote) {
function tokenize (line 105) | function tokenize(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/sieve/sieve.js
function words (line 7) | function words(str) {
function tokenBase (line 17) | function tokenBase(stream, state) {
function tokenMultiLineString (line 104) | function tokenMultiLineString(stream, state)
function tokenCComment (line 129) | function tokenCComment(stream, state) {
function tokenString (line 141) | function tokenString(quote) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/sparql/sparql.js
function wordRegexp (line 5) | function wordRegexp(words) {
function tokenBase (line 17) | function tokenBase(stream, state) {
function tokenLiteral (line 64) | function tokenLiteral(quote) {
function pushContext (line 78) | function pushContext(state, type, col) {
function popContext (line 81) | function popContext(state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/sql/sql.js
function tokenBase (line 13) | function tokenBase(stream, state) {
function tokenLiteral (line 107) | function tokenLiteral(quote) {
function tokenComment (line 120) | function tokenComment(stream, state) {
function pushContext (line 136) | function pushContext(stream, state, type) {
function popContext (line 145) | function popContext(state) {
function hookIdentifier (line 195) | function hookIdentifier(stream) {
function hookVar (line 206) | function hookVar(stream) {
function hookClient (line 233) | function hookClient(stream) {
function set (line 248) | function set(str) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/stex/stex.js
function pushCommand (line 9) | function pushCommand(state, command) {
function peekCommand (line 13) | function peekCommand(state) {
function popCommand (line 21) | function popCommand(state) {
function getMostPowerful (line 29) | function getMostPowerful(state) {
function addPluginPattern (line 41) | function addPluginPattern(pluginName, cmdStyle, styles) {
function setState (line 75) | function setState(state, f) {
function normal (line 80) | function normal(source, state) {
function inCComment (line 153) | function inCComment(source, state) {
function inMathMode (line 159) | function inMathMode(source, state, endModeSeq) {
function beginParams (line 207) | function beginParams(source, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/stex/test.js
function MT (line 3) | function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arg...
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/tcl/tcl.js
function parseWords (line 3) | function parseWords(str) {
function chain (line 23) | function chain(stream, state, f) {
function tokenBase (line 27) | function tokenBase(stream, state) {
function tokenString (line 78) | function tokenString(quote) {
function tokenComment (line 92) | function tokenComment(stream, state) {
function tokenUnparsed (line 103) | function tokenUnparsed(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/tiddlywiki/tiddlywiki.js
function kw (line 22) | function kw(type) {
function chain (line 55) | function chain(stream, state, f) {
function ret (line 64) | function ret(tp, style, cont) {
function jsTokenBase (line 70) | function jsTokenBase(stream, state) {
function twTokenComment (line 207) | function twTokenComment(stream, state) {
function twTokenStrong (line 221) | function twTokenStrong(stream, state) {
function twTokenCode (line 235) | function twTokenCode(stream, state) {
function twTokenEm (line 257) | function twTokenEm(stream, state) {
function twTokenUnderline (line 271) | function twTokenUnderline(stream, state) {
function twTokenStrike (line 286) | function twTokenStrike(stream, state) {
function twTokenMacro (line 300) | function twTokenMacro(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/tiki/tiki.js
function inBlock (line 2) | function inBlock(style, terminator, returnTokenizer) {
function inLine (line 18) | function inLine(style) {
function inText (line 28) | function inText(stream, state) {
function inPlugin (line 131) | function inPlugin(stream, state) {
function inAttribute (line 165) | function inAttribute(quote) {
function inAttributeNoQuote (line 177) | function inAttributeNoQuote() {
function pass (line 192) | function pass() {
function cont (line 196) | function cont() {
function pushContext (line 201) | function pushContext(pluginName, startOfLine) {
function popContext (line 212) | function popContext() {
function element (line 216) | function element(type) {
function endplugin (line 237) | function endplugin(startOfLine) {
function endcloseplugin (line 249) | function endcloseplugin(err) {
function attributes (line 257) | function attributes(type) {
function attvalue (line 262) | function attvalue(type) {
function attvaluemaybe (line 267) | function attvaluemaybe(type) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/turtle/turtle.js
function wordRegexp (line 5) | function wordRegexp(words) {
function tokenBase (line 12) | function tokenBase(stream, state) {
function tokenLiteral (line 64) | function tokenLiteral(quote) {
function pushContext (line 78) | function pushContext(state, type, col) {
function popContext (line 81) | function popContext(state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/vb/vb.js
function wordRegexp (line 4) | function wordRegexp(words) {
function indent (line 40) | function indent(_stream, state) {
function dedent (line 44) | function dedent(_stream, state) {
function tokenBase (line 48) | function tokenBase(stream, state) {
function tokenStringFactory (line 158) | function tokenStringFactory(delimiter) {
function tokenLexer (line 184) | function tokenLexer(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/vbscript/vbscript.js
function wordRegexp (line 14) | function wordRegexp(words) {
function indent (line 94) | function indent(_stream, state) {
function dedent (line 98) | function dedent(_stream, state) {
function tokenBase (line 102) | function tokenBase(stream, state) {
function tokenStringFactory (line 245) | function tokenStringFactory(delimiter) {
function tokenLexer (line 271) | function tokenLexer(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/velocity/velocity.js
function parseWords (line 2) | function parseWords(str) {
function chain (line 15) | function chain(stream, state, f) {
function tokenBase (line 19) | function tokenBase(stream, state) {
function tokenString (line 116) | function tokenString(quote) {
function tokenComment (line 136) | function tokenComment(stream, state) {
function tokenUnparsed (line 148) | function tokenUnparsed(stream, state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/verilog/verilog.js
function tokenBase (line 12) | function tokenBase(stream, state) {
function tokenString (line 54) | function tokenString(quote) {
function tokenComment (line 67) | function tokenComment(stream, state) {
function Context (line 79) | function Context(indented, column, type, align, prev) {
function pushContext (line 86) | function pushContext(state, col, type) {
function popContext (line 89) | function popContext(state) {
function words (line 150) | function words(str) {
function metaHook (line 170) | function metaHook(stream) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/xml/xml.js
function inText (line 50) | function inText(stream, state) {
function inTag (line 102) | function inTag(stream, state) {
function inAttribute (line 125) | function inAttribute(quote) {
function inBlock (line 139) | function inBlock(style, terminator) {
function doctype (line 151) | function doctype(depth) {
function pass (line 173) | function pass() {
function cont (line 176) | function cont() {
function pushContext (line 181) | function pushContext(tagName, startOfLine) {
function popContext (line 191) | function popContext() {
function element (line 195) | function element(type) {
function endtag (line 217) | function endtag(startOfLine) {
function endclosetag (line 234) | function endclosetag(err) {
function maybePopContext (line 242) | function maybePopContext(nextTagName) {
function attributes (line 257) | function attributes(type) {
function attribute (line 263) | function attribute(type) {
function attvalue (line 269) | function attvalue(type) {
function attvaluemaybe (line 275) | function attvaluemaybe(type) {
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/xquery/test.js
function MT (line 8) | function MT(name) { test.mode(name, mode, Array.prototype.slice.call(arg...
FILE: debuggers/browser/static/lib/codemirror-3.20/mode/xquery/xquery.js
function kw (line 8) | function kw(type) {return {type: type, style: "keyword"};}
function ret (line 62) | function ret(tp, style, cont) {
function chain (line 67) | function chain(stream, state, f) {
function tokenBase (line 73) | function tokenBase(stream, state) {
function tokenComment (line 207) | function tokenComment(stream, state) {
function tokenString (line 230) | function tokenString(quote, f) {
function tokenVariable (line 270) | function tokenVariable(stream, state) {
function tokenTag (line 287) | function tokenTag(name, isclose) {
function tokenAttribute (line 310) | function tokenAttribute(stream, state) {
function tokenXMLComment (line 345) | function tokenXMLComment(stream, state) {
function tokenCDATA (line 357) | function tokenCDATA(stream, state) {
function tokenPreProcessing (line 368) | function tokenPreProcessing(stream, state) {
function isInXmlBlock (line 380) | function isInXmlBlock(state) { return isIn(state, "tag"); }
function isInXmlAttributeBlock (line 381) | function isInXmlAttributeBlock(state) { return isIn(state, "attribute"); }
function isInXmlConstructor (line 382) | function isInXmlConstructor(state) { return isIn(state, "xmlconstructor"...
function isInString (line 383) | function isInString(state) { return isIn(state, "string"); }
function isEQNameAhead (line 385) | function isEQNameAhead(stream) {
function isIn (line 395) | function isIn(state, type) {
function pushStateStack (line 399) | function pushStateStack(state, newState) {
function popStateStack (line 403) | function popStateStack(state) {
FILE: debuggers/browser/static/lib/codemirror-3.20/test/comment_test.js
function test (line 4) | function test(name, mode, run, before, after) {
FILE: debuggers/browser/static/lib/codemirror-3.20/test/doc_test.js
function instantiateSpec (line 3) | function instantiateSpec(spec, place, opts) {
function clone (line 30) | function clone(obj, props) {
function eqAll (line 39) | function eqAll(val) {
function testDoc (line 48) | function testDoc(name, spec, run, opts, expectFail) {
function testBasic (line 73) | function testBasic(a, b) {
FILE: debuggers/browser/static/lib/codemirror-3.20/test/driver.js
function Failure (line 3) | function Failure(why) {this.message = why;}
function indexOf (line 6) | function indexOf(collection, elt) {
function test (line 13) | function test(name, run, expectedFail) {
function testCM (line 27) | function testCM(name, run, opts, expectedFail) {
function runTests (line 44) | function runTests(callback) {
function label (line 111) | function label(str, msg) {
function eq (line 115) | function eq(a, b, msg) {
function eqPos (line 118) | function eqPos(a, b, msg) {
function is (line 125) | function is(a, msg) {
function countTests (line 129) | function countTests() {
FILE: debuggers/browser/static/lib/codemirror-3.20/test/emacs_test.js
function fakeEvent (line 8) | function fakeEvent(keyName) {
function sim (line 30) | function sim(name, start /*, actions... */) {
function at (line 42) | function at(line, ch) { return function(cm) { eqPos(cm.getCursor(), Pos(...
function txt (line 43) | function txt(str) { return function(cm) { eq(cm.getValue(), str); }; }
FILE: debuggers/browser/static/lib/codemirror-3.20/test/lint/acorn.js
function raise (line 174) | function raise(pos, message) {
function makePredicate (line 282) | function makePredicate(words) {
function isIdentifierStart (line 365) | function isIdentifierStart(code) {
function isIdentifierChar (line 375) | function isIdentifierChar(code) {
function nextLineStart (line 391) | function nextLineStart() {
function curLineLoc (line 397) | function curLineLoc() {
function initTokenState (line 408) | function initTokenState() {
function finishToken (line 422) | function finishToken(type, val) {
function skipBlockComment (line 432) | function skipBlockComment() {
function skipLineComment (line 440) | function skipLineComment() {
function skipSpace (line 454) | function skipSpace() {
function readToken (line 489) | function readToken(forceRegexp) {
function finishOp (line 588) | function finishOp(type, size) {
function readRegexp (line 597) | function readRegexp() {
function readInt (line 624) | function readInt(radix, len) {
function readHexNumber (line 641) | function readHexNumber() {
function readNumber (line 651) | function readNumber(ch) {
function readString (line 678) | function readString(quote) {
function readHexChar (line 726) | function readHexChar(len) {
function readWord1 (line 744) | function readWord1() {
function readWord (line 775) | function readWord() {
function next (line 812) | function next() {
function setStrict (line 822) | function setStrict(strct) {
function startNode (line 832) | function startNode() {
function startNodeFrom (line 850) | function startNodeFrom(other) {
function finishNode (line 874) | function finishNode(node, type) {
function isUseStrict (line 896) | function isUseStrict(stmt) {
function eat (line 904) | function eat(type) {
function canInsertSemicolon (line 913) | function canInsertSemicolon() {
function semicolon (line 921) | function semicolon() {
function expect (line 928) | function expect(type) {
function unexpected (line 935) | function unexpected() {
function checkLVal (line 942) | function checkLVal(expr) {
function parseTopLevel (line 956) | function parseTopLevel(program) {
function parseStatement (line 984) | function parseStatement() {
function parseParenExpression
Condensed preview — 563 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (8,752K chars).
[
{
"path": ".gitignore",
"chars": 109,
"preview": ".#*\nnpm-debug.log\nnode_modules\n\ntest/mocha.js\ntest/mocha.css\n\ntest/tests.es5.js\ntest/tests.browser.js\n\n.idea\n"
},
{
"path": ".travis.yml",
"chars": 69,
"preview": "language: node_js\nnode_js:\n - \"0.11\"\n - \"0.10\"\n - \"0.8\"\n - \"0.6\"\n"
},
{
"path": "LICENSE",
"chars": 1334,
"preview": "BSD License\n\nFor \"regenerator\" software\n\nCopyright (c) 2013, Facebook, Inc.\nAll rights reserved.\n\nRedistribution and use"
},
{
"path": "README.md",
"chars": 4120,
"preview": "\n# unwinder\n\nAn implementation of continuations in JavaScript. Includes built-in\nsupport for breakpoints (implemented wi"
},
{
"path": "bin/compile",
"chars": 882,
"preview": "#!/usr/bin/env node\n\nvar fs = require('fs');\nvar compiler = require(__dirname + '/../main');\nvar sweet = require('sweet."
},
{
"path": "bin/regenerator",
"chars": 666,
"preview": "#!/usr/bin/env node\n// -*- mode: js -*-\n\n//Error.stackTraceLimit = 100;\n\nvar options = require(\"commander\")\n .version(r"
},
{
"path": "bin/run",
"chars": 327,
"preview": "#!/usr/bin/env node\n\nvar Machine = require('../runtime/vm.js').$Machine;\nvar VM = new Machine();\n\nVM.on(\"error\", functio"
},
{
"path": "browser/build/bundle.js",
"chars": 1409215,
"preview": "/******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n\n/*"
},
{
"path": "browser/build/styles.css",
"chars": 11104,
"preview": "/* BASICS */\n\n.CodeMirror {\n /* Set height, width, borders, and global font properties here */\n font-family: monospace"
},
{
"path": "browser/index.html",
"chars": 1932,
"preview": "<!DOCTYPE html>\n<html>\n <head>\n <meta charset=\"utf-8\" />\n <link rel=\"stylesheet\" type=\"text/css\" href=\"build/styl"
},
{
"path": "browser/main.js",
"chars": 7705,
"preview": "const regenerator = require('../main');\nconst VM = require('../runtime/vm');\nconst CodeMirror = require('codemirror');\n\n"
},
{
"path": "browser/script.js",
"chars": 87,
"preview": "function foo(x) {\n if(x < 2) {\n debugger;\n }\n return x + foo(x - 1);\n}\n\nfoo(10);\n"
},
{
"path": "browser/style.css",
"chars": 1052,
"preview": "\n.CodeMirror {\n min-width: 100%;\n height: 100%;\n background-color: #f0f0f0;\n /* max-height: 500px; */\n}\n\n.CodeMirror"
},
{
"path": "debuggers/browser/main.js",
"chars": 503,
"preview": "var express = require('express');\n\nvar app = express();\napp.configure(function() {\n app.use(express.static(__dirname + "
},
{
"path": "debuggers/browser/static/app-conn.js",
"chars": 2319,
"preview": "\nfunction format(obj) {\n if(obj === undefined) {\n return 'undefined';\n }\n else if(obj === null) {\n return 'null"
},
{
"path": "debuggers/browser/static/app.css",
"chars": 3831,
"preview": "\nbody {\n background-color: #aaaaaa;\n}\n\nhtml, body, .app {\n height: 100%;\n}\n\niframe {\n border: 0;\n}\n\nbutton {\n "
},
{
"path": "debuggers/browser/static/app.js",
"chars": 19906,
"preview": "\n// util\n\nfunction classes() {\n return Array.prototype.slice.call(arguments).reduce(function(acc, cls) {\n if(cls) {\n"
},
{
"path": "debuggers/browser/static/conn.js",
"chars": 1950,
"preview": "(function(exports) {\n\n// Connection\n\nfunction Connection(target, name) {\n this.target = target;\n this.baseid = 0;\n th"
},
{
"path": "debuggers/browser/static/index.html",
"chars": 927,
"preview": "<!DOCTYPE html>\n<html>\n <head>\n <title>probe your JavaScript</title>\n <meta charset=\"utf-8\" />\n <link rel=\"sty"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/.editorconfig",
"chars": 167,
"preview": "# editorconfig.org\n\nroot = true\n\n[*]\nindent_style = space\nindent_size = 2\nend_of_line = lf\ncharset = utf-8\ntrim_trailing"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/.gitattributes",
"chars": 164,
"preview": "# Enforce Unix newlines\n*.css text eol=lf\n*.html text eol=lf\n*.js text eol=lf\n*.json text eol=lf\n*.less text eol"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/.gitignore",
"chars": 451,
"preview": "# Ignore docs files\n_gh_pages\n_site\n.ruby-version\n\n# Numerous always-ignore extensions\n*.diff\n*.err\n*.orig\n*.log\n*.rej\n*"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/.travis.yml",
"chars": 335,
"preview": "language: node_js\nnode_js:\n - 0.10\nbefore_script:\n - gem install jekyll\n - npm install -g grunt-cli\nenv:\n global:\n "
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/CNAME",
"chars": 17,
"preview": "getbootstrap.com\n"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/CONTRIBUTING.md",
"chars": 3962,
"preview": "# Contributing to Bootstrap\n\nLooking to contribute something to Bootstrap? **Here's how you can help.**\n\n\n\n## Reporting "
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/DOCS-LICENSE",
"chars": 19466,
"preview": "Creative Commons Legal Code\n\nAttribution 3.0 Unported\n\n CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT P"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/Gruntfile.js",
"chars": 8929,
"preview": "/* jshint node: true */\n\nmodule.exports = function(grunt) {\n \"use strict\";\n\n // Force use of Unix newlines\n grunt.uti"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/LICENSE",
"chars": 10173,
"preview": " Apache License\n Version 2.0, January 2004\n "
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/LICENSE-MIT",
"chars": 1079,
"preview": "The MIT License (MIT)\n\nCopyright (c) 2013 Twitter, Inc\n\nPermission is hereby granted, free of charge, to any person obta"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/README.md",
"chars": 7533,
"preview": "# [Bootstrap](http://getbootstrap.com) [](http://travis-"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/_config.yml",
"chars": 968,
"preview": "# Dependencies\nmarkdown: rdiscount\npygments: true\n\n# Permalinks\npermalink: pretty\n\n# Server\ndesti"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/_includes/ads.html",
"chars": 317,
"preview": "<div id=\"carbonads-container\"><div class=\"carbonad\"><div id=\"azcarbon\"></div><script>var z = document.createElement(\"scr"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/_includes/footer.html",
"chars": 2007,
"preview": "<!-- Bootstrap core JavaScript\n================================================== -->\n<!-- Placed at the end of the docu"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/_includes/header.html",
"chars": 1747,
"preview": "<meta charset=\"utf-8\">\n<meta http-equiv=\"X-UA-Compatible\" content=\"IE=edge\">\n<meta name=\"viewport\" content=\"width=device"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/_includes/nav-about.html",
"chars": 189,
"preview": "<li>\n <a href=\"#history\">History</a>\n</li>\n<li>\n <a href=\"#team\">Core team</a>\n</li>\n<li>\n <a href=\"#community\">Commu"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/_includes/nav-components.html",
"chars": 4978,
"preview": "<li>\n <a href=\"#glyphicons\">Glyphicons</a>\n <ul class=\"nav\">\n <li><a href=\"#glyphicons-glyphs\">Available glyphs</a>"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/_includes/nav-css.html",
"chars": 4081,
"preview": "<li>\n <a href=\"#overview\">Overview</a>\n <ul class=\"nav\">\n <li><a href=\"#overview-doctype\">HTML5 doctype</a></li>\n "
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/_includes/nav-customize.html",
"chars": 1691,
"preview": "<li>\n <a href=\"#less\">LESS components</a>\n</li>\n<li>\n <a href=\"#plugins\">jQuery plugins</a>\n</li>\n<li>\n <a href=\"#les"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/_includes/nav-getting-started.html",
"chars": 1285,
"preview": "<li>\n <a href=\"#download\">Download Bootstrap</a>\n <ul class=\"nav\">\n <li><a href=\"#download-compiled\">Compiled CSS, "
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/_includes/nav-javascript.html",
"chars": 2320,
"preview": "<li>\n <a href=\"#js-overview\">Overview</a>\n <ul class=\"nav\">\n <li><a href=\"#js-individual-compiled\">Individual or co"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/_includes/nav-main.html",
"chars": 1613,
"preview": "<header class=\"navbar navbar-inverse navbar-fixed-top bs-docs-nav\" role=\"banner\">\n <div class=\"container\">\n <div cla"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/_includes/old-bs-docs.html",
"chars": 319,
"preview": "<div class=\"bs-old-docs\">\n <div class=\"container\">\n <strong>\n <a href=\"{{ page.base_url }}2.3.2/\">Looking for B"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/_includes/social-buttons.html",
"chars": 925,
"preview": "<div class=\"bs-social\">\n <ul class=\"bs-social-buttons\">\n <li>\n <iframe class=\"github-btn\" src=\"http://ghbtns.co"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/_layouts/default.html",
"chars": 2810,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <!-- Meta, title, CSS, favicons, etc. -->\n {% include header.html %}\n "
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/_layouts/home.html",
"chars": 1497,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <!-- Meta, title, CSS, favicons, etc. -->\n {% include header.html %}\n "
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/about.html",
"chars": 6000,
"preview": "---\nlayout: default\ntitle: About\nslug: about\nlead: \"Learn about the history of Bootstrap, meet the core team, and check "
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/bower.json",
"chars": 633,
"preview": "{\n \"name\": \"bootstrap\",\n \"version\": \"3.0.3\",\n \"main\": [\n \"./dist/js/bootstrap.js\", \n \"./dist/css/bootstrap.css\""
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/components.html",
"chars": 148653,
"preview": "---\nlayout: default\ntitle: Components\nslug: components\nlead: \"Over a dozen reusable components built to provide iconogra"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/composer.json",
"chars": 632,
"preview": "{\n \"name\": \"twbs/bootstrap\"\n , \"description\": \"Sleek, intuitive, and powerful mobile first front-end framework for f"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/css.html",
"chars": 102364,
"preview": "---\nlayout: default\ntitle: CSS\nslug: css\nlead: \"Global CSS settings, fundamental HTML elements styled and enhanced with "
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/customize.html",
"chars": 77717,
"preview": "---\nlayout: default\ntitle: Customize and download\nslug: customize\nlead: Customize Bootstrap's components, LESS variables"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/dist/css/bootstrap-theme.css",
"chars": 14716,
"preview": "/*!\n * Bootstrap v3.0.3 (http://getbootstrap.com)\n * Copyright 2013 Twitter, Inc.\n * Licensed under http://www.apache.or"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/dist/css/bootstrap.css",
"chars": 122848,
"preview": "/*!\n * Bootstrap v3.0.3 (http://getbootstrap.com)\n * Copyright 2013 Twitter, Inc.\n * Licensed under http://www.apache.or"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/dist/js/bootstrap.js",
"chars": 58533,
"preview": "/*!\n * Bootstrap v3.0.3 (http://getbootstrap.com)\n * Copyright 2013 Twitter, Inc.\n * Licensed under http://www.apache.or"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/css/docs.css",
"chars": 72798,
"preview": "/*!\n * Copyright 2013 Twitter, Inc.\n *\n * Licensed under the Creative Commons Attribution 3.0 Unported License. For\n * d"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/css/pygments-manni.css",
"chars": 3005,
"preview": ".hll { background-color: #ffffcc }\n /*{ background: #f0f3f3; }*/\n.c { color: #999; } /* Comment */\n.err { color: #AA0000"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/js/application.js",
"chars": 2461,
"preview": "// NOTICE!! DO NOT USE ANY OF THIS JAVASCRIPT\n// IT'S ALL JUST JUNK FOR OUR DOCS!\n// +++++++++++++++++++++++++++++++++++"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/js/customizer.js",
"chars": 10452,
"preview": "/*!\n * Copyright 2013 Twitter, Inc.\n *\n * Licensed under the Creative Commons Attribution 3.0 Unported License. For\n * d"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/js/filesaver.js",
"chars": 12448,
"preview": "/* Blob.js\n * A Blob implementation.\n * 2013-06-20\n *\n * By Eli Grey, http://eligrey.com\n * By Devin Samarin, https://gi"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/js/holder.js",
"chars": 14727,
"preview": "/*\n\nHolder - 2.2 - client side image placeholders\n(c) 2012-2013 Ivan Malopinsky / http://imsky.co\n\nProvided under the MI"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/js/ie8-responsive-file-warning.js",
"chars": 581,
"preview": "// NOTICE!! DO NOT USE ANY OF THIS JAVASCRIPT\n// IT'S JUST JUNK FOR OUR DOCS!\n// +++++++++++++++++++++++++++++++++++++++"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/js/jszip.js",
"chars": 50962,
"preview": "/**\n\nJSZip - A Javascript class for generating and reading zip files\n<http://stuartk.com/jszip>\n\n(c) 2009-2012 Stuart Kn"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/js/less.js",
"chars": 58184,
"preview": "//\n// LESS - Leaner CSS v1.3.3\n// http://lesscss.org\n//\n// Copyright (c) 2009-2013, Alexis Sellier\n// Licensed under the"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/js/raw-files.js",
"chars": 437781,
"preview": "var __js = {\"affix.js\":\"/* ========================================================================\\n * Bootstrap: affix"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/docs-assets/js/uglify.js",
"chars": 50609,
"preview": "/** @license uglifyweb Copyright (c) 2011, The Dojo Foundation All Rights Reserved.\n * The parts that are unique to this"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/carousel/carousel.css",
"chars": 2709,
"preview": "/* GLOBAL STYLES\n-------------------------------------------------- */\n/* Padding below the footer and lighter body text"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/carousel/index.html",
"chars": 10022,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/grid/grid.css",
"chars": 422,
"preview": ".container {\n padding-left: 15px;\n padding-right: 15px;\n}\n\nh4 {\n margin-top: 25px;\n}\n.row {\n margin-bottom: 20px;\n}\n"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/grid/index.html",
"chars": 6167,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/jumbotron/index.html",
"chars": 4467,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/jumbotron/jumbotron.css",
"chars": 127,
"preview": "/* Move down content because we have a fixed navbar that is 50px tall */\nbody {\n padding-top: 50px;\n padding-bottom: 2"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/jumbotron-narrow/index.html",
"chars": 3049,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/jumbotron-narrow/jumbotron-narrow.css",
"chars": 1411,
"preview": "/* Space out content a bit */\nbody {\n padding-top: 20px;\n padding-bottom: 20px;\n}\n\n/* Everything but the jumbotron get"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/justified-nav/index.html",
"chars": 3776,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/justified-nav/justified-nav.css",
"chars": 2361,
"preview": "body {\n padding-top: 20px;\n}\n\n.footer {\n border-top: 1px solid #eee;\n margin-top: 40px;\n padding-top: 40px;\n paddin"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/navbar/index.html",
"chars": 3668,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/navbar/navbar.css",
"chars": 90,
"preview": "body {\n padding-top: 20px;\n padding-bottom: 20px;\n}\n\n.navbar {\n margin-bottom: 20px;\n}\n"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/navbar-fixed-top/index.html",
"chars": 3827,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/navbar-fixed-top/navbar-fixed-top.css",
"chars": 52,
"preview": "body {\n min-height: 2000px;\n padding-top: 70px;\n}\n"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/navbar-static-top/index.html",
"chars": 3831,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/navbar-static-top/navbar-static-top.css",
"chars": 77,
"preview": "body {\n min-height: 2000px;\n}\n\n.navbar-static-top {\n margin-bottom: 19px;\n}"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/non-responsive/index.html",
"chars": 4267,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/non-responsive/non-responsive.css",
"chars": 2610,
"preview": "/* Template-specific stuff\n *\n * Customizations just for the template; these are not necessary for anything\n * with disa"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/offcanvas/index.html",
"chars": 6643,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/offcanvas/offcanvas.css",
"chars": 896,
"preview": "/*\n * Style tweaks\n * --------------------------------------------------\n */\nhtml,\nbody {\n overflow-x: hidden; /* Preve"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/offcanvas/offcanvas.js",
"chars": 137,
"preview": "$(document).ready(function() {\n $('[data-toggle=offcanvas]').click(function() {\n $('.row-offcanvas').toggleClass('ac"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/signin/index.html",
"chars": 1849,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/signin/signin.css",
"chars": 791,
"preview": "body {\n padding-top: 40px;\n padding-bottom: 40px;\n background-color: #eee;\n}\n\n.form-signin {\n max-width: 330px;\n pa"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/starter-template/index.html",
"chars": 2591,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/starter-template/starter-template.css",
"chars": 96,
"preview": "body {\n padding-top: 50px;\n}\n.starter-template {\n padding: 40px 15px;\n text-align: center;\n}\n"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/sticky-footer/index.html",
"chars": 1921,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/sticky-footer/sticky-footer.css",
"chars": 755,
"preview": "/* Sticky footer styles\n-------------------------------------------------- */\n\nhtml,\nbody {\n height: 100%;\n /* The htm"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/sticky-footer-navbar/index.html",
"chars": 3750,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/sticky-footer-navbar/sticky-footer-navbar.css",
"chars": 832,
"preview": "/* Sticky footer styles\n-------------------------------------------------- */\n\nhtml,\nbody {\n height: 100%;\n /* The htm"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/theme/index.html",
"chars": 16869,
"preview": "<!DOCTYPE html>\n<html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta http-equiv=\"X-UA-Compatible\" content=\"IE="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/examples/theme/theme.css",
"chars": 199,
"preview": "body {\n padding-top: 70px;\n padding-bottom: 30px;\n}\n\n.theme-dropdown .dropdown-menu {\n display: block;\n position: st"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/getting-started.html",
"chars": 50851,
"preview": "---\nlayout: default\ntitle: Getting started\nslug: getting-started\nlead: \"An overview of Bootstrap, how to download and us"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/index.html",
"chars": 748,
"preview": "---\nlayout: home\ntitle: Bootstrap\nbase_url: \"./\"\n---\n\n<main class=\"bs-masthead\" id=\"content\" role=\"main\">\n <div class=\""
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/javascript.html",
"chars": 95750,
"preview": "---\nlayout: default\ntitle: JavaScript\nslug: js\nlead: \"Bring Bootstrap's components to life with over a dozen custom jQue"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/.jshintrc",
"chars": 256,
"preview": "{\n \"asi\" : true,\n \"boss\" : true,\n \"browser\" : true,\n \"curly\" : false,\n \"debug\" : true,\n \"devel\" "
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/affix.js",
"chars": 3861,
"preview": "/* ========================================================================\n * Bootstrap: affix.js v3.0.3\n * http://getb"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/alert.js",
"chars": 2582,
"preview": "/* ========================================================================\n * Bootstrap: alert.js v3.0.3\n * http://getb"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/button.js",
"chars": 3265,
"preview": "/* ========================================================================\n * Bootstrap: button.js v3.0.3\n * http://get"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/carousel.js",
"chars": 6493,
"preview": "/* ========================================================================\n * Bootstrap: carousel.js v3.0.3\n * http://g"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/collapse.js",
"chars": 5228,
"preview": "/* ========================================================================\n * Bootstrap: collapse.js v3.0.3\n * http://g"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/dropdown.js",
"chars": 4477,
"preview": "/* ========================================================================\n * Bootstrap: dropdown.js v3.0.3\n * http://g"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/modal.js",
"chars": 6975,
"preview": "/* ========================================================================\n * Bootstrap: modal.js v3.0.3\n * http://getb"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/popover.js",
"chars": 3488,
"preview": "/* ========================================================================\n * Bootstrap: popover.js v3.0.3\n * http://ge"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/scrollspy.js",
"chars": 4635,
"preview": "/* ========================================================================\n * Bootstrap: scrollspy.js v3.0.3\n * http://"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tab.js",
"chars": 3413,
"preview": "/* ========================================================================\n * Bootstrap: tab.js v3.0.3\n * http://getboo"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/index.html",
"chars": 1678,
"preview": "<!DOCTYPE HTML>\n<html>\n<head>\n <title>Bootstrap Plugin Test Suite</title>\n\n <!-- jquery -->\n <!--<script src=\"http://"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/unit/affix.js",
"chars": 791,
"preview": "$(function () {\n\n module(\"affix\")\n\n test(\"should provide no conflict\", function () {\n var affix = $.fn.af"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/unit/alert.js",
"chars": 2101,
"preview": "$(function () {\n\n module(\"alert\")\n\n test(\"should provide no conflict\", function () {\n var alert = $.fn.al"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/unit/button.js",
"chars": 4805,
"preview": "$(function () {\n\n module(\"button\")\n\n test(\"should provide no conflict\", function () {\n var button = $.fn."
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/unit/carousel.js",
"chars": 6381,
"preview": "$(function () {\n\n module(\"carousel\")\n\n test(\"should provide no conflict\", function () {\n var carousel = $"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/unit/collapse.js",
"chars": 5903,
"preview": "$(function () {\n\n module(\"collapse\")\n\n test(\"should provide no conflict\", function () {\n var collapse = $"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/unit/dropdown.js",
"chars": 8414,
"preview": "$(function () {\n\n module(\"dropdowns\")\n\n test(\"should provide no conflict\", function () {\n var dropdown = "
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/unit/modal.js",
"chars": 6132,
"preview": "$(function () {\n\n module(\"modal\")\n\n test(\"should provide no conflict\", function () {\n var modal = $.fn.modal.no"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/unit/phantom.js",
"chars": 2137,
"preview": "/*\n * grunt-contrib-qunit\n * http://gruntjs.com/\n *\n * Copyright (c) 2013 \"Cowboy\" Ben Alman, contributors\n * Licensed u"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/unit/popover.js",
"chars": 5286,
"preview": "$(function () {\n\n module(\"popover\")\n\n test(\"should provide no conflict\", function () {\n var popover = $.f"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/unit/scrollspy.js",
"chars": 1194,
"preview": "$(function () {\n\n module(\"scrollspy\")\n\n test(\"should provide no conflict\", function () {\n var scrollspy ="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/unit/tab.js",
"chars": 2843,
"preview": "$(function () {\n\n module(\"tabs\")\n\n test(\"should provide no conflict\", function () {\n var tab = $.fn.tab.n"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/unit/tooltip.js",
"chars": 17062,
"preview": "$(function () {\n\n module(\"tooltip\")\n\n test(\"should provide no conflict\", function () {\n var tooltip = $.f"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/unit/transition.js",
"chars": 365,
"preview": "$(function () {\n\n module(\"transition\")\n\n test(\"should be defined on jquery support object\", function () {\n "
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/vendor/jquery.js",
"chars": 93106,
"preview": "/*! jQuery v1.10.2 | (c) 2005, 2013 jQuery Foundation, Inc. | jquery.org/license\n//@ sourceMappingURL=jquery-1.10.2.min."
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/vendor/qunit.css",
"chars": 4560,
"preview": "/**\n * QUnit - A JavaScript Unit Testing Framework\n *\n * http://docs.jquery.com/QUnit\n *\n * Copyright (c) 2012 John Resi"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tests/vendor/qunit.js",
"chars": 38065,
"preview": "/**\n * QUnit - A JavaScript Unit Testing Framework\n *\n * http://docs.jquery.com/QUnit\n *\n * Copyright (c) 2012 John Resi"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/tooltip.js",
"chars": 11908,
"preview": "/* ========================================================================\n * Bootstrap: tooltip.js v3.0.3\n * http://ge"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/js/transition.js",
"chars": 1964,
"preview": "/* ========================================================================\n * Bootstrap: transition.js v3.0.3\n * http:/"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/alerts.less",
"chars": 1430,
"preview": "//\n// Alerts\n// --------------------------------------------------\n\n\n// Base styles\n// -------------------------\n\n.alert"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/badges.less",
"chars": 1005,
"preview": "//\n// Badges\n// --------------------------------------------------\n\n\n// Base classes\n.badge {\n display: inline-block;\n "
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/bootstrap.less",
"chars": 1071,
"preview": "// Core variables and mixins\n@import \"variables.less\";\n@import \"mixins.less\";\n\n// Reset\n@import \"normalize.less\";\n@impor"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/breadcrumbs.less",
"chars": 540,
"preview": "//\n// Breadcrumbs\n// --------------------------------------------------\n\n\n.breadcrumb {\n padding: 8px 15px;\n margin-bo"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/button-groups.less",
"chars": 4919,
"preview": "//\n// Button groups\n// --------------------------------------------------\n\n// Make the div behave like a button\n.btn-gro"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/buttons.less",
"chars": 3499,
"preview": "//\n// Buttons\n// --------------------------------------------------\n\n\n// Base styles\n// --------------------------------"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/carousel.less",
"chars": 4592,
"preview": "//\n// Carousel\n// --------------------------------------------------\n\n\n// Wrapper for the slide container and indicators"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/close.less",
"chars": 683,
"preview": "//\n// Close icons\n// --------------------------------------------------\n\n\n.close {\n float: right;\n font-size: (@font-s"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/code.less",
"chars": 1102,
"preview": "//\n// Code (inline and block)\n// --------------------------------------------------\n\n\n// Inline and block code styles\nco"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/component-animations.less",
"chars": 509,
"preview": "//\n// Component animations\n// --------------------------------------------------\n\n// Heads up!\n//\n// We don't use the `."
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/dropdowns.less",
"chars": 3821,
"preview": "//\n// Dropdown menus\n// --------------------------------------------------\n\n\n// Dropdown arrow/caret\n.caret {\n display:"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/forms.less",
"chars": 9172,
"preview": "//\n// Forms\n// --------------------------------------------------\n\n\n// Normalize non-controls\n//\n// Restyle and baseline"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/glyphicons.less",
"chars": 14918,
"preview": "//\n// Glyphicons for Bootstrap\n//\n// Since icons are fonts, they can be placed anywhere text is placed and are\n// thus a"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/grid.less",
"chars": 1793,
"preview": "//\n// Grid system\n// --------------------------------------------------\n\n// Set the container width, and override it for"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/input-groups.less",
"chars": 3281,
"preview": "//\n// Input groups\n// --------------------------------------------------\n\n// Base styles\n// -------------------------\n.i"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/jumbotron.less",
"chars": 936,
"preview": "//\n// Jumbotron\n// --------------------------------------------------\n\n\n.jumbotron {\n padding: @jumbotron-padding;\n ma"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/labels.less",
"chars": 1084,
"preview": "//\n// Labels\n// --------------------------------------------------\n\n.label {\n display: inline;\n padding: .2em .6em .3e"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/list-group.less",
"chars": 1914,
"preview": "//\n// List groups\n// --------------------------------------------------\n\n// Base class\n//\n// Easily usable on <ul>, <ol>"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/media.less",
"chars": 848,
"preview": "// Media objects\n// Source: http://stubbornella.org/content/?p=497\n// --------------------------------------------------"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/mixins.less",
"chars": 24469,
"preview": "//\n// Mixins\n// --------------------------------------------------\n\n\n// Utilities\n// -------------------------\n\n// Clear"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/modals.less",
"chars": 3078,
"preview": "//\n// Modals\n// --------------------------------------------------\n\n// .modal-open - body class for killing the scr"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/navbar.less",
"chars": 13814,
"preview": "//\n// Navbars\n// --------------------------------------------------\n\n\n// Wrapper and base class\n//\n// Provide a static n"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/navs.less",
"chars": 4915,
"preview": "//\n// Navs\n// --------------------------------------------------\n\n\n// Base class\n// ------------------------------------"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/normalize.less",
"chars": 7275,
"preview": "/*! normalize.css v2.1.3 | MIT License | git.io/normalize */\n\n// ======================================================="
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/pager.less",
"chars": 865,
"preview": "//\n// Pager pagination\n// --------------------------------------------------\n\n\n.pager {\n padding-left: 0;\n margin: @li"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/pagination.less",
"chars": 1858,
"preview": "//\n// Pagination (multiple pages)\n// --------------------------------------------------\n.pagination {\n display: inline-"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/panels.less",
"chars": 4028,
"preview": "//\n// Panels\n// --------------------------------------------------\n\n\n// Base class\n.panel {\n margin-bottom: @line-heigh"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/popovers.less",
"chars": 3282,
"preview": "//\n// Popovers\n// --------------------------------------------------\n\n\n.popover {\n position: absolute;\n top: 0;\n left"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/print.less",
"chars": 1650,
"preview": "//\n// Basic print styles\n// --------------------------------------------------\n// Source: https://github.com/h5bp/html5-"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/progress-bars.less",
"chars": 1589,
"preview": "//\n// Progress bars\n// --------------------------------------------------\n\n\n// Bar animations\n// -----------------------"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/responsive-utilities.less",
"chars": 4880,
"preview": "//\n// Responsive: Utility classes\n// --------------------------------------------------\n\n\n// IE10 in Windows (Phone) 8\n/"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/scaffolding.less",
"chars": 1867,
"preview": "//\n// Scaffolding\n// --------------------------------------------------\n\n\n// Reset the box-sizing\n\n*,\n*:before,\n*:after "
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/tables.less",
"chars": 4304,
"preview": "//\n// Tables\n// --------------------------------------------------\n\n\ntable {\n max-width: 100%;\n background-color: @tab"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/theme.less",
"chars": 6854,
"preview": "\n//\n// Load core variables and mixins\n// --------------------------------------------------\n\n@import \"variables.less\";\n@"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/thumbnails.less",
"chars": 742,
"preview": "//\n// Thumbnails\n// --------------------------------------------------\n\n\n// Mixin and adjust the regular image class\n.th"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/tooltip.less",
"chars": 2576,
"preview": "//\n// Tooltips\n// --------------------------------------------------\n\n\n// Base class\n.tooltip {\n position: absolute;\n "
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/type.less",
"chars": 5179,
"preview": "//\n// Typography\n// --------------------------------------------------\n\n\n// Headings\n// -------------------------\n\nh1, h"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/utilities.less",
"chars": 780,
"preview": "//\n// Utility classes\n// --------------------------------------------------\n\n\n// Floats\n// -------------------------\n\n.c"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/variables.less",
"chars": 19762,
"preview": "//\n// Variables\n// --------------------------------------------------\n\n\n// Global values\n// ----------------------------"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/less/wells.less",
"chars": 535,
"preview": "//\n// Wells\n// --------------------------------------------------\n\n\n// Base class\n.well {\n min-height: 20px;\n padding:"
},
{
"path": "debuggers/browser/static/lib/bootstrap-3.0.3/package.json",
"chars": 1427,
"preview": "{\n \"name\": \"bootstrap\"\n , \"description\": \"Sleek, intuitive, and powerful front-end framework for faster and easier w"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/.gitattributes",
"chars": 104,
"preview": "*.txt text\n*.js text\n*.html text\n*.md text\n*.json text\n*.yml text\n*.css text\n*.svg text\n"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/.gitignore",
"chars": 56,
"preview": "/node_modules\n/npm-debug.log\ntest.html\n.tern-*\n*~\n*.swp\n"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/.travis.yml",
"chars": 35,
"preview": "language: node_js\nnode_js:\n - 0.8\n"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/AUTHORS",
"chars": 3263,
"preview": "List of CodeMirror contributors. Updated before every release.\n\n4r2r\nAaron Brooks\nAdam King\nadanlobato\nAdán Lobato\naeros"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/CONTRIBUTING.md",
"chars": 3071,
"preview": "# How to contribute\n\n- [Getting help](#getting-help-)\n- [Submitting bug reports](#submitting-bug-reports-)\n- [Contributi"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/LICENSE",
"chars": 1094,
"preview": "Copyright (C) 2013 by Marijn Haverbeke <marijnh@gmail.com> and others\n\nPermission is hereby granted, free of charge, to "
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/README.md",
"chars": 661,
"preview": "# CodeMirror\n[](http://travis-ci.org/m"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/comment/comment.js",
"chars": 5981,
"preview": "(function() {\n \"use strict\";\n\n var noOptions = {};\n var nonWS = /[^\\s\\u00a0]/;\n var Pos = CodeMirror.Pos;\n\n functio"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/comment/continuecomment.js",
"chars": 2128,
"preview": "(function() {\n var modes = [\"clike\", \"css\", \"javascript\"];\n for (var i = 0; i < modes.length; ++i)\n CodeMirror.exte"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/dialog/dialog.css",
"chars": 502,
"preview": ".CodeMirror-dialog {\n position: absolute;\n left: 0; right: 0;\n background: white;\n z-index: 15;\n padding: .1em .8em"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/dialog/dialog.js",
"chars": 4002,
"preview": "// Open simple dialogs on top of an editor. Relies on dialog.css.\n\n(function() {\n function dialogDiv(cm, template, bott"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/display/fullscreen.css",
"chars": 116,
"preview": ".CodeMirror-fullscreen {\n position: fixed;\n top: 0; left: 0; right: 0; bottom: 0;\n height: auto;\n z-index: 9;\n}\n"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/display/fullscreen.js",
"chars": 1069,
"preview": "(function() {\n \"use strict\";\n\n CodeMirror.defineOption(\"fullScreen\", false, function(cm, val, old) {\n if (old == Co"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/display/placeholder.js",
"chars": 1546,
"preview": "(function() {\n CodeMirror.defineOption(\"placeholder\", \"\", function(cm, val, old) {\n var prev = old && old != CodeMir"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/edit/closebrackets.js",
"chars": 3381,
"preview": "(function() {\n var DEFAULT_BRACKETS = \"()[]{}''\\\"\\\"\";\n var DEFAULT_EXPLODE_ON_ENTER = \"[]{}\";\n var SPACE_CHAR_REGEX ="
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/edit/closetag.js",
"chars": 4039,
"preview": "/**\n * Tag-closer extension for CodeMirror.\n *\n * This extension adds an \"autoCloseTags\" option that can be set to\n * ei"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/edit/continuelist.js",
"chars": 662,
"preview": "(function() {\n 'use strict';\n\n var listRE = /^(\\s*)([*+-]|(\\d+)\\.)(\\s*)/,\n unorderedBullets = '*+-';\n\n CodeMirro"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/edit/matchbrackets.js",
"chars": 3915,
"preview": "(function() {\n var ie_lt8 = /MSIE \\d/.test(navigator.userAgent) &&\n (document.documentMode == null || document.docum"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/edit/matchtags.js",
"chars": 1878,
"preview": "(function() {\n \"use strict\";\n\n CodeMirror.defineOption(\"matchTags\", false, function(cm, val, old) {\n if (old && old"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/edit/trailingspace.js",
"chars": 528,
"preview": "CodeMirror.defineOption(\"showTrailingSpace\", false, function(cm, val, prev) {\n if (prev == CodeMirror.Init) prev = fals"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/fold/brace-fold.js",
"chars": 3653,
"preview": "CodeMirror.registerHelper(\"fold\", \"brace\", function(cm, start) {\n var line = start.line, lineText = cm.getLine(line);\n "
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/fold/comment-fold.js",
"chars": 1455,
"preview": "CodeMirror.registerHelper(\"fold\", \"comment\", function(cm, start) {\n var mode = cm.getModeAt(start), startToken = mode.b"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/fold/foldcode.js",
"chars": 2460,
"preview": "(function() {\n \"use strict\";\n\n function doFold(cm, pos, options, force) {\n var finder = options && (options.call ? "
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/fold/foldgutter.css",
"chars": 450,
"preview": ".CodeMirror-foldmarker {\n color: blue;\n text-shadow: #b9f 1px 1px 2px, #b9f -1px -1px 2px, #b9f 1px -1px 2px, #b9f -1p"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/fold/foldgutter.js",
"chars": 3879,
"preview": "(function() {\n \"use strict\";\n\n CodeMirror.defineOption(\"foldGutter\", false, function(cm, val, old) {\n if (old && ol"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/fold/indent-fold.js",
"chars": 1241,
"preview": "CodeMirror.registerHelper(\"fold\", \"indent\", function(cm, start) {\n var tabSize = cm.getOption(\"tabSize\"), firstLine = c"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/fold/xml-fold.js",
"chars": 5931,
"preview": "(function() {\n \"use strict\";\n\n var Pos = CodeMirror.Pos;\n function cmp(a, b) { return a.line - b.line || a.ch - b.ch;"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/hint/anyword-hint.js",
"chars": 1277,
"preview": "(function() {\n \"use strict\";\n\n var WORD = /[\\w$]+/, RANGE = 500;\n\n CodeMirror.registerHelper(\"hint\", \"anyword\", funct"
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/hint/css-hint.js",
"chars": 1431,
"preview": "(function () {\n \"use strict\";\n\n function getHints(cm) {\n var cur = cm.getCursor(), token = cm.getTokenAt(cur);\n "
},
{
"path": "debuggers/browser/static/lib/codemirror-3.20/addon/hint/html-hint.js",
"chars": 10911,
"preview": "(function () {\n var langs = \"ab aa af ak sq am ar an hy as av ae ay az bm ba eu be bn bh bi bs br bg my ca ch ce ny zh "
}
]
// ... and 363 more files (download for full content)
About this extraction
This page contains the full source code of the jlongster/unwinder GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 563 files (7.9 MB), approximately 2.1M tokens, and a symbol index with 3805 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.