Repository: parkouss/webmacs
Branch: master
Commit: c42d89fcc41e
Files: 113
Total size: 777.4 KB
Directory structure:
gitextract_3q3a7_u6/
├── .flake8
├── .gitattributes
├── .gitignore
├── .gitmodules
├── .travis.yml
├── CHANGELOG.md
├── COPYING
├── README-nix.org
├── README.org
├── c/
│ └── adblock.c
├── docs/
│ ├── Makefile
│ ├── advanced_topics.rst
│ ├── api.rst
│ ├── basic_usage.rst
│ ├── concepts.rst
│ ├── conf.py
│ ├── ext/
│ │ └── webmacs_sphinx_ext.py
│ ├── faq.rst
│ ├── glossary.rst
│ ├── index.rst
│ ├── make.bat
│ └── user_configuration.rst
├── git_archive_all.py
├── pytest.ini
├── setup.py
├── test-requirements.txt
├── tests/
│ ├── integration/
│ │ ├── conftest.py
│ │ ├── iframe_follow/
│ │ │ ├── index.html
│ │ │ └── my_iframe.html
│ │ ├── javascript_prompt/
│ │ │ └── index.html
│ │ ├── navigation/
│ │ │ ├── index.html
│ │ │ └── page1.html
│ │ ├── test_copy_link.py
│ │ ├── test_iframe_navigation.py
│ │ ├── test_javascript_prompt.py
│ │ ├── test_navigation.py
│ │ └── test_user_download_dir.py
│ ├── test_prompt_history.py
│ └── test_variables.py
└── webmacs/
├── __init__.py
├── adblock.py
├── application.py
├── bookmarks.py
├── clipboard.py
├── commands/
│ ├── __init__.py
│ ├── buffer_history.py
│ ├── caret_browsing.py
│ ├── content_edit.py
│ ├── follow.py
│ ├── global.py
│ ├── isearch.py
│ ├── minibuffer.py
│ ├── webbuffer.py
│ └── webjump.py
├── content_handler.py
├── default_webjumps.py
├── download_manager/
│ ├── __init__.py
│ └── prompts.py
├── egrid.py
├── external_editor.py
├── features.py
├── filter_webengine_output.py
├── hooks.py
├── ignore_certificates.py
├── ipc.py
├── keyboardhandler.py
├── keymaps/
│ ├── __init__.py
│ ├── caret_browsing.py
│ ├── content_edit.py
│ ├── fullscreen.py
│ ├── global.py
│ ├── hints.py
│ ├── isearch.py
│ ├── minibuffer.py
│ └── webbuffer.py
├── killed_buffers.py
├── main.py
├── minibuffer/
│ ├── __init__.py
│ ├── prompt.py
│ └── right_label.py
├── mode.py
├── password_manager/
│ ├── __init__.py
│ └── password_store.py
├── profile.py
├── scheme_handlers/
│ ├── __init__.py
│ └── webmacs/
│ ├── __init__.py
│ ├── js/
│ │ └── vue.js
│ └── templates/
│ ├── base.html
│ ├── bindings.html
│ ├── command.html
│ ├── commands.html
│ ├── downloads.html
│ ├── key.html
│ ├── keymap.html
│ ├── variable.html
│ ├── variables.html
│ └── version.html
├── scripts/
│ ├── caret_browsing.js
│ ├── hint.js
│ ├── password_manager.js
│ ├── setup.js
│ ├── textedit.js
│ └── textzoom.js
├── session.py
├── spell_checking.py
├── task.py
├── url_opener.py
├── variables.py
├── version.py
├── visited_links.py
├── webbuffer.py
├── webview.py
└── window.py
================================================
FILE CONTENTS
================================================
================================================
FILE: .flake8
================================================
[flake8]
exclude = ./vendor/,
./build/,
./dist/,
./webmacs.egg-info/,
# exclude virtual envs
./venv*,
================================================
FILE: .gitattributes
================================================
**/.gitignore export-ignore
**/.gitmodules export-ignore
**/.travis.yml export-ignore
vendor/*/test/** export-ignore
vendor/*/vendor/depot_tools/** export-ignore
vendor/*/.npmignore export-ignore
git_archive_all.py export-ignore
================================================
FILE: .gitignore
================================================
__pycache__/
venv/
================================================
FILE: .gitmodules
================================================
[submodule "vendor/hashset-cpp"]
path = vendor/hashset-cpp
url = https://github.com/bbondy/hashset-cpp
[submodule "vendor/bloom-filter-cpp"]
path = vendor/bloom-filter-cpp
url = https://github.com/bbondy/bloom-filter-cpp
[submodule "vendor/ad-block"]
path = vendor/ad-block
url = https://github.com/brave/ad-block
================================================
FILE: .travis.yml
================================================
sudo: true
language: python
dist: xenial
python: 3.7
matrix:
include:
- os: linux
env: PYQT_VERSION=5.7.1
- os: linux
env: PYQT_VERSION=5.8.2
- os: linux
env: PYQT_VERSION=5.9.2
- os: linux
env: PYQT_VERSION=5.10.1
- os: linux
env: PYQT_VERSION=5.11.2 GENERATE_GIT_ARCHIVE=true
fast_finish: true
cache:
directories:
- $HOME/.cache/pip
install:
- pip install PyQt5==$PYQT_VERSION sphinx
- pip install -r test-requirements.txt
- sudo apt-get --yes install xvfb herbstluftwm
script:
- flake8
- pytest
- cd docs && READTHEDOCS=1 make html && cd ..
before_deploy:
- python git_archive_all.py webmacs-${TRAVIS_TAG}.tar.gz
deploy:
provider: releases
api_key:
secure: MZSDuOdwUlHn55GfMy4MwkT9ZgDhd5/09gKTH2futOWtF90oIhbIO2a1ZfH8QXPB2AZtISzPFgPgMgFtdCIBkmv7ic5yD0AC+hfb6F8iWsxVaUCBQh6B7g4vUomoAEkr7+pUzjapOuJFSlaIWajSL43WcZb7Ep6gdy8M1bBnj8HsyBug5g5uV0GEFmk55Jwlg1EsXF9Jx23EstEBW1HC/wdywa3vkYZsaCzKSco+L1XU2lVtbrRBuY8SbYyvadeFPkyu315+cFNT+HkdD5yvFjRNFoaSYF4AMskv8LR7cCQ6Z7Hug1huFBNgr+LPVFxfflb+zaEETimLV5BN52pB2udv+RDJu0Xmc2hGcCb3eRrHC/w7DkxXWuldF/g8b2aCmoCUDrca1Dh+ipeXzWKo5yEFgrP4dp8l/q5ClbpH3Qc/o6IUhFvVS7YH8udO7A7bAHcZisDGuSfasQeHSDq28maU0pSH3sB0zcTvcphIzkDUjT7+9peXhn56MWUMKlBRX2JU9eoUCz1dBuxK/XCuRZ0YPHjV3xrDvEIbMBny3kdKHCTkc7rcZZs1QfZgnMmySLbM6uUXpmwxBhH5eIEqdZ5isQn/oCt+G3L99Lp7/sNr+gXJtNuocEzWcryEIeJ2Vi/hL9+Mu/I4TlgyLv6f1RS74Ndp4cPpgCCwGS2yVwY=
file: webmacs-${TRAVIS_TAG}.tar.gz
skip_cleanup: true
on:
tags: true
repo: parkouss/webmacs
branch: master
# limit to only one element in the matrix
condition: $GENERATE_GIT_ARCHIVE = true
================================================
FILE: CHANGELOG.md
================================================
# Changelog
All notable changes to this project will be documented in this file.
The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
## [Unreleased]
### Fixed
- Cookies and persistent data is now really saved on disk, and used on restart.
- Fixed a possible security issue of the webmacs.ipc file that was readable and
writable by others.
- adblock url fetching and parsing is now more verbose on error and more
resilient.
- Fixed text selection within iframes.
- Fixed minibuffer line input redo binding.
- Fixed exiting webmacs as fast as possible by rewriting long-running tasks
asynchronously.
### Added
- Added passwordstore support for storing passwords (the linux 'pass' command
line tool)
- Added **content-edit-select-all** in content edit mode, bound to **C-x h**.
- Added **minibuffer-select-all** in minibuffer keymap, bound to **C-x h**.
- Added bindings currently attached to commands when using **M-x** command.
- Added support for an off-the-record (private) mode. It is enabled by starting
webmacs using **--off-the-record** flag, or using the command
**open-off-the-record**.
### Changed
- Moved codebase to PyQt6. PyQt5 is no longer supported.
- Removed support for an internal database to store passwords.
- Moved path to the spell checking data (to ~/.webmacs/spell_checking/)
## [0.8] - 2019-09-15
### Fixed
- autocompletion for duckduckgo now uses duckduckgo servers
- Fixed displaying long lines in the minibuffer popup (such as long urls in
history)
- Fixed regression, unable to revive a buffer.
- webmacs command line now handle correctly opening relative local file paths.
- Fixed scrolling top or bottom when switching view, and losing focus sometimes.
- Use one session file per webmacs instance.
### Added
- Added **where-is** command, bound to **C-h w**, to look up what keys a command
is bound to, if any.
- Added **describe-key-briefly** command, bound to **C-h c**, as a less verbose
alternative to **describe-key**.
- Added **print-buffer** command, bound to **C-x p** to print the current
buffer.
- Improved customization of key bindings for incremental search, hinting and
minibuffer
- Added key bindings **C-/** and **C-?** (resp. undo and redo) as minibuffer
input key bindings
- Added a **clipboard-copy** variable to be able to copy to primary clipboard
(still the default), mouse selection clipboard or both.
- Added a **--list-instances** command line flag, allowing to list current
running instances.
- Passing an empty string to the **--instance** command line flag will generate
a new unique instance name.
- Added a **raise-instance** command, to raise the current window of another
webmacs instance.
- Added a **current-instance** command that show the name of the current
instance name.
- Added **C-u C-u** prefix argument for command opening urls. Using it will open
the chosen url in a new window.
- Added the variable **visited-links-display-limit**, to limit the number of
elements displayed in the **visited-links-history** command. Defaults to 2000.
- Added **--profile** command line option to allow using more than one profile.
## Changed
- **C-h c** is now bound to **describe-key-briefly** instead of
**describe-command** which has in turn been moved to **C-h f**, in accordance
with Emacs default keybindings.
## [0.7] - 2018-09-20
### Fixed
- Fix refreshing buffer count in the minibuffer right label when a buffer is
closed.
- Fix reviving buffers that were not loaded (after restoring a session).
- Fix hinting urls in iframes when opening in a new buffer.
- Fixed support for Qt 5.7
- Fixed requiring escaping of raw % signs in custom webjumps.
- Fixed zoom-normal was bound to **0** instead of **=**.
### Added
- Added the **switch-buffer-current-color** variable that customize the color of
the current buffer row in the **switch-buffer** displayed list. The color
defaults to a light blue. Set to an empty string to get the old behavior (no
specific color).
- **switch-buffer** now list buffers using the internal buffer order.
- Buffers now have numbers and the current buffer number is displayed in the
minibuffer right label as well as in the **switch-buffer** and
**switch-recent-buffer** lists.
- **M-n** and **M-p** are bound respectively to the new commands **next-buffer**
and **previous-buffer**, allowing to cycle through buffers.
- **M-<**, **M->**, **C-v**, **M-v** bindings in the minibuffer lists for
navigation.
- New commands and bindings added to copy stuff to clipboard.
**copy-current-link** bound to **c c**, **copy-current-buffer-title** bound to
**c t**, and copy-current-buffer-url bound to **c u** (all in the webbuffer
keymap)
- Added a new method for hinting: alphabet. This allow to navigate only using
the home row keys, and without using Enter. Can be enabled by setting the
new variable **hint-method** to "alphabet".
- Added a new variable **hint-alphabet-characters** to specify which characters
to use with the alphabet hinting.
- Added a new variable **hint-node-style** to change the style of the hint div
nodes.
- Added a **close-buffer-close-window** variable to be able to close a window
when a buffer is closed.
- **C-g** in webbuffer is now bound to **buffer-escape** instead of
**buffer-unselect**, which does the same thing and send the Escape too (which
closes popup and other things).
- Added two variables, **default-download-dir** and
**keep-temporary-download-dir**.
### Changed
- The old **switch-buffer** behavior is now offered with the
**switch-recent-buffer** command. The latter is now bound to **C-x b** and
**C-x C-b** so there is no visible change using those keybindings.
- The **c** (copy-link) binding is now available using **c l** (think about Copy
Link).
- The css style of the hints has been changed. If you prefer the old style, just
set the **hint-node-style** variable to {"background": "red", "color":
"white"}.
- The **go-to** command (bounds to **g**) now set the current url in the
minibuffer input and select it.
- The **go-to-selected-url** and **go-to-selected-url-new-buffer** commands are
renamed to **go-to-alternate-url** and **go-to-alternate-url-new-buffer**.
Also they do not anymore select the current url, but only set the cursor at
the end of the url.
## [0.6] - 2018-08-20
### Fixed
- crash when opening in a new window (from right-click menu on a link), in qt
5.11.1.
- crash when reviving closed buffers in some cases.
- crash when calling switch-buffer and closing buffer (including the current
one) using C-k.
### Added
- added a basic navigation toolbar, that can be shown using the command
**toggle-toolbar**. Also added a new variable, **window-toolbar-on-startup**
that can be set to True to show the toolbar automatically.
- added a database to keep feature permissions (geolocation, camera, ...) on a
per-url basis (thanks to Patrick Lafrance)
- the allow permission for feature dialog now ask for Always/Never, and save
that in the database. (thanks to Patrick Lafrance)
- it is now possible to answer Never when webmacs ask to save a password.
(thanks to Patrick Lafrance)
- it is now possible to answer Always to bypass certificate errors. (thanks to
Patrick Lafrance)
- when opening a download, there is now a prompt to ask to download or to open
the file with an external command.
### Changed
- the functions **webmacs.keymaps.global_keymap()**,
**webmacs.keymaps.webbuffer_keymap()**,
**webmacs.keymaps.content_edit_keymap()** have been deprecated in favor of
**webmacs.keymaps.keymap()** (respectively with the argument "global",
"webbuffer" and "webcontent-edit").
- loading page information is now displayed in the minibuffer right label, using
the **loading** key in the **minibuffer-right-label** variable (default value
of this variable has changed)
## [0.5] - 2018-07-08
### Fixed
- focus is not lost anymore in the minibuffer input on page loading
- adblock is fully disabled when the variable **adblock-urls-rules** is set to
an empty list.
- adblock cache is rebuilt when the variable **adblock-urls-rules** has changed.
- Fixed the **copy-link** command (**c**) when used with the argument 0.
- Added a space after the default webjump when calling **search-default**.
- Mouse events are now propagated to the minibuffer input and popup.
- Fixed a bug that prevented to use multi-modifiers keybindings (e.g., C-M-a)
- Fixed regression in **close-other-buffers** command.
- The keyboard is not anymore lost when a new buffer is opened from javascript.
- The **follow** command is now working in cross-origin iframes.
- Text edition in web pages is now working in cross-origin iframes.
- Text zoom in web pages is now working in cross-origin iframes.
- Caret navigation is now working in cross-origin iframes.
### Changed
- **scroll-page-down**, **scroll-page-up**, **scroll-bottom** and
**scroll-top** are now implemented by sending the PageDown, PageUp and End
and Home key presses.
- **search-default** now defaults to google.
### Added
- The minibuffer input now flashes under some circumstances to grab user's
attention.
- Added **minibuffer-flash-duration**, **minibuffer-flash-color**, and
**minibuffer-flash-count** variables to customize the flash animation.
## [0.4] - 2018-05-04
### Fixed
- Fixed closing buffer in some circumstances using C-k from the
switch-buffer command.
- Improved position of the minibuffer popup, removing empty pixels
between the popup and the input.
- Fixed using i-search when caret browsing is enabled
- improve using multiple views, fixing a lot of bugs around that (keyboard
focus lost, crash using switch-buffer on an already displayed buffer, ...)
### Changed
- **breaking change**. The completion\_fn argument in define\_webjump has
changed, see the documentation about that.
- improved webjump completions in multiple ways.
- switching buffers now tries its best to keep the current scroll and cursor
position, so that coming back to a previous buffer feels more natural. This
is in part implemented by keeping one internal qt webengineview per buffer.
- improved the visibility of the current view when there are multiple
views. There is now a border on each side of the view, with one pixel red and
one black.
### Added
- added a **revive-buffer** command, bound to **C-x r** in the global keymap.
This allow to reopen a previously closed buffer.
- added the **revive-buffers-limit** variable, to specify how many buffers might
be revived. This defaults to 10.
- added basic handling of web features to enable video, audio from javascript.
- added two variables to customize how webmacs starts: **home-page** and
**home-page-in-new-window**.
- added a command to restore previous session (windows and buffers),
**restore-session**.
- Under X11, if the --instance is passed at the command line, the
WM_CLASS property is set to "webmacs-{instance}".
- added basic support for multiple windows. New commands added: **make-window**,
**other-window**, **close-window**, **close-other-window**.
- saving and restoring web views in session
- saving and restoring window position and state in session
- added a variable **webview-stylesheet** to customize the above view style.
- added a command **buffer-unselect** to clear selection in the current buffer.
- bound **buffer-unselect** to **C-g** in the webbuffer keymap.
## [0.3]
### Added
- keymaps can now have a name and associated documentation
- added command **describe-commands** to list all named webmacs commands
- added command **describe-bindings** to list named commands in named keymaps
- added command **describe-variables** to list named webmacs variables
- added command **downloads** to open a buffer to see downloads of the session
- added command **version** to open a version buffer.
- added command **describe-variable** to describe a variable (bound to C-h v)
- added command **describe-command** to describe a command (bound to C-h c)
- added command **describe-key** to describe a keychord (bound to C-h k)
- added python dependency *pygments* to render source code.
- added a command line flag **--instance** to run named instances of webmacs
### Fixed
- If webmacs has crashed, the local socket used for ipc is now cleaned, so other
commands for this webmacs instance are forwarded and does not anymore create a
new instance.
- do not set the webbuffer active keymap as the current local keymap if the
minibuffer input is currently opened.
## [0.2]
The distinction between 0.1 and 0.2 version is not clear unfortunately - patches
were just going in the main git branch. To highlight some features, let's start
the version 0.2 from the commit cb0cea39eaab6a01ee74ca16261c2b467b4af5a3.
### Added
- buffers loading from last session are delayed until they are displayed
- added caret browsing support, with a specific keymap and its set of commands.
The **C** binding in a web buffer enter the caret browsing mode
- added new variable **adblock-urls-rules** to list rules url for the ad-blocker
- added new variable **webjump-default**
- better prompt completion
- added information in the minibuffer
- added new variable **minibuffer-right-label** for the format of the displayed
information in the minibuffer
- support for bookmarks (see **bookmark-add** and **bookmark-open** commands,
bound to respectively **M** and **m** in the webbuffer keymap).
- support for zoom and text zoom. See the **zoom-\*** and **text-zoom-\***
commands.
- added undefine_key method on Keymaps to unbind keys
- added command **close-other-buffers**
- added basic notion of mode to a web buffer, normal usage being "standard-mode"
and a new mode "no-keybindings"
- added new variable **auto-buffer-modes** to set up rules for settings web
buffer mode based on urls
- added new command **content-edit-open-external-editor** to open a text editor
to edit web content, bound to **Cx e** and **C-x C-e** in the webcontent-edit
keymap. The external command to run is stored in the variable
**external-editor-command**.
- added **content-edit-undo** and **content-edit-redo** commands, bound
respectively to **C-/** and **C-?** in webcontent-edit keymap.
- added spell check support, configurable with the
**spell-checking-dictionaries** variable.
### Fixed
- fixed segfault with some graphic cards
- retrieving ad-block rules and compiling them is now done in a thread, so
webmacs is not slow at startup anymore
- added a warning when using opengl with the nouveau driver.
- default qt shortcuts in webviews are removed, so webmacs bindings are working
without side-effect anymore (e.g., C-a was sometimes selecting the text)
- changed implementation of the webcontent-edit movement text commands, so now
undo redo works better and it also mostly works in contenteditable fields
================================================
FILE: COPYING
================================================
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Copyright (C)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see Copyright (C)
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.
================================================
FILE: README-nix.org
================================================
* Installation with Nix
There are two recommended ways of installing webmacs:
1. Nix
2. pip/virtualenv
** Nix
Currently, the easiest way to install webmacs is via the [[https://nixos.org/nix/][Nix package
manager]]:
#+BEGIN_SRC bash
nix-env -i webmacs
#+END_SRC
*** Need more help with nix?
Nix is available for Linux, macOS and other Unix-like systems. Rest
assured that removing Nix (along with any packages installed using
Nix) is as easy as =rm /nix -rf=.
If you do not have Nix, install it. For details see
https://nixos.org/nix/manual/#chap-installation, but this step
approximates to
#+BEGIN_SRC bash
bash <(curl https://nixos.org/nix/install)
#+END_SRC
and will require you to provide a sudo password.
Look out for, and follow the instructions which will appear once
nix is installed, and which will look something like this:
#+BEGIN_SRC text
Installation finished! To ensure that the necessary environment
variables are set, either log in again, or type
. /home/yourusername/.nix-profile/etc/profile.d/nix.sh
in your shell.
#+END_SRC
If you don't spot this, the installation will appear to have failed.
Now you can use =nix-env= to install webmacs:
#+BEGIN_SRC bash
nix-env -i webmacs
#+END_SRC
For further details, see
https://nixos.org/nix/manual/#chap-quick-start.
*** working on webmacs with nix
The command
#+BEGIN_SRC bash
nix-shell -p webmacs
#+END_SRC
will drop you into a shell which makes available all the compilers and
libraries required to build and run webmacs, thus =nix-shell= plays
the role of =virtualenv= in the pip/virtualenv approach described
below. Unfortunately, some of the libraries required to run the
tests, are not yet available in this shell.
================================================
FILE: README.org
================================================
* webmacs
*webmacs* is yet another browser for keyboard-based web navigation.
It mainly target emacs-like navigation, and started as a clone (in terms of
features) of [[http://conkeror.org/][conkeror]].
See the documentation manual: https://webmacs.readthedocs.io/en/latest/
webmacs is based on qt webengine and written mainly in Python (version 3).
#+html:
* Features
Short list of features:
- keyboard navigation everywhere (including basic emacs movements in editable
web content)
- Integrated, fast ad-blocker
- [[https://webmacs.readthedocs.io/en/latest/basic_usage.html#live-documentation][live documentation]]
- [[https://webmacs.readthedocs.io/en/latest/user_configuration.html][highly customizable using Python]]
* Installation (... and development)
** Using Nix
See the [[./.README-nix.org][dedicated page]].
** Using pip/virtualenv
Be prepared to have a working c and c++ compiler with python development
library. Note I only have tested on linux.
You will also need the PyQt6 library, as I believe it can't be installed through
pip. It's easy to install using any package manager though.
Then you have to check out the repository (do not forget the *recursive* flag):
#+BEGIN_SRC bash
git clone --recursive https://github.com/parkouss/webmacs
#+END_SRC
To test it, or work on it, I recommend virtualenv:
#+BEGIN_SRC bash
virtualenv --system-site-packages -p python3 venv
# activate the virtualenv
source venv/bin/activate
# install webmacs in there
pip install -e
# and now to run webmacs
python -m webmacs.main
#+END_SRC
Then you can create a system alias to run it:
#+BEGIN_SRC bash
sudo ln -s /bin/webmacs /usr/local/bin/webmacs
# now you can use the webmacs command on your system, given that
# /usr/local/bin is in your PATH.
#+END_SRC
* Running tests
To run the tests, you will need a few more dependencies (the virtualenv needs
to be activated):
#+BEGIN_SRC bash
# install test dependencies
pip install -r /test-requirements.txt
# also install the herbstluftwm window manager, using your package manager.
# Example on fedora:
sudo dnf install herbstluftwm
#+END_SRC
Then you can run the tests (the virtualenv needs to be activated):
#+BEGIN_SRC bash
python -m pytest /tests
# you can run them with the windows visible:
python -m pytest /tests --no-xvfb
#+END_SRC
* Qt versions support
Every stable Qt version from (and including) 6.0 should work with webmacs.
* Contributions
Contributions are much welcome! Writing this browser is exciting and I love
that, though I don't have many time to spend on it, having a family life and a
job; And anyway the more we are to work on it and use the tool, the better!
================================================
FILE: c/adblock.c
================================================
// This file is part of webmacs.
//
// webmacs is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// webmacs is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with webmacs. If not, see
#include "structmember.h"
#include
#include
#include "ad_block_client.h"
using namespace std;
typedef struct {
PyObject_HEAD
AdBlockClient * client;
char * data;
} AdBlock;
static void
AdBlock_dealloc(AdBlock* self)
{
delete self->client;
if (self->data) delete[] self->data;
Py_TYPE(self)->tp_free((PyObject*)self);
}
static PyObject *
AdBlock_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
AdBlock *self;
self = (AdBlock *)type->tp_alloc(type, 0);
return (PyObject *)self;
}
static int
AdBlock_init(AdBlock *self, PyObject *args, PyObject *kwds)
{
self->client = new AdBlockClient;
self->data = NULL;
return 0;
}
static PyObject *
AdBlock_parse(AdBlock* self, PyObject *args)
{
const char *data;
if (!PyArg_ParseTuple(args, "s", &data))
return NULL;
Py_BEGIN_ALLOW_THREADS
self->client->parse(data);
Py_END_ALLOW_THREADS
Py_RETURN_NONE;
}
static PyObject *
AdBlock_matches(AdBlock* self, PyObject *args)
{
const char *url, *domain;
bool result;
if (!PyArg_ParseTuple(args, "ss", &url, &domain))
return NULL;
/* I suspect that allowing threads here does create deadlocks,
but anyway I am not sure it would be useful to allow them. */
/* Py_BEGIN_ALLOW_THREADS */
result = self->client->matches(url, FONoFilterOption, domain);
/* Py_END_ALLOW_THREADS */
if (result) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
}
static PyObject *
AdBlock_save(AdBlock* self, PyObject *args)
{
const char *path;
if (!PyArg_ParseTuple(args, "s", &path))
return NULL;
int size;
ofstream outFile(path, ios::out | ios::binary);
if (!outFile) {
Py_RETURN_FALSE;
}
Py_BEGIN_ALLOW_THREADS
char * buffer = self->client->serialize(&size);
outFile.write(buffer, size);
outFile.close();
Py_END_ALLOW_THREADS
Py_RETURN_TRUE;
}
static PyObject *
AdBlock_load(AdBlock* self, PyObject *args)
{
const char *path;
bool result = false;
if (!PyArg_ParseTuple(args, "s", &path))
return NULL;
ifstream file(path, ios::binary | ios::ate);
if (!file) {
Py_RETURN_FALSE;
}
Py_BEGIN_ALLOW_THREADS
streamsize size = file.tellg();
file.seekg(0, ios::beg);
if (self->data) {delete[] self->data;}
self->data = new char[size];
if (file.read(self->data, size)) {
self->client->deserialize(self->data);
result = true;
}
Py_END_ALLOW_THREADS
if (result) {
Py_RETURN_TRUE;
} else {
Py_RETURN_FALSE;
}
}
static PyMethodDef AdBlock_methods[] = {
{"parse", (PyCFunction)AdBlock_parse, METH_VARARGS,
"Parse adblock data string, like the content of an easylist."
},
{"matches", (PyCFunction)AdBlock_matches, METH_VARARGS,
"matches an url, returns True if it should be filtered."
},
{"save", (PyCFunction)AdBlock_save, METH_VARARGS,
"Save serialized data into a file."
},
{"load", (PyCFunction)AdBlock_load, METH_VARARGS,
"Load serialized data from a file."
},
{NULL} /* Sentinel */
};
static PyTypeObject AdBlockType = {
PyVarObject_HEAD_INIT(NULL, 0)
"adblock.AdBlock", /* tp_name */
sizeof(AdBlock), /* tp_basicsize */
0, /* tp_itemsize */
(destructor)AdBlock_dealloc, /* tp_dealloc */
0, /* tp_print */
0, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_reserved */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
0, /* tp_getattro */
0, /* tp_setattro */
0, /* tp_as_buffer */
Py_TPFLAGS_DEFAULT |
Py_TPFLAGS_BASETYPE, /* tp_flags */
"Adblock objects", /* tp_doc */
0, /* tp_traverse */
0, /* tp_clear */
0, /* tp_richcompare */
0, /* tp_weaklistoffset */
0, /* tp_iter */
0, /* tp_iternext */
AdBlock_methods, /* tp_methods */
0, /* tp_members */
0, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
0, /* tp_descr_set */
0, /* tp_dictoffset */
(initproc)AdBlock_init, /* tp_init */
0, /* tp_alloc */
AdBlock_new, /* tp_new */
};
static PyModuleDef adblockmodule = {
PyModuleDef_HEAD_INIT,
"adblock",
"Module to speed up ad filtering.",
-1,
NULL, NULL, NULL, NULL, NULL
};
PyMODINIT_FUNC
PyInit__adblock(void)
{
PyObject* m;
AdBlockType.tp_new = PyType_GenericNew;
if (PyType_Ready(&AdBlockType) < 0)
return NULL;
m = PyModule_Create(&adblockmodule);
if (m == NULL)
return NULL;
Py_INCREF(&AdBlockType);
PyModule_AddObject(m, "AdBlock", (PyObject *)&AdBlockType);
return m;
}
================================================
FILE: docs/Makefile
================================================
# Minimal makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS = -W
SPHINXBUILD = sphinx-build
SPHINXPROJ = webmacs
SOURCEDIR = .
BUILDDIR = _build
# Put it first so that "make" without argument is like "make help".
help:
@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
.PHONY: help Makefile
# Catch-all target: route all unknown targets to Sphinx using the new
# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS).
%: Makefile
@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
================================================
FILE: docs/advanced_topics.rst
================================================
Advanced topics
===============
.. current-keymap:: global
.. _managing_views:
Managing views
**************
It is possible to manage multiple :term:`views` in a webmacs window:
- :key:`C-x 2` split the current view in two horizontally.
- :key:`C-x 3` split the current view in two vertically.
- :key:`C-x o` navigate in current window views.
- :key:`C-x 0` close the current view.
- :key:`C-x 1` maximize the current view, closing every other view.
Managing windows
****************
You can also manage multiple windows:
- :cmd:`make-window` to create a new window.
- :cmd:`other-window` to navigate through windows.
- :cmd:`close-window` to close the current window.
- :cmd:`close-other-windows` to close all but the current window.
Caret browsing
**************
.. current-keymap:: caret-browsing
Caret browsing allows to navigate in a web page using a caret. It is mainly
useful for copying text inside a web page without using the mouse.
It is enabled by pressing :key:`C (webbuffer)`.
Then you can navigate using arrow keys or standard Emacs bindings:
- :key:`C-n` to go to the next line.
- :key:`C-p` to go to the previous line.
- :key:`C-f` to go to the next character.
- :key:`C-b` to go to the previous character.
- :key:`M-f` to go to the next word.
- :key:`M-b` to go to the previous word.
- :key:`C-e` to go to the end of the line.
- :key:`C-a` to go to the beginning of the line.
You can select some text and copy it using:
- :key:`C-Space` to toggle the mark
- :key:`M-w` to copy the current selection to the clipboard.
.. current-keymap:: webbuffer
.. note::
Incremental search can be used when in caret browsing, to allow easier
navigation.
It is also great to start caret browsing after an incremental search, as the
caret will be at the beginning of the current web selection.
Bookmarks
*********
Bookmarks are like a dictionary of URLs. Each bookmark must have a unique name.
Bookmarks are stored in the profile, and hence are persistent across sessions.
It is possible to manage bookmarks using:
- :key:`M` to create a bookmark.
- :key:`m` to open the bookmark list.
When in the bookmark list, you can:
- :key:`Return (bookmarks-list)` to open the bookmark URL in the current buffer
- :key:`C-k (bookmarks-list)` to remove the highlighted bookmark.
================================================
FILE: docs/api.rst
================================================
Public api
==========
Initialisation
**************
.. autofunction:: webmacs.main.init
Keymaps
*******
.. autofunction:: webmacs.keymaps.keymap
.. autoclass:: webmacs.keymaps.Keymap
:members: define_key, undefine_key
Webjumps
********
.. autofunction:: webmacs.commands.webjump.define_webjump
.. autoclass:: webmacs.commands.webjump.WebJumpCompleter
:members:
.. autoclass:: webmacs.commands.webjump.WebJumpRequestCompleter
.. autoclass:: webmacs.commands.webjump.SyncWebJumpCompleter
.. autofunction:: webmacs.commands.webjump.define_webjump_alias
Variables
*********
.. autofunction:: webmacs.variables.set
.. autofunction:: webmacs.variables.get
.. autoexception:: webmacs.variables.VariableConditionError
================================================
FILE: docs/basic_usage.rst
================================================
Basic usage
===========
Don't panic
***********
When you are stuck in some interactive :term:`command` or text field, and you
are unsure what to do, press **C-g**. This :term:`key binding` usually lets you
out of the current action - you may have to press it more than once. **C-g** is
the universal *get me out of there* command.
.. note::
Usually, pressing **C-g** enough times lets you focus on the current
:term:`web buffer`, and so activates the :keymap:`webbuffer` :term:`keymap`.
.. current-keymap:: global
Running a command using its name
********************************
It is always possible to run a :term:`command` using its name. Some commands
does not have default :term:`key binding`, and requires to be called this
way. To call a command using its name, use the :key:`M-x` keybinding, then
select in the list (or type) the command you want to run, followed by **Return**
(the Enter key).
For example, :key:`M-x` toggle-toolbar will toggle the webmac's
toolbar.
Live documentation
******************
webmacs is self-documenting. You can easily access the documentation by running
the following commands:
- :cmd:`describe-commands` to see all available commands.
- :cmd:`describe-command` (bound to :key:`C-h f`) to choose one command, and get
a detailed description.
- :cmd:`describe-variables` to see all the available :term:`variables`.
- :cmd:`describe-variable` (bound to :key:`C-h v`) to choose one variable and
get a detailed description.
- :cmd:`describe-key` (bound to :key:`C-h k`) or :cmd:`describe-key-briefly` (bound to :key:`C-h c`)
to discover what command a key binding would trigger.
- :cmd:`where-is` (bound to: :key:`C-h w`) to quickly find what key(s) a command is bound to.
- :cmd:`describe-bindings` to see the list of all keymaps, with the bindings
and commands they contain.
.. note::
Self-documentation is super useful for many things. If you want, for example,
to define a custom binding for a command, but don't know its name, you can
always use :key:`C-h k` to help you.
Also, do not hesitate to use :key:`C-h v` to see the description of a
:term:`variable`.
.. current-keymap:: webbuffer
Visiting urls
*************
An easy way to go to a new URL is to type :key:`g`. This calls the :cmd:`go-to`
command, that lets you type a URL or a :term:`webjump`. Pressing **Return**
will then open it in the current web buffer.
For example, try typing: **g g webmacs **. This should open a new
Google page with the query 'webmacs'.
.. important::
Typing **C-u** before :key:`g` will open the url or webjump in a new buffer.
.. _link_hinting:
Link hinting
************
Link hinting is used to navigate through visible links of the current web
buffer's page, using the keyboard only.
Press :key:`f`. You should see the :term:`minibuffer` right label displaying
that you are in the :keymap:`hint` keymap, and the links on the page
highlighted.
.. current-keymap:: hint
Hinting in webmacs can be done using two methods: filter (the default) and
alphabet. You can use the :term:`variable` :var:`hint-method` to change it.
filter
------
There is one active hint. Typing text will narrow down the hint selection by
fuzzy matching against the link's texts. It is also possible to directly type
the number of the link to activate it, and to cycle the visible hints (next,
previous) to change the active hint.
Keybindings are as follows:
- :key:`C-n` activate next visible hint
- :key:`C-p` activate previous visible hint
Note that to validate hinting, :key:`Return` has to be pressed.
alphabet
--------
This is the method used by default in vimium, for example. There is no active
hint, and each link is associated with some characters: they must all be entered
to validate hinting.
Note that the hinting characters are usually randomly picked up from the home
row of the keyboard. This behavior is configured with the :term:`variable`
:var:`hint-alphabet-characters`, defaulting to the home row characters of a
QWERTY keyboard.
.. current-keymap:: webbuffer
.. _managing_buffers:
Managing buffers
****************
You can switch to a buffer using :key:`C-x b (global)`, which opens a list on
top of the :term:`minibuffer`. Select the buffer you want to switch to by
fuzzy-matching text of the url or title page, or just use the arrow keys (or
better, standard Emacs bindings such as **C-n**, **C-p**, **C-v**, **M-v**,
etc). Finally, validate with **Return**.
.. important::
Most of the lists displayed in the :term:`minibuffer` work in this same way,
and have the same basic bindings.
The command is called :cmd:`switch-recent-buffer`.
.. note::
The above command orders the buffers so that the most recently used is on top.
If you want the buffers to be ordeded by their number, you can call the
command :cmd:`switch-buffer`.
You can also navigate to the next or previous buffer by using respectively
:key:`M-n (global)` and :key:`M-p (global)`.
A buffer can be closed by just pressing :key:`q`. When you are running
:cmd:`switch-buffer` or :cmd:`switch-recent-buffer`, pressing :key:`C-k
(buffer-list)` will also kill the buffer currently highlighted in the list.
.. important::
If you killed a buffer by accident, no worries! Just use :key:`C-x r (global)`
to resurrect it.
Navigating through buffer history
*********************************
- :key:`B` goes backward in the buffer history
- :key:`F` goes forward in the buffer history
- :key:`b` shows the current buffer's history as a list in the
:term:`minibuffer`, and allows to easily navigate it.
Navigating through global history
*********************************
Type :key:`h` to display a list of every visited URL (these are saved in a
database file and are persistent in your profile). Select one to open it in the
current buffer.
.. note::
Use **C-u** before :key:`h` to open the URL in a new buffer.
Scrolling in current web buffer
*******************************
- :key:`C-n` or :key:`n` scrolls the current buffer down a bit.
- :key:`C-p` or :key:`p` scrolls the current buffer up a bit.
- :key:`C-b` scrolls the current buffer left a bit.
- :key:`C-f` scrolls the current buffer right a bit.
- :key:`C-v` scrolls the current buffer down for one visible page.
- :key:`M-v` scrolls the current buffer up for one visible page.
- :key:`M-<` lets you go to the top of the page.
- :key:`M->` lets you go to the bottom of the page.
Searching in current web buffer
*******************************
Type :key:`C-s` to start incremental search. Then you can type the text you are
looking for. Press :key:`C-s` again to go to the next match, or :key:`C-r` to go
to the previous match.
.. note::
:key:`C-r` can also be used to start incremental search.
Copying links
*************
- :key:`c u` to copy the URL of the current buffer.
- :key:`c l` to copy a visible link in the buffer (by :term:`hinting`).
- :key:`c c` to copy the currently selected link.
- :key:`c t` to copy the current buffer page title.
Downloading
***********
A download can be started by clicking a link or button or :term:`hinting`.
When a download is about to be started, the :term:`minibuffer` will propose to
either **download** or **open** it.
- **download** will start downloading, and save the file to your hard drive.
- **open** will download to a temporary directory, then open the file with the given
command. A list of available commands is shown in the minibuffer completion
list. Note that when the command exits, the file will be automatically deleted
from your hard drive.
.. note::
open is useful for viewing PDF files for example, as you can use your
favorite PDF file viewer to read it.
The list of downloads can be accessed using the :cmd:`downloads` command.
.. seealso::
See the :var:`default-download-dir` and :var:`keep-temporary-download-dir`
variables.
Zooming
*******
- :key:`+` zoom in.
- :key:`-` zoom out.
- :key:`=` reset the zoom to its default value.
.. note::
There are variants for the zoom, using the Control modifier (:key:`C-+`,
:key:`C--`, and :key:`C-=`) that are used for text zoom only.
Printing
********
- :key:`C-x p` to print the current buffer.
================================================
FILE: docs/concepts.rst
================================================
Concepts
========
Please make sure to understand the following basic webmacs concepts before
further reading the documentation.
.. _concept_commands:
Commands, key bindings and keymaps
**********************************
These are quite similar to the definitions found in the Emacs manual.
- A :term:`command` is a named action which can be done in the browser. For
example, :cmd:`follow` is the command that allows to start hinting links to
navigate.
- A :term:`key binding` is a combination of key presses used to trigger commands.
Key bindings are represented as in Emacs, for example **C-x C-b** means
"holding the Control key while pressing x, then b on the keyboard."
.. note::
The control key is called a modifier. There are three keyboard modifiers:
- **C** represents the Control key.
- **M** represents the Alt key.
- **S** represents the Super key (often called the Windows key)
.. note::
.. current-keymap:: webbuffer
A key binding can also be a single key press. For example, pressing :key:`f`
while in the :keymap:`webbuffer` keymap will trigger the :cmd:`follow`
command.
- A :term:`keymap` is an object holding a mapping between key bindings and
commands, so that a command can be triggered by pressing keyboard keys.
Usually, there is one global keymap, and one active local keymap activated
at the same time - the local keymap changes interactively depending on the
context.
Some important keymaps:
.. webmacs-keymaps::
:only: global, webbuffer, webcontent-edit, caret-browsing
Web buffers
***********
A :term:`web buffer` is like an Emacs buffer, but applying to a Web page.
Buffers are like tabs in other browsers, except that they are not bound to
any view or window.
Windows, views
**************
Differing from Emacs terminology, a window actually is what we nowadays call a
window, and :term:`views` (sometimes called frames) correspond to the content
of a window.
================================================
FILE: docs/conf.py
================================================
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# webmacs documentation build configuration file, created by
# sphinx-quickstart on Sat Dec 23 08:47:03 2017.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#
import os
import sys
sys.path.insert(0, os.path.join(os.path.abspath("."), "ext"))
sys.path.insert(0, os.path.abspath('..'))
# Generating doc don't work without that flag. That could be fixed but anyway
# on readthedocs we can't install binary package so we are stuck for now trying
# to mock everything.
if True or "READTHEDOCS" in os.environ:
# We can not install webmacs on readthedocs, as it requires to
# buid some C extensions (from dateparser, PyQt6, ...). The
# alternative is to mock any dependency used by webmacs.
class Mock(object):
def __init__(self, *a, **kw):
pass
def __getattr__(self, name): # noqa: E301
return Mock()
def __call__(self, *a, **kw): # noqa: E301
return Mock()
def __iter__(self): # noqa: E301
return iter(())
def __instancecheck__(self, instance): # noqa: E301
return True
def __subclasscheck__(self, cls): # noqa: E301
return True
def __mro_entries__(self, a): # noqa: E301
return ()
MOCK_MODULES = ["PyQt6", "PyQt6.QtCore", "PyQt6.QtGui",
"PyQt6.QtWidgets", "PyQt6.QtWebEngineWidgets",
"PyQt6.QtWebEngineCore", "PyQt6.QtWebChannel",
"PyQt6.QtNetwork", "PyQt6.QtPrintSupport",
"_adblock", "dateparser"]
sys.modules.update((mod_name, Mock()) for mod_name in MOCK_MODULES)
# the version number is not important, though it must be an int.
sys.modules["PyQt6.QtCore"].QT_VERSION \
= sys.modules["PyQt6.QtCore"].PYQT_VERSION = 330497
import webmacs # noqa: E402
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = ['sphinx.ext.autodoc',
'sphinx.ext.viewcode', "webmacs_sphinx_ext"]
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
#
# source_suffix = ['.rst', '.md']
source_suffix = '.rst'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = 'webmacs'
copyright = '2017, Julien Pagès'
author = 'Julien Pagès'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = webmacs.__version__
# The full version, including alpha/beta/rc tags.
release = version
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = "en"
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
# This patterns also effect to html_static_path and html_extra_path
exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = False
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
#
html_theme = 'alabaster'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#
html_theme_options = {
'github_user': 'parkouss',
'github_repo': project,
"github_button": True,
'description': "An emacs-like keyboard-driven web browser",
# defaults is 940, gives a bit more so viewcode looks good.
'page_width': "1050px",
}
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
# html_static_path = ['_static']
# Custom sidebar templates, must be a dictionary that maps document names
# to template names.
#
# This is required for the alabaster theme
# refs: http://alabaster.readthedocs.io/en/latest/installation.html#sidebars
html_sidebars = {
'**': [
'about.html',
'navigation.html',
'relations.html', # needs 'show_related': True theme option to display
'searchbox.html',
]
}
# -- Options for HTMLHelp output ------------------------------------------
# Output file base name for HTML help builder.
htmlhelp_basename = 'webmacsdoc'
# -- Options for LaTeX output ---------------------------------------------
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#
# 'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#
# 'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#
# 'preamble': '',
# Latex figure (float) alignment
#
# 'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, 'webmacs.tex', 'webmacs Documentation',
'Julien Pagès', 'manual'),
]
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
(master_doc, 'webmacs', 'webmacs Documentation',
[author], 1)
]
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(master_doc, 'webmacs', 'webmacs Documentation',
author, 'webmacs', 'One line description of project.',
'Miscellaneous'),
]
================================================
FILE: docs/ext/webmacs_sphinx_ext.py
================================================
import re
from docutils.parsers.rst import Directive
from docutils.statemachine import ViewList
from docutils import nodes
from webmacs import COMMANDS
from webmacs.commands import InteractiveCommand
from webmacs.commands.webjump import WEBJUMPS
from webmacs.application import _app_requires
from webmacs.variables import VARIABLES
from webmacs.mode import MODES
from webmacs.keymaps import KEYMAPS
# to include all commands, etc.
_app_requires()
def as_rest_table(data):
numcolumns = len(data[0])
colsizes = [max(len(r[i]) for r in data) for i in range(numcolumns)]
formatter = ' '.join('{:<%d}' % c for c in colsizes)
rowsformatted = [formatter.format(*row) for row in data]
header = formatter.format(*['=' * c for c in colsizes])
yield header
yield rowsformatted[0]
yield header
for row in rowsformatted[1:]:
yield row
yield header
class SimpleAutoDirective(Directive):
has_content = False
required_arguments = 0
optional_arguments = 0
final_argument_whitespace = False
option_spec = {}
def run(self):
self._result = ViewList()
self._run()
node = nodes.paragraph()
node.document = self.state.document
self.state.nested_parse(self._result, 0, node)
return node.children
class WebmacsCommands(SimpleAutoDirective):
def _run(self):
result = self._result
def get_doc(cmd):
if isinstance(cmd, InteractiveCommand):
cmd = cmd.binding
return cmd.__doc__ or "No description"
table = [("Command", "description")]
for name in sorted(COMMANDS):
table.append((name, get_doc(COMMANDS[name])))
for line in as_rest_table(table):
result.append(line, "")
class WebmacsWebjumps(SimpleAutoDirective):
def _run(self):
result = self._result
table = [("Name", "url", "description")]
for name in sorted(WEBJUMPS):
webjump = WEBJUMPS[name]
table.append((name, webjump.url, webjump.doc))
for line in as_rest_table(table):
result.append(line, "")
class WebmacsVariables(SimpleAutoDirective):
def _run(self):
result = self._result
table = [("Name", "description", "default")]
for name in sorted(VARIABLES):
variable = VARIABLES[name]
table.append((name, variable.doc, repr(variable.value)))
for line in as_rest_table(table):
result.append(line, "")
class WebmacsModes(SimpleAutoDirective):
def _run(self):
result = self._result
table = [("Name", "Description")]
for name in sorted(MODES):
mode = MODES[name]
table.append((name, mode.description))
for line in as_rest_table(table):
result.append(line, "")
class WebmacsKeymaps(SimpleAutoDirective):
option_spec = {
"only": lambda a: (a or "").replace(" ", "").split(",")
}
def _run(self):
result = self._result
keys = self.options.get("only") or sorted(KEYMAPS)
table = [("Name", "Description")]
for name in keys:
km = KEYMAPS[name]
table.append((name, km.doc or ""))
for line in as_rest_table(table):
result.append(line, "")
def webmacs_role(data):
"""
Create a simple role function handler that check for the text to be in the
given data, and just create a strong node for the it.
"""
def role(name, rawtext, text, lineno, inliner, options={}, content=[]):
if text not in data:
inliner.reporter.error("No such %s: %s" % (name, text))
node = nodes.strong(text=text)
return [node], []
return role
class CurrentKeymapDirective(Directive):
has_content = False
required_arguments = 1
optional_arguments = 0
final_argument_whitespace = False
option_spec = {}
def run(self):
env = self.state.document.settings.env
keymap = self.arguments[0].strip()
if keymap not in KEYMAPS:
self.state_machine.reporter.error("No such keymap: %s" % keymap)
env.ref_context['webmacs:keymap'] = keymap
return []
KEYMAPS_BINDINGS_CACHE = {}
RE_KEY_MAP = re.compile(r"^(.*)\s+\(([\w-]+)\)$")
def get_keymap_bindings(keymap_name):
if keymap_name not in KEYMAPS_BINDINGS_CACHE:
KEYMAPS_BINDINGS_CACHE[keymap_name] \
= {k: v for k, v in KEYMAPS[keymap_name].all_bindings(raw_fn=True)}
return KEYMAPS_BINDINGS_CACHE[keymap_name]
def key_in_keymap_role(name, rawtext, text, lineno, inliner, options={},
content=[]):
m = RE_KEY_MAP.match(text)
if m:
text = m.group(1)
km = m.group(2)
else:
env = inliner.document.settings.env
try:
km = env.ref_context["webmacs:keymap"]
except KeyError:
inliner.reporter.error(
"no current keymap. Use the current-keymap directive."
)
keys = get_keymap_bindings(km)
if text not in keys:
inliner.reporter.error("No such key: %s in keymap %s" % (text, km))
node = nodes.strong(text=text)
return [node], []
def setup(app):
app.add_directive("webmacs-commands", WebmacsCommands)
app.add_directive("webmacs-webjumps", WebmacsWebjumps)
app.add_directive("webmacs-variables", WebmacsVariables)
app.add_directive("webmacs-modes", WebmacsModes)
app.add_directive("webmacs-keymaps", WebmacsKeymaps)
app.add_directive("current-keymap", CurrentKeymapDirective)
# use them to ensure doc is not outdated, making references to things that
# do not exists.
app.add_role("cmd", webmacs_role(COMMANDS))
app.add_role("var", webmacs_role(VARIABLES))
app.add_role("keymap", webmacs_role(KEYMAPS))
app.add_role("key", key_in_keymap_role)
================================================
FILE: docs/faq.rst
================================================
FAQ
===
How do I run a new webmacs instance instead of a new buffer from the command-line?
**********************************************************************************
When a webmacs instance is already running, calling `webmacs ` from a
shell will open the URL in a new buffer of the running instance. To run a fresh
new instance, use `webmacs --instance `.
How do I run webmacs with a specific profile from the command-line?
**********************************************************************************
To have webmacs use a specific profile, use
`webmacs --profile `. Each profile directory will contain
distinct navigation data (history, cookies, ...).
Website is blocked, turn off the extensions
*******************************************
This message will appear in the browser when the URL has got filtered by the
ad-blocker.
To overcome this, you can temporarily disable the ad-blocker with *M-x toggle-ad-block*.
For a permanent change, edit the :var:`adblock-urls-rules` variable, to remove
some URLs in there. Note if you set this variable to an empty list, the
adblocker will be completely disabled. See the :ref:`user_conf_variables`
section in the documentation.
================================================
FILE: docs/glossary.rst
================================================
Glossary
========
.. glossary::
buffer
web buffer
The content of a web page, not including its window or view.
You can learn the basics of buffer handling in :ref:`managing_buffers`.
command
commands
A command is a named action doable in the browser.
See :ref:`concept_commands` for a detailed description.
See :ref:`Commands ` for a list of commands; or better,
use the :cmd:`describe-commands` command to get live documentation.
hinting
Hinting is used to navigate through the visible links and objects of the
current web buffer's page, using the keyboard only.
See :ref:`link_hinting` for more information.
key binding
key bindings
A **key binding** is a combination of key presses used to trigger commands.
See :ref:`concept_commands` for a detailed description, and
:ref:`user_conf_binding_keys` for custom configuration of key bindings.
keymap
keymaps
A **keymap** is an object holding a mapping between key bindings and
commands.
See :ref:`concept_commands` for a detailed description.
See :ref:`Keymaps ` for a list of keymaps; or better, use
the :cmd:`describe-bindings` command to get live documentation.
minibuffer
The minibuffer is what can be seen at the bottom of a webmacs window. It
displays some information on the right, such as the currently active keymap
and the number of open buffers.
minibuffer input
When webmacs is waiting for some information from you, the
**minibuffer input** is shown: it's a text edit field in which you can type
some text.
Often, there also is a completion list above the minibuffer input.
variable
variables
Some behaviors of *webmacs* can be customized using variables.
See :ref:`user_conf_variables` for variables configuration.
See :ref:`All variables ` to see all the variables;
or better, use :cmd:`describe-variables` to get live documentation.
view
views
A view is a part of a window displaying a buffer. There can be multiple
views in one window.
See :ref:`managing_views`.
webjump
webjumps
A Webjump represents a quick way to access a URL, possibly with a variable
part. A webjump name becomes a part of the webmacs :cmd:`go-to` command, so
for example you can type ``google foo bar`` to execute a Google query with
"foo bar" terms.
See :ref:`user_conf_webjumps` to see the builtins webjumps and how to
configure your owns.
================================================
FILE: docs/index.rst
================================================
.. webmacs documentation master file, created by
sphinx-quickstart on Sat Dec 23 08:47:03 2017.
You can adapt this file completely to your liking, but it should at least
contain the root `toctree` directive.
Welcome to webmacs's documentation!
===================================
**webmacs** is yet another browser for keyboard-based web navigation.
Code is hosted on a `github repository `_.
.. toctree::
:maxdepth: 2
:caption: Contents:
concepts
basic_usage
advanced_topics
user_configuration
api
faq
glossary
Indices and tables
==================
* :ref:`genindex`
* :ref:`modindex`
* :ref:`search`
================================================
FILE: docs/make.bat
================================================
@ECHO OFF
pushd %~dp0
REM Command file for Sphinx documentation
if "%SPHINXBUILD%" == "" (
set SPHINXBUILD=sphinx-build
)
set SOURCEDIR=.
set BUILDDIR=_build
set SPHINXPROJ=webmacs
if "%1" == "" goto help
%SPHINXBUILD% >NUL 2>NUL
if errorlevel 9009 (
echo.
echo.The 'sphinx-build' command was not found. Make sure you have Sphinx
echo.installed, then set the SPHINXBUILD environment variable to point
echo.to the full path of the 'sphinx-build' executable. Alternatively you
echo.may add the Sphinx directory to PATH.
echo.
echo.If you don't have Sphinx installed, grab it from
echo.http://sphinx-doc.org/
exit /b 1
)
%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
goto end
:help
%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
:end
popd
================================================
FILE: docs/user_configuration.rst
================================================
User configuration
==================
**webmacs** can be configured by writing Python code. The files should live in
a ``~/.webmacs/init`` directory, starting with an ``__init__.py`` file.
If this file exists, it will be loaded early in the application.
Note that you have the full power of Python in there, and as it is loaded early,
you can change and adapt nearly every aspect of the webmacs behavior.
.. note::
Only the documented functions and objects here are considered stable (meaning
they will not change without change notes and explanations). Any other API
you can use is considered internal and might change without notification.
The init function
*****************
You can write a function **init** that would be called when webmacs is about to
start. This function must take one parameter (usually named *opts*), that
contains the result of the parsed command line. For now, there is only one
useful parameter:
- opts.url: the url given in the command line, or None
Overriding the init function does override the default init function of webmacs,
though it is still accessible with :func:`webmacs.main.init`. Hello world
example:
.. code-block:: python
import webmacs.main
def init(opts):
print("hello wordl")
if opts.url:
print("{} was given as a command line argument".format(opts.url))
webmacs.main.init(opts)
The default webmacs.main.init function is responsible for restoring the session,
or opening the given URL, for example.
.. note::
It is not required to create an init function in the user configuration
_\_init_\_.py file. Only do so if you want to change the default webmacs
initialization. Other changes can be applied early, directly at the module
level, such as defining :term:`webjumps` or **binding keys**.
Using more than one configuration file
**************************************
It is possible to write more than one configuration file. The
directory where the ``__init__.py`` file lives is a Python package, so
it is possible to just use relative imports.
For example:
``__init__.py``
.. code-block:: python
from . import webjumps
``webjumps.py``
.. code-block:: python
print("definition of my custom webjumps should go there.")
.. _user_conf_variables:
Variables
*********
It is possible to change a variable in the configuration using
:func:`webmacs.variables.set`:
.. code-block:: python
from webmacs import variables
variables.set("webjump-default", "google")
.. _user_conf_all_variables:
Here is the list of the variables:
.. webmacs-variables::
Modes
*****
Modes are used to bind keymaps to a web buffer, by assigning the buffer a given
mode. By default, all buffers use the "standard-mode".
Here is the list of the pre-defined modes:
.. webmacs-modes::
Automatically assign modes depending on the url
-----------------------------------------------
You can use the `auto-buffer-modes` variable.
Example:
.. code-block:: python
from webmacs import variables
variables.set("auto-buffer-modes", [
(".*www.gnu.org.*", "no-keybindings"),
("https://mail.google.com/.*", "no-keybindings")
])
Binding keys
************
In webmacs, like in Emacs, it is possible to bind a key to a command on a given
keymap.
.. _user_conf_keymaps:
Keymaps
-------
Here is the list of available keymaps. Note that you can see them live (with
their associated key bindings) in webmacs by running the command
`describe-bindings`.
.. webmacs-keymaps::
A keymap object in user configuration is retrieved with
:func:`webmacs.keymaps.keymap`.
.. _user_conf_commands:
Commands
--------
Here is the list of the currently available commands:
.. webmacs-commands::
.. _user_conf_binding_keys:
Binding a command to a keymap
-----------------------------
You should use :meth:`webmacs.keymaps.Keymap.define_key`. Here is an example:
.. code-block:: python
from webmacs import keymaps
global_map = keymaps.keymap("global")
global_map.define_key("C-c |", "split-view-right")
global_map.define_key("C-c _", "split-view-bottom")
buffer_keymap = keymaps.keymap("webbuffer")
buffer_keymap.define_key("x", "close-buffer")
.. note::
The global buffer should not define single letter keychords, as you
won't be able to type that letter in editable fields; though, this is
possible in the webbuffer :term:`keymap`.
.. _user_conf_webjumps:
Webjumps
********
Here is the implementation of the google :term:`webjump`:
.. literalinclude:: ../webmacs/default_webjumps.py
:start-after: # ----------- doc example
:end-before: # ----------- end of doc example
The list of defined webjumps in webmacs:
.. webmacs-webjumps::
You can implement your own webjumps, or override the existing
ones. See :func:`webmacs.commands.webjump.define_webjump` and the
example above.
Pressing the ``s`` key will call the command
``search-default``, wich will, by default, use the Google webjump. To change
this default, change the value of the variable *webjump-default*.
It is also possible to define an alias to an existing webjump,
without duplicating its implementation.
.. code-block:: python
from webmacs.commands.webjump import define_webjump_alias
define_webjump_alias("g", "google")
================================================
FILE: git_archive_all.py
================================================
# Script to generate a git archive with submodules
# From https://github.com/Kentzo/git-archive-all
from os import extsep, path, readlink
from shlex import quote
from subprocess import CalledProcessError, Popen, PIPE
from zipfile import ZipFile, ZipInfo, ZIP_DEFLATED
import re
import sys
import tarfile
__version__ = "1.18.1"
class GitArchiver(object):
"""
GitArchiver
Scan a git repository and export all tracked files, and submodules.
Checks for .gitattributes files in each directory and uses 'export-ignore'
pattern entries for ignore files in the archive.
>>> archiver = GitArchiver(main_repo_abspath='my/repo/path')
>>> archiver.create('output.zip')
"""
def __init__(self, prefix='', exclude=True, force_sub=False, extra=None,
main_repo_abspath=None):
"""
@param prefix: Prefix used to prepend all paths in the resulting
archive. Extra file paths are only prefixed if they are not
relative. E.g. if prefix is 'foo' and extra is ['bar', '/baz'] the
resulting archive will look like this:
/
baz
foo/
bar
@type prefix: str
@param exclude: Determines whether archiver should follow rules
specified in .gitattributes files.
@type exclude: bool
@param force_sub: Determines whether submodules are initialized and
updated before archiving. @type force_sub: bool
@param extra: List of extra paths to include in the resulting archive.
@type extra: list
@param main_repo_abspath: Absolute path to the main repository (or one
of subdirectories). If given path is path to a subdirectory (but
not a submodule directory!) it will be replaced with abspath to
top-level directory of the repository. If None, current cwd is
used.
@type main_repo_abspath: str
"""
if extra is None:
extra = []
if main_repo_abspath is None:
main_repo_abspath = path.abspath('')
elif not path.isabs(main_repo_abspath):
raise ValueError("main_repo_abspath must be an absolute path")
try:
main_repo_abspath = path.abspath(
self.run_git_shell('git rev-parse --show-toplevel',
main_repo_abspath).rstrip())
except CalledProcessError:
raise ValueError("{0} is not part of a git repository"
.format(main_repo_abspath))
self.prefix = prefix
self.exclude = exclude
self.extra = extra
self.force_sub = force_sub
self.main_repo_abspath = main_repo_abspath
def create(self, output_path, dry_run=False, output_format=None):
"""
Create the archive at output_file_path.
Type of the archive is determined either by extension of
output_file_path or by output_format. Supported formats are: gz, zip,
bz2, xz, tar, tgz, txz
@param output_path: Output file path.
@type output_path: str
@param dry_run: Determines whether create should do nothing but print
what it would archive.
@type dry_run: bool
@param output_format: Determines format of the output archive. If None,
format is determined from extension of output_file_path.
@type output_format: str
"""
if output_format is None:
file_name, file_ext = path.splitext(output_path)
output_format = file_ext[len(extsep):].lower()
if not dry_run:
if output_format == 'zip':
archive = ZipFile(path.abspath(output_path), 'w')
def add_file(file_path, arcname):
if not path.islink(file_path):
archive.write(file_path, arcname, ZIP_DEFLATED)
else:
i = ZipInfo(arcname)
i.create_system = 3
i.external_attr = 0xA1ED0000
archive.writestr(i, readlink(file_path))
elif output_format in ['tar', 'bz2', 'gz', 'xz', 'tgz', 'txz']:
if output_format == 'tar':
t_mode = 'w'
elif output_format == 'tgz':
t_mode = 'w:gz'
elif output_format == 'txz':
t_mode = 'w:xz'
else:
t_mode = 'w:{0}'.format(output_format)
archive = tarfile.open(path.abspath(output_path), t_mode)
def add_file(file_path, arcname):
archive.add(file_path, arcname)
else:
raise RuntimeError("unknown format: {0}".format(output_format))
def archiver(file_path, arcname):
add_file(file_path, arcname)
else:
archive = None
def archiver(file_path, arcname):
print("{0} => {1}".format(file_path, arcname))
self.archive_all_files(archiver)
if archive is not None:
archive.close()
def is_file_excluded(self, file_path):
"""
Checks whether file at a given path is excluded.
"""
out = self.run_git_shell(
'git check-attr -z export-ignore -- %s' % quote(file_path),
cwd=self.main_repo_abspath
).split('\0')
try:
return out[2] == 'set'
except IndexError:
return False
def archive_all_files(self, archiver):
"""
Archive all files using archiver.
@param archiver: Callable that accepts 2 arguments:
abspath to file on the system and relative path within archive.
@type archiver: Callable
"""
for file_path in self.extra:
archiver(path.abspath(file_path),
path.join(self.prefix, file_path))
for file_path in self.walk_git_files():
archiver(path.join(self.main_repo_abspath, file_path),
path.join(self.prefix, file_path))
def walk_git_files(self, repo_path=''):
"""
An iterator method that yields a file path relative to
main_repo_abspath for each file that should be included in the archive.
Skips those that match the exclusion patterns found in any discovered
.gitattributes files along the way.
Recurs into submodules as well.
@param repo_path: Path to the git submodule repository relative to
main_repo_abspath.
@type repo_path: str
@return: Iterator to traverse files under git control relative to
main_repo_abspath.
@rtype: Iterable
"""
repo_abspath = path.join(self.main_repo_abspath, repo_path)
repo_file_paths = self.run_git_shell(
'git ls-files -z --cached --full-name --no-empty-directory',
repo_abspath
).split('\0')[:-1]
for repo_file_path in repo_file_paths:
# absolute file path
repo_file_abspath = path.join(repo_abspath, repo_file_path)
# file path relative to the main repo
main_repo_file_path = path.join(repo_path, repo_file_path)
# Only list symlinks and files.
if not path.islink(repo_file_abspath) \
and path.isdir(repo_file_abspath):
continue
if self.is_file_excluded(main_repo_file_path):
continue
yield main_repo_file_path
if self.force_sub:
self.run_git_shell('git submodule init', repo_abspath)
self.run_git_shell('git submodule update', repo_abspath)
try:
repo_gitmodules_abspath = path.join(repo_abspath, ".gitmodules")
with open(repo_gitmodules_abspath) as f:
lines = f.readlines()
for l in lines:
m = re.match("^\\s*path\\s*=\\s*(.*)\\s*$", l)
if m:
repo_submodule_path = m.group(1) # relative to repo_path
# relative to main_repo_abspath
gen = self.walk_git_files(
path.join(repo_path, repo_submodule_path))
for main_repo_submodule_fpath in gen:
if self.is_file_excluded(main_repo_submodule_fpath):
continue
yield main_repo_submodule_fpath
except IOError:
pass
@staticmethod
def run_git_shell(cmd, cwd=None):
"""
Runs git shell command, reads output and decodes it into unicode
string.
@param cmd: Command to be executed.
@type cmd: str
@type cwd: str
@param cwd: Working directory.
@rtype: str
@return: Output of the command.
@raise CalledProcessError: Raises exception if return code of the
command is non-zero.
"""
p = Popen(cmd, shell=True, stdout=PIPE, cwd=cwd)
output, _ = p.communicate()
output = output.decode('unicode_escape')\
.encode('raw_unicode_escape').decode('utf-8')
if p.returncode:
if sys.version_info > (2, 6):
raise CalledProcessError(returncode=p.returncode, cmd=cmd,
output=output)
else:
raise CalledProcessError(returncode=p.returncode, cmd=cmd)
return output
def main():
from optparse import OptionParser
parser = OptionParser(
version="%prog {0}".format(__version__)
)
parser.add_option('--prefix',
type='string',
dest='prefix',
default=None,
help="""prepend PREFIX to each filename in the archive.
OUTPUT_FILE name is used by default to avoid tarbomb.
You can set it to '' in order to explicitly request
tarbomb""")
parser.add_option('-v', '--verbose',
action='store_true',
dest='verbose',
help='enable verbose mode')
parser.add_option('--no-exclude',
action='store_false',
dest='exclude',
default=True,
help="don't read .gitattributes files for patterns"
" containing export-ignore attrib")
parser.add_option('--force-submodules',
action='store_true',
dest='force_sub',
help='force a git submodule init && git submodule update'
" at each level before iterating submodules")
parser.add_option('--extra',
action='append',
dest='extra',
default=[],
help="any additional files to include in the archive")
parser.add_option('--dry-run',
action='store_true',
dest='dry_run',
help="don't actually archive anything, just show what"
" would be done")
options, args = parser.parse_args()
if len(args) != 1:
parser.error("You must specify exactly one output file")
output_file_path = args[0]
if path.isdir(output_file_path):
parser.error("You cannot use directory as output")
# avoid tarbomb
if options.prefix is not None:
options.prefix = path.join(options.prefix, '')
else:
import re
output_name = path.basename(output_file_path)
output_name = re.sub(
'(\\.zip|\\.tar|\\.tgz|\\.txz|\\.gz|\\.bz2|\\.xz|\\.tar\\.gz'
'|\\.tar\\.bz2|\\.tar\\.xz)$',
'',
output_name
) or "Archive"
options.prefix = path.join(output_name, '')
try:
archiver = GitArchiver(options.prefix,
options.exclude,
options.force_sub,
options.extra)
archiver.create(output_file_path, options.dry_run)
except Exception as e:
parser.exit(2, "{0}\n".format(e))
sys.exit(0)
if __name__ == '__main__':
main()
================================================
FILE: pytest.ini
================================================
[pytest]
addopts = tests
log_cli = true
log_cli_level = debug
log_format = %(asctime)s %(name)-10s %(levelname)s %(message)s
log_date_format = %Y-%m-%d %H:%M:%S
================================================
FILE: setup.py
================================================
# This file is part of webmacs.
#
# webmacs is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# webmacs is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with webmacs. If not, see iframe testing
top
================================================
FILE: tests/integration/iframe_follow/my_iframe.html
================================================
inside iframe
inside link
================================================
FILE: tests/integration/javascript_prompt/index.html
================================================
inside iframe
prompt
alert
================================================
FILE: tests/integration/navigation/index.html
================================================
page index
================================================
FILE: tests/integration/navigation/page1.html
================================================
first page
================================================
FILE: tests/integration/test_copy_link.py
================================================
from webmacs.keyboardhandler import CommandContext
from webmacs.application import app
from webmacs.commands import COMMANDS
def clipboard_contains(text):
return app().clipboard().text() == text
def test_copy_current_link(session):
session.load_page("iframe_follow", wait_iframes=True)
link = "document.getElementById('a_top')"
session.buffer.runJavaScript("%s.focus()" % link)
session.check_javascript("document.activeElement == %s" % link, True)
COMMANDS["copy-current-link"](CommandContext())
assert session.wait_until(
lambda: clipboard_contains("https://foo/top.html")
)
def test_copy_current_link_in_subframe(session):
session.load_page("iframe_follow", wait_iframes=True)
link = "window.frames[0].document.getElementById('a_inside')"
session.buffer.runJavaScript("%s.focus()" % link)
session.check_javascript(
"document.activeElement.tagName",
'IFRAME'
)
session.check_javascript(
"window.frames[0].document.activeElement == %s" % link,
True
)
COMMANDS["copy-current-link"](CommandContext())
assert session.wait_until(
lambda: clipboard_contains("https://foo/inside.html")
)
def test_copy_current_url(session):
session.load_page("iframe_follow")
url = session.buffer.url().toString()
COMMANDS["copy-current-buffer-url"](CommandContext())
assert session.wait_until(
lambda: clipboard_contains(url)
)
def test_copy_current_title(session):
session.load_page("iframe_follow")
COMMANDS["copy-current-buffer-title"](CommandContext())
assert session.wait_until(
lambda: clipboard_contains("iframe testing")
)
================================================
FILE: tests/integration/test_iframe_navigation.py
================================================
import pytest
INPUT0 = "document.getElementById('input0')"
INPUT0_IFRAME = "window.frames[0].document.getElementById('input0')"
def test_iframe_navigation(session):
"""
Webcontent-edit keymaps are used even in sub frames.
"""
session.load_page("iframe_follow", wait_iframes=True)
session.wkeyclicks("Tab")
session.check_javascript("%s === document.activeElement" % INPUT0, True)
# type some text in INPUT0 and move word backward
session.keyclicks("hello world")
session.check_javascript("%s.value" % INPUT0, "hello world")
session.check_javascript("%s.selectionEnd" % INPUT0, 11)
session.wkeyclicks("M-b")
session.check_javascript("%s.selectionEnd" % INPUT0, 6)
session.wkeyclicks("Tab")
session.check_javascript("%s === window.frames[0].document.activeElement"
% INPUT0_IFRAME, True)
# type some text in INPUT0 inside the iframe and move word backward
session.keyclicks("hello world2")
session.check_javascript("%s.value" % INPUT0_IFRAME, "hello world2")
session.check_javascript("%s.selectionEnd" % INPUT0_IFRAME, 12)
session.wkeyclicks("M-b")
session.check_javascript("%s.selectionEnd" % INPUT0_IFRAME, 6)
@pytest.mark.parametrize("hint_method", ["filter", "alphabet"])
def test_iframe_follow(session, pytestconfig, hint_method, variables):
"""
It is possible to hint things inside sub frames.
"""
variables.set("hint-method", hint_method)
session.load_page("iframe_follow", wait_iframes=True)
end_waiter = session.waiter()
def do_check():
session.check_javascript(
"%s === window.frames[0].document.activeElement"
% INPUT0_IFRAME, True)
session.keyclicks("youhou")
session.check_javascript("%s.value" % INPUT0_IFRAME, "youhou")
end_waiter.set()
def prompt_follow(prompt, _):
wait_hint.wait()
if hint_method == "filter":
session.wkeyclicks("C-n")
# wait until the background color is green, the above keypress has
# been taken in account.
session.check_nav_highlighted(INPUT0_IFRAME)
with session.wait_signal(prompt.closed):
session.wkeyclicks("Enter")
else:
with session.wait_signal(prompt.closed):
session.keyclick("d")
session.call_next(do_check)
session.set_prompt_exec(prompt_follow)
wait_hint = session.wait_hints_ready()
session.wkeyclicks("f")
end_waiter.wait()
================================================
FILE: tests/integration/test_javascript_prompt.py
================================================
import pytest
def check_js_result(res):
def check(session):
session.check_javascript("getContent();", res)
return check
def check_minibuffer(res):
def check(session):
assert session.wait_until(
lambda: session.minibuffer.label.text() == res
)
return check
@pytest.mark.parametrize("selection,input,check", [
# first variable is what is typed in follow command,
# to select the right button to click.
("pro", "y", check_js_result("true")),
("pro", "n", check_js_result("false")),
("aler", None, check_minibuffer("[js-alert] hello there")),
])
def test_confirm(session, selection, input, check):
"""
test javascript confirm.
"""
session.load_page("javascript_prompt")
end_waiter = session.waiter()
def prompt_follow(prompt, _):
session.keyclicks(selection)
session.set_prompt_exec(confirm)
with session.wait_signal(prompt.closed):
session.wkeyclicks("Enter")
if not input:
session.call_next(do_check)
def confirm(prompt, _1):
with session.wait_signal(prompt.closed):
session.keyclicks(input)
session.call_next(do_check)
def do_check():
check(session)
end_waiter.set()
session.set_prompt_exec(prompt_follow)
session.wkeyclicks("f")
end_waiter.wait()
================================================
FILE: tests/integration/test_navigation.py
================================================
from webmacs import BUFFERS
from webmacs.webbuffer import create_buffer
def test_cycle_buffers(session):
"""
Webcontent-edit keymaps are used even in sub frames.
"""
session.load_page("navigation")
session.load_page("navigation/page1.html", buffer=create_buffer())
def on_index_page():
return session.buffer.title() == "page index"
def on_first_page():
return session.buffer.title() == "first page"
assert len(BUFFERS) == 2
assert on_index_page()
session.wkeyclicks("M-n")
assert session.wait_until(on_first_page)
session.wkeyclicks("M-n")
assert session.wait_until(on_index_page)
session.wkeyclicks("M-p")
assert session.wait_until(on_first_page)
session.wkeyclicks("M-p")
assert session.wait_until(on_index_page)
================================================
FILE: tests/integration/test_user_download_dir.py
================================================
import pytest
import os
from webmacs import download_manager
# should be more or less in unit test section, but uses the variables fixture.
def test_get_user_download_dir(variables, tmpdir):
# by default, no custom user download dir
assert download_manager.get_user_download_dir() is None
d1 = str(tmpdir.mkdir("d1"))
d2 = str(tmpdir.mkdir("d2"))
download_manager.TEMPORARY_DOWNLOAD_DIR = d2
# if default-download-_dir is set, use it
variables.set("default-download-dir", d1)
assert download_manager.get_user_download_dir() == d1
# if keep-temporary-download-dir is set, it takes precendence
variables.set("keep-temporary-download-dir", True)
assert download_manager.get_user_download_dir() == d2
variables.set("default-download-dir", "")
assert download_manager.get_user_download_dir() == d2
@pytest.mark.parametrize("fname,expected", [
("/path/to", ("/path", "to")),
("/path/to(1)", ("/path", "to")),
("/path/to(3)", ("/path", "to")),
("/path/to.txt", ("/path", "to.txt")),
("/path/to(1).txt", ("/path", "to.txt")),
("/path/to(3).tar.gz", ("/path", "to.tar.gz")),
])
def test_extract_suggested_filename(fname, expected):
assert download_manager.extract_suggested_filename(fname) == expected
@pytest.mark.parametrize("files, filename, expected", [
([], "toto", "toto"),
(["toto"], "toto", "toto(1)"),
([], "toto.txt", "toto.txt"),
(["toto.txt"], "toto.txt", "toto(1).txt"),
(["toto.tar.gz", "toto(1).tar.gz"], "toto.tar.gz", "toto(2).tar.gz"),
])
def test_find_unique_suggested_path(tmpdir, files, filename, expected):
for name in files:
tmpdir.join(name).ensure(file=True)
dir = str(tmpdir)
assert download_manager.find_unique_suggested_path(dir, filename) \
== os.path.join(dir, expected)
================================================
FILE: tests/test_prompt_history.py
================================================
from webmacs.minibuffer.prompt import PromptHistory
def test_history():
p = PromptHistory(maxsize=10)
# calling next or previous on empty history is alright
assert p.get_next() == ""
assert p.get_previous() == ""
assert p.in_user_value() # we are in user value
# insert some values, a bit more than what the buffer can store
for i in range(12):
p.push(str("test_%d" % i))
# playing around with next/previous
assert p.get_previous() == "test_11"
assert p.get_previous() == "test_10"
assert p.get_next() == "test_11"
assert not p.in_user_value()
# we get back in user value when we do an equal amount of next/previous
# calls
assert p.get_next() == ""
assert p.in_user_value()
# test the custom user value
p.set_user_value("foobar")
assert p.get_next() == "test_2"
assert not p.in_user_value()
assert p.get_previous() == "foobar"
assert p.in_user_value()
assert p.get_next() == "test_2"
assert not p.in_user_value()
# resetting put the state back to initial, including the custom user value
p.reset()
assert p.in_user_value()
assert p.get_next() == "test_2"
assert p.get_previous() == ""
================================================
FILE: tests/test_variables.py
================================================
import pytest
from webmacs.variables import (
VariableConditionError, String, Int, Bool, Float, List, Tuple, Dict
)
def check_type_error(type, value, regex):
with pytest.raises(VariableConditionError) as ei:
type.validate(value)
assert ei.match(regex)
def test_type_string():
s = String()
s.validate("")
s.validate("hello")
check_type_error(s, 1, r"Must be a string")
s = String(choices=["aha", "hoho"])
s.validate("aha")
s.validate("hoho")
check_type_error(s, 1, r"Must be a string")
check_type_error(s, "invalid", r"Must be one of \('aha', 'hoho'\)")
def test_type_int():
i = Int()
i.validate(-5)
i.validate(0)
i.validate(5)
check_type_error(i, "1", r"Must be an integer")
i = Int(min=0, max=5)
i.validate(0)
i.validate(1)
i.validate(5)
check_type_error(i, "1", r"Must be an integer")
check_type_error(i, 6, r"Must be lesser or equal to 5")
check_type_error(i, -1, r"Must be greater or equal to 0")
def test_type_bool():
b = Bool()
b.validate(True)
b.validate(False)
def test_type_list():
l = List(Float(min=0.0)) # noqa: E741
l.validate([])
l.validate([1.1, 6.1])
check_type_error(l, 123, "Must be a list")
check_type_error(l, [2.3, "1"], r"List at position 1: Must be a float")
check_type_error(l, [-2.3, 3.2],
r"List at position 0: Must be greater or equal to 0.0")
def test_type_dict():
d = Dict(String(), Tuple(Int(), Float(min=0.0, max=1.1)))
d.validate({})
d.validate({"1": (1, 0.5)})
check_type_error(d, 123, "Must be a dict")
check_type_error(d, {"1": (1,)},
"Value for key '1': Must be a tuple of size 2")
================================================
FILE: webmacs/__init__.py
================================================
# This file is part of webmacs.
#
# webmacs is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# webmacs is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with webmacs. If not, see as a prefix to open" \
" in a new buffer, or to open in a new window."
open_new_buffer.__doc__ = doc + " in a new buffer."
open_new_window.__doc__ = doc + " in a new window."
================================================
FILE: webmacs/commands/buffer_history.py
================================================
# This file is part of webmacs.
#
# webmacs is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# webmacs is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with webmacs. If not, see '
}
var name = typeof vm === 'string'
? vm
: typeof vm === 'function' && vm.options
? vm.options.name
: vm._isVue
? vm.$options.name || vm.$options._componentTag
: vm.name;
var file = vm._isVue && vm.$options.__file;
if (!name && file) {
var match = file.match(/([^/\\]+)\.vue$/);
name = match && match[1];
}
return (
(name ? ("<" + (classify(name)) + ">") : "") +
(file && includeFile !== false ? (" at " + file) : '')
)
};
var repeat = function (str, n) {
var res = '';
while (n) {
if (n % 2 === 1) { res += str; }
if (n > 1) { str += str; }
n >>= 1;
}
return res
};
var generateComponentTrace = function (vm) {
if (vm._isVue && vm.$parent) {
var tree = [];
var currentRecursiveSequence = 0;
while (vm) {
if (tree.length > 0) {
var last = tree[tree.length - 1];
if (last.constructor === vm.constructor) {
currentRecursiveSequence++;
vm = vm.$parent;
continue
} else if (currentRecursiveSequence > 0) {
tree[tree.length - 1] = [last, currentRecursiveSequence];
currentRecursiveSequence = 0;
}
}
tree.push(vm);
vm = vm.$parent;
}
return '\n\nfound in\n\n' + tree
.map(function (vm, i) { return ("" + (i === 0 ? '---> ' : repeat(' ', 5 + i * 2)) + (Array.isArray(vm)
? ((formatComponentName(vm[0])) + "... (" + (vm[1]) + " recursive calls)")
: formatComponentName(vm))); })
.join('\n')
} else {
return ("\n\n(found in " + (formatComponentName(vm)) + ")")
}
};
}
/* */
function handleError (err, vm, info) {
if (config.errorHandler) {
config.errorHandler.call(null, err, vm, info);
} else {
{
warn(("Error in " + info + ": \"" + (err.toString()) + "\""), vm);
}
/* istanbul ignore else */
if (inBrowser && typeof console !== 'undefined') {
console.error(err);
} else {
throw err
}
}
}
/* */
/* globals MutationObserver */
// can we use __proto__?
var hasProto = '__proto__' in {};
// Browser environment sniffing
var inBrowser = typeof window !== 'undefined';
var UA = inBrowser && window.navigator.userAgent.toLowerCase();
var isIE = UA && /msie|trident/.test(UA);
var isIE9 = UA && UA.indexOf('msie 9.0') > 0;
var isEdge = UA && UA.indexOf('edge/') > 0;
var isAndroid = UA && UA.indexOf('android') > 0;
var isIOS = UA && /iphone|ipad|ipod|ios/.test(UA);
var isChrome = UA && /chrome\/\d+/.test(UA) && !isEdge;
// Firefox has a "watch" function on Object.prototype...
var nativeWatch = ({}).watch;
var supportsPassive = false;
if (inBrowser) {
try {
var opts = {};
Object.defineProperty(opts, 'passive', ({
get: function get () {
/* istanbul ignore next */
supportsPassive = true;
}
})); // https://github.com/facebook/flow/issues/285
window.addEventListener('test-passive', null, opts);
} catch (e) {}
}
// this needs to be lazy-evaled because vue may be required before
// vue-server-renderer can set VUE_ENV
var _isServer;
var isServerRendering = function () {
if (_isServer === undefined) {
/* istanbul ignore if */
if (!inBrowser && typeof global !== 'undefined') {
// detect presence of vue-server-renderer and avoid
// Webpack shimming the process
_isServer = global['process'].env.VUE_ENV === 'server';
} else {
_isServer = false;
}
}
return _isServer
};
// detect devtools
var devtools = inBrowser && window.__VUE_DEVTOOLS_GLOBAL_HOOK__;
/* istanbul ignore next */
function isNative (Ctor) {
return typeof Ctor === 'function' && /native code/.test(Ctor.toString())
}
var hasSymbol =
typeof Symbol !== 'undefined' && isNative(Symbol) &&
typeof Reflect !== 'undefined' && isNative(Reflect.ownKeys);
/**
* Defer a task to execute it asynchronously.
*/
var nextTick = (function () {
var callbacks = [];
var pending = false;
var timerFunc;
function nextTickHandler () {
pending = false;
var copies = callbacks.slice(0);
callbacks.length = 0;
for (var i = 0; i < copies.length; i++) {
copies[i]();
}
}
// the nextTick behavior leverages the microtask queue, which can be accessed
// via either native Promise.then or MutationObserver.
// MutationObserver has wider support, however it is seriously bugged in
// UIWebView in iOS >= 9.3.3 when triggered in touch event handlers. It
// completely stops working after triggering a few times... so, if native
// Promise is available, we will use it:
/* istanbul ignore if */
if (typeof Promise !== 'undefined' && isNative(Promise)) {
var p = Promise.resolve();
var logError = function (err) { console.error(err); };
timerFunc = function () {
p.then(nextTickHandler).catch(logError);
// in problematic UIWebViews, Promise.then doesn't completely break, but
// it can get stuck in a weird state where callbacks are pushed into the
// microtask queue but the queue isn't being flushed, until the browser
// needs to do some other work, e.g. handle a timer. Therefore we can
// "force" the microtask queue to be flushed by adding an empty timer.
if (isIOS) { setTimeout(noop); }
};
} else if (!isIE && typeof MutationObserver !== 'undefined' && (
isNative(MutationObserver) ||
// PhantomJS and iOS 7.x
MutationObserver.toString() === '[object MutationObserverConstructor]'
)) {
// use MutationObserver where native Promise is not available,
// e.g. PhantomJS, iOS7, Android 4.4
var counter = 1;
var observer = new MutationObserver(nextTickHandler);
var textNode = document.createTextNode(String(counter));
observer.observe(textNode, {
characterData: true
});
timerFunc = function () {
counter = (counter + 1) % 2;
textNode.data = String(counter);
};
} else {
// fallback to setTimeout
/* istanbul ignore next */
timerFunc = function () {
setTimeout(nextTickHandler, 0);
};
}
return function queueNextTick (cb, ctx) {
var _resolve;
callbacks.push(function () {
if (cb) {
try {
cb.call(ctx);
} catch (e) {
handleError(e, ctx, 'nextTick');
}
} else if (_resolve) {
_resolve(ctx);
}
});
if (!pending) {
pending = true;
timerFunc();
}
if (!cb && typeof Promise !== 'undefined') {
return new Promise(function (resolve, reject) {
_resolve = resolve;
})
}
}
})();
var _Set;
/* istanbul ignore if */
if (typeof Set !== 'undefined' && isNative(Set)) {
// use native Set when available.
_Set = Set;
} else {
// a non-standard Set polyfill that only works with primitive keys.
_Set = (function () {
function Set () {
this.set = Object.create(null);
}
Set.prototype.has = function has (key) {
return this.set[key] === true
};
Set.prototype.add = function add (key) {
this.set[key] = true;
};
Set.prototype.clear = function clear () {
this.set = Object.create(null);
};
return Set;
}());
}
/* */
var uid = 0;
/**
* A dep is an observable that can have multiple
* directives subscribing to it.
*/
var Dep = function Dep () {
this.id = uid++;
this.subs = [];
};
Dep.prototype.addSub = function addSub (sub) {
this.subs.push(sub);
};
Dep.prototype.removeSub = function removeSub (sub) {
remove(this.subs, sub);
};
Dep.prototype.depend = function depend () {
if (Dep.target) {
Dep.target.addDep(this);
}
};
Dep.prototype.notify = function notify () {
// stabilize the subscriber list first
var subs = this.subs.slice();
for (var i = 0, l = subs.length; i < l; i++) {
subs[i].update();
}
};
// the current target watcher being evaluated.
// this is globally unique because there could be only one
// watcher being evaluated at any time.
Dep.target = null;
var targetStack = [];
function pushTarget (_target) {
if (Dep.target) { targetStack.push(Dep.target); }
Dep.target = _target;
}
function popTarget () {
Dep.target = targetStack.pop();
}
/*
* not type checking this file because flow doesn't play well with
* dynamically accessing methods on Array prototype
*/
var arrayProto = Array.prototype;
var arrayMethods = Object.create(arrayProto);[
'push',
'pop',
'shift',
'unshift',
'splice',
'sort',
'reverse'
]
.forEach(function (method) {
// cache original method
var original = arrayProto[method];
def(arrayMethods, method, function mutator () {
var args = [], len = arguments.length;
while ( len-- ) args[ len ] = arguments[ len ];
var result = original.apply(this, args);
var ob = this.__ob__;
var inserted;
switch (method) {
case 'push':
case 'unshift':
inserted = args;
break
case 'splice':
inserted = args.slice(2);
break
}
if (inserted) { ob.observeArray(inserted); }
// notify change
ob.dep.notify();
return result
});
});
/* */
var arrayKeys = Object.getOwnPropertyNames(arrayMethods);
/**
* By default, when a reactive property is set, the new value is
* also converted to become reactive. However when passing down props,
* we don't want to force conversion because the value may be a nested value
* under a frozen data structure. Converting it would defeat the optimization.
*/
var observerState = {
shouldConvert: true
};
/**
* Observer class that are attached to each observed
* object. Once attached, the observer converts target
* object's property keys into getter/setters that
* collect dependencies and dispatches updates.
*/
var Observer = function Observer (value) {
this.value = value;
this.dep = new Dep();
this.vmCount = 0;
def(value, '__ob__', this);
if (Array.isArray(value)) {
var augment = hasProto
? protoAugment
: copyAugment;
augment(value, arrayMethods, arrayKeys);
this.observeArray(value);
} else {
this.walk(value);
}
};
/**
* Walk through each property and convert them into
* getter/setters. This method should only be called when
* value type is Object.
*/
Observer.prototype.walk = function walk (obj) {
var keys = Object.keys(obj);
for (var i = 0; i < keys.length; i++) {
defineReactive$$1(obj, keys[i], obj[keys[i]]);
}
};
/**
* Observe a list of Array items.
*/
Observer.prototype.observeArray = function observeArray (items) {
for (var i = 0, l = items.length; i < l; i++) {
observe(items[i]);
}
};
// helpers
/**
* Augment an target Object or Array by intercepting
* the prototype chain using __proto__
*/
function protoAugment (target, src, keys) {
/* eslint-disable no-proto */
target.__proto__ = src;
/* eslint-enable no-proto */
}
/**
* Augment an target Object or Array by defining
* hidden properties.
*/
/* istanbul ignore next */
function copyAugment (target, src, keys) {
for (var i = 0, l = keys.length; i < l; i++) {
var key = keys[i];
def(target, key, src[key]);
}
}
/**
* Attempt to create an observer instance for a value,
* returns the new observer if successfully observed,
* or the existing observer if the value already has one.
*/
function observe (value, asRootData) {
if (!isObject(value)) {
return
}
var ob;
if (hasOwn(value, '__ob__') && value.__ob__ instanceof Observer) {
ob = value.__ob__;
} else if (
observerState.shouldConvert &&
!isServerRendering() &&
(Array.isArray(value) || isPlainObject(value)) &&
Object.isExtensible(value) &&
!value._isVue
) {
ob = new Observer(value);
}
if (asRootData && ob) {
ob.vmCount++;
}
return ob
}
/**
* Define a reactive property on an Object.
*/
function defineReactive$$1 (
obj,
key,
val,
customSetter,
shallow
) {
var dep = new Dep();
var property = Object.getOwnPropertyDescriptor(obj, key);
if (property && property.configurable === false) {
return
}
// cater for pre-defined getter/setters
var getter = property && property.get;
var setter = property && property.set;
var childOb = !shallow && observe(val);
Object.defineProperty(obj, key, {
enumerable: true,
configurable: true,
get: function reactiveGetter () {
var value = getter ? getter.call(obj) : val;
if (Dep.target) {
dep.depend();
if (childOb) {
childOb.dep.depend();
if (Array.isArray(value)) {
dependArray(value);
}
}
}
return value
},
set: function reactiveSetter (newVal) {
var value = getter ? getter.call(obj) : val;
/* eslint-disable no-self-compare */
if (newVal === value || (newVal !== newVal && value !== value)) {
return
}
/* eslint-enable no-self-compare */
if ("development" !== 'production' && customSetter) {
customSetter();
}
if (setter) {
setter.call(obj, newVal);
} else {
val = newVal;
}
childOb = !shallow && observe(newVal);
dep.notify();
}
});
}
/**
* Set a property on an object. Adds the new property and
* triggers change notification if the property doesn't
* already exist.
*/
function set (target, key, val) {
if (Array.isArray(target) && isValidArrayIndex(key)) {
target.length = Math.max(target.length, key);
target.splice(key, 1, val);
return val
}
if (hasOwn(target, key)) {
target[key] = val;
return val
}
var ob = (target).__ob__;
if (target._isVue || (ob && ob.vmCount)) {
"development" !== 'production' && warn(
'Avoid adding reactive properties to a Vue instance or its root $data ' +
'at runtime - declare it upfront in the data option.'
);
return val
}
if (!ob) {
target[key] = val;
return val
}
defineReactive$$1(ob.value, key, val);
ob.dep.notify();
return val
}
/**
* Delete a property and trigger change if necessary.
*/
function del (target, key) {
if (Array.isArray(target) && isValidArrayIndex(key)) {
target.splice(key, 1);
return
}
var ob = (target).__ob__;
if (target._isVue || (ob && ob.vmCount)) {
"development" !== 'production' && warn(
'Avoid deleting properties on a Vue instance or its root $data ' +
'- just set it to null.'
);
return
}
if (!hasOwn(target, key)) {
return
}
delete target[key];
if (!ob) {
return
}
ob.dep.notify();
}
/**
* Collect dependencies on array elements when the array is touched, since
* we cannot intercept array element access like property getters.
*/
function dependArray (value) {
for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
e = value[i];
e && e.__ob__ && e.__ob__.dep.depend();
if (Array.isArray(e)) {
dependArray(e);
}
}
}
/* */
/**
* Option overwriting strategies are functions that handle
* how to merge a parent option value and a child option
* value into the final value.
*/
var strats = config.optionMergeStrategies;
/**
* Options with restrictions
*/
{
strats.el = strats.propsData = function (parent, child, vm, key) {
if (!vm) {
warn(
"option \"" + key + "\" can only be used during instance " +
'creation with the `new` keyword.'
);
}
return defaultStrat(parent, child)
};
}
/**
* Helper that recursively merges two data objects together.
*/
function mergeData (to, from) {
if (!from) { return to }
var key, toVal, fromVal;
var keys = Object.keys(from);
for (var i = 0; i < keys.length; i++) {
key = keys[i];
toVal = to[key];
fromVal = from[key];
if (!hasOwn(to, key)) {
set(to, key, fromVal);
} else if (isPlainObject(toVal) && isPlainObject(fromVal)) {
mergeData(toVal, fromVal);
}
}
return to
}
/**
* Data
*/
function mergeDataOrFn (
parentVal,
childVal,
vm
) {
if (!vm) {
// in a Vue.extend merge, both should be functions
if (!childVal) {
return parentVal
}
if (!parentVal) {
return childVal
}
// when parentVal & childVal are both present,
// we need to return a function that returns the
// merged result of both functions... no need to
// check if parentVal is a function here because
// it has to be a function to pass previous merges.
return function mergedDataFn () {
return mergeData(
typeof childVal === 'function' ? childVal.call(this) : childVal,
typeof parentVal === 'function' ? parentVal.call(this) : parentVal
)
}
} else if (parentVal || childVal) {
return function mergedInstanceDataFn () {
// instance merge
var instanceData = typeof childVal === 'function'
? childVal.call(vm)
: childVal;
var defaultData = typeof parentVal === 'function'
? parentVal.call(vm)
: parentVal;
if (instanceData) {
return mergeData(instanceData, defaultData)
} else {
return defaultData
}
}
}
}
strats.data = function (
parentVal,
childVal,
vm
) {
if (!vm) {
if (childVal && typeof childVal !== 'function') {
"development" !== 'production' && warn(
'The "data" option should be a function ' +
'that returns a per-instance value in component ' +
'definitions.',
vm
);
return parentVal
}
return mergeDataOrFn.call(this, parentVal, childVal)
}
return mergeDataOrFn(parentVal, childVal, vm)
};
/**
* Hooks and props are merged as arrays.
*/
function mergeHook (
parentVal,
childVal
) {
return childVal
? parentVal
? parentVal.concat(childVal)
: Array.isArray(childVal)
? childVal
: [childVal]
: parentVal
}
LIFECYCLE_HOOKS.forEach(function (hook) {
strats[hook] = mergeHook;
});
/**
* Assets
*
* When a vm is present (instance creation), we need to do
* a three-way merge between constructor options, instance
* options and parent options.
*/
function mergeAssets (parentVal, childVal) {
var res = Object.create(parentVal || null);
return childVal
? extend(res, childVal)
: res
}
ASSET_TYPES.forEach(function (type) {
strats[type + 's'] = mergeAssets;
});
/**
* Watchers.
*
* Watchers hashes should not overwrite one
* another, so we merge them as arrays.
*/
strats.watch = function (parentVal, childVal) {
// work around Firefox's Object.prototype.watch...
if (parentVal === nativeWatch) { parentVal = undefined; }
if (childVal === nativeWatch) { childVal = undefined; }
/* istanbul ignore if */
if (!childVal) { return Object.create(parentVal || null) }
if (!parentVal) { return childVal }
var ret = {};
extend(ret, parentVal);
for (var key in childVal) {
var parent = ret[key];
var child = childVal[key];
if (parent && !Array.isArray(parent)) {
parent = [parent];
}
ret[key] = parent
? parent.concat(child)
: Array.isArray(child) ? child : [child];
}
return ret
};
/**
* Other object hashes.
*/
strats.props =
strats.methods =
strats.inject =
strats.computed = function (parentVal, childVal) {
if (!parentVal) { return childVal }
var ret = Object.create(null);
extend(ret, parentVal);
if (childVal) { extend(ret, childVal); }
return ret
};
strats.provide = mergeDataOrFn;
/**
* Default strategy.
*/
var defaultStrat = function (parentVal, childVal) {
return childVal === undefined
? parentVal
: childVal
};
/**
* Validate component names
*/
function checkComponents (options) {
for (var key in options.components) {
var lower = key.toLowerCase();
if (isBuiltInTag(lower) || config.isReservedTag(lower)) {
warn(
'Do not use built-in or reserved HTML elements as component ' +
'id: ' + key
);
}
}
}
/**
* Ensure all props option syntax are normalized into the
* Object-based format.
*/
function normalizeProps (options) {
var props = options.props;
if (!props) { return }
var res = {};
var i, val, name;
if (Array.isArray(props)) {
i = props.length;
while (i--) {
val = props[i];
if (typeof val === 'string') {
name = camelize(val);
res[name] = { type: null };
} else {
warn('props must be strings when using array syntax.');
}
}
} else if (isPlainObject(props)) {
for (var key in props) {
val = props[key];
name = camelize(key);
res[name] = isPlainObject(val)
? val
: { type: val };
}
}
options.props = res;
}
/**
* Normalize all injections into Object-based format
*/
function normalizeInject (options) {
var inject = options.inject;
if (Array.isArray(inject)) {
var normalized = options.inject = {};
for (var i = 0; i < inject.length; i++) {
normalized[inject[i]] = inject[i];
}
}
}
/**
* Normalize raw function directives into object format.
*/
function normalizeDirectives (options) {
var dirs = options.directives;
if (dirs) {
for (var key in dirs) {
var def = dirs[key];
if (typeof def === 'function') {
dirs[key] = { bind: def, update: def };
}
}
}
}
/**
* Merge two option objects into a new one.
* Core utility used in both instantiation and inheritance.
*/
function mergeOptions (
parent,
child,
vm
) {
{
checkComponents(child);
}
if (typeof child === 'function') {
child = child.options;
}
normalizeProps(child);
normalizeInject(child);
normalizeDirectives(child);
var extendsFrom = child.extends;
if (extendsFrom) {
parent = mergeOptions(parent, extendsFrom, vm);
}
if (child.mixins) {
for (var i = 0, l = child.mixins.length; i < l; i++) {
parent = mergeOptions(parent, child.mixins[i], vm);
}
}
var options = {};
var key;
for (key in parent) {
mergeField(key);
}
for (key in child) {
if (!hasOwn(parent, key)) {
mergeField(key);
}
}
function mergeField (key) {
var strat = strats[key] || defaultStrat;
options[key] = strat(parent[key], child[key], vm, key);
}
return options
}
/**
* Resolve an asset.
* This function is used because child instances need access
* to assets defined in its ancestor chain.
*/
function resolveAsset (
options,
type,
id,
warnMissing
) {
/* istanbul ignore if */
if (typeof id !== 'string') {
return
}
var assets = options[type];
// check local registration variations first
if (hasOwn(assets, id)) { return assets[id] }
var camelizedId = camelize(id);
if (hasOwn(assets, camelizedId)) { return assets[camelizedId] }
var PascalCaseId = capitalize(camelizedId);
if (hasOwn(assets, PascalCaseId)) { return assets[PascalCaseId] }
// fallback to prototype chain
var res = assets[id] || assets[camelizedId] || assets[PascalCaseId];
if ("development" !== 'production' && warnMissing && !res) {
warn(
'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
options
);
}
return res
}
/* */
function validateProp (
key,
propOptions,
propsData,
vm
) {
var prop = propOptions[key];
var absent = !hasOwn(propsData, key);
var value = propsData[key];
// handle boolean props
if (isType(Boolean, prop.type)) {
if (absent && !hasOwn(prop, 'default')) {
value = false;
} else if (!isType(String, prop.type) && (value === '' || value === hyphenate(key))) {
value = true;
}
}
// check default value
if (value === undefined) {
value = getPropDefaultValue(vm, prop, key);
// since the default value is a fresh copy,
// make sure to observe it.
var prevShouldConvert = observerState.shouldConvert;
observerState.shouldConvert = true;
observe(value);
observerState.shouldConvert = prevShouldConvert;
}
{
assertProp(prop, key, value, vm, absent);
}
return value
}
/**
* Get the default value of a prop.
*/
function getPropDefaultValue (vm, prop, key) {
// no default, return undefined
if (!hasOwn(prop, 'default')) {
return undefined
}
var def = prop.default;
// warn against non-factory defaults for Object & Array
if ("development" !== 'production' && isObject(def)) {
warn(
'Invalid default value for prop "' + key + '": ' +
'Props with type Object/Array must use a factory function ' +
'to return the default value.',
vm
);
}
// the raw prop value was also undefined from previous render,
// return previous default value to avoid unnecessary watcher trigger
if (vm && vm.$options.propsData &&
vm.$options.propsData[key] === undefined &&
vm._props[key] !== undefined
) {
return vm._props[key]
}
// call factory function for non-Function types
// a value is Function if its prototype is function even across different execution context
return typeof def === 'function' && getType(prop.type) !== 'Function'
? def.call(vm)
: def
}
/**
* Assert whether a prop is valid.
*/
function assertProp (
prop,
name,
value,
vm,
absent
) {
if (prop.required && absent) {
warn(
'Missing required prop: "' + name + '"',
vm
);
return
}
if (value == null && !prop.required) {
return
}
var type = prop.type;
var valid = !type || type === true;
var expectedTypes = [];
if (type) {
if (!Array.isArray(type)) {
type = [type];
}
for (var i = 0; i < type.length && !valid; i++) {
var assertedType = assertType(value, type[i]);
expectedTypes.push(assertedType.expectedType || '');
valid = assertedType.valid;
}
}
if (!valid) {
warn(
'Invalid prop: type check failed for prop "' + name + '".' +
' Expected ' + expectedTypes.map(capitalize).join(', ') +
', got ' + Object.prototype.toString.call(value).slice(8, -1) + '.',
vm
);
return
}
var validator = prop.validator;
if (validator) {
if (!validator(value)) {
warn(
'Invalid prop: custom validator check failed for prop "' + name + '".',
vm
);
}
}
}
var simpleCheckRE = /^(String|Number|Boolean|Function|Symbol)$/;
function assertType (value, type) {
var valid;
var expectedType = getType(type);
if (simpleCheckRE.test(expectedType)) {
var t = typeof value;
valid = t === expectedType.toLowerCase();
// for primitive wrapper objects
if (!valid && t === 'object') {
valid = value instanceof type;
}
} else if (expectedType === 'Object') {
valid = isPlainObject(value);
} else if (expectedType === 'Array') {
valid = Array.isArray(value);
} else {
valid = value instanceof type;
}
return {
valid: valid,
expectedType: expectedType
}
}
/**
* Use function string name to check built-in types,
* because a simple equality check will fail when running
* across different vms / iframes.
*/
function getType (fn) {
var match = fn && fn.toString().match(/^\s*function (\w+)/);
return match ? match[1] : ''
}
function isType (type, fn) {
if (!Array.isArray(fn)) {
return getType(fn) === getType(type)
}
for (var i = 0, len = fn.length; i < len; i++) {
if (getType(fn[i]) === getType(type)) {
return true
}
}
/* istanbul ignore next */
return false
}
/* */
var mark;
var measure;
{
var perf = inBrowser && window.performance;
/* istanbul ignore if */
if (
perf &&
perf.mark &&
perf.measure &&
perf.clearMarks &&
perf.clearMeasures
) {
mark = function (tag) { return perf.mark(tag); };
measure = function (name, startTag, endTag) {
perf.measure(name, startTag, endTag);
perf.clearMarks(startTag);
perf.clearMarks(endTag);
perf.clearMeasures(name);
};
}
}
/* not type checking this file because flow doesn't play well with Proxy */
var initProxy;
{
var allowedGlobals = makeMap(
'Infinity,undefined,NaN,isFinite,isNaN,' +
'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
'require' // for Webpack/Browserify
);
var warnNonPresent = function (target, key) {
warn(
"Property or method \"" + key + "\" is not defined on the instance but " +
"referenced during render. Make sure to declare reactive data " +
"properties in the data option.",
target
);
};
var hasProxy =
typeof Proxy !== 'undefined' &&
Proxy.toString().match(/native code/);
if (hasProxy) {
var isBuiltInModifier = makeMap('stop,prevent,self,ctrl,shift,alt,meta');
config.keyCodes = new Proxy(config.keyCodes, {
set: function set (target, key, value) {
if (isBuiltInModifier(key)) {
warn(("Avoid overwriting built-in modifier in config.keyCodes: ." + key));
return false
} else {
target[key] = value;
return true
}
}
});
}
var hasHandler = {
has: function has (target, key) {
var has = key in target;
var isAllowed = allowedGlobals(key) || key.charAt(0) === '_';
if (!has && !isAllowed) {
warnNonPresent(target, key);
}
return has || !isAllowed
}
};
var getHandler = {
get: function get (target, key) {
if (typeof key === 'string' && !(key in target)) {
warnNonPresent(target, key);
}
return target[key]
}
};
initProxy = function initProxy (vm) {
if (hasProxy) {
// determine which proxy handler to use
var options = vm.$options;
var handlers = options.render && options.render._withStripped
? getHandler
: hasHandler;
vm._renderProxy = new Proxy(vm, handlers);
} else {
vm._renderProxy = vm;
}
};
}
/* */
var VNode = function VNode (
tag,
data,
children,
text,
elm,
context,
componentOptions,
asyncFactory
) {
this.tag = tag;
this.data = data;
this.children = children;
this.text = text;
this.elm = elm;
this.ns = undefined;
this.context = context;
this.functionalContext = undefined;
this.key = data && data.key;
this.componentOptions = componentOptions;
this.componentInstance = undefined;
this.parent = undefined;
this.raw = false;
this.isStatic = false;
this.isRootInsert = true;
this.isComment = false;
this.isCloned = false;
this.isOnce = false;
this.asyncFactory = asyncFactory;
this.asyncMeta = undefined;
this.isAsyncPlaceholder = false;
};
var prototypeAccessors = { child: {} };
// DEPRECATED: alias for componentInstance for backwards compat.
/* istanbul ignore next */
prototypeAccessors.child.get = function () {
return this.componentInstance
};
Object.defineProperties( VNode.prototype, prototypeAccessors );
var createEmptyVNode = function (text) {
if ( text === void 0 ) text = '';
var node = new VNode();
node.text = text;
node.isComment = true;
return node
};
function createTextVNode (val) {
return new VNode(undefined, undefined, undefined, String(val))
}
// optimized shallow clone
// used for static nodes and slot nodes because they may be reused across
// multiple renders, cloning them avoids errors when DOM manipulations rely
// on their elm reference.
function cloneVNode (vnode, deep) {
var cloned = new VNode(
vnode.tag,
vnode.data,
vnode.children,
vnode.text,
vnode.elm,
vnode.context,
vnode.componentOptions,
vnode.asyncFactory
);
cloned.ns = vnode.ns;
cloned.isStatic = vnode.isStatic;
cloned.key = vnode.key;
cloned.isComment = vnode.isComment;
cloned.isCloned = true;
if (deep && vnode.children) {
cloned.children = cloneVNodes(vnode.children);
}
return cloned
}
function cloneVNodes (vnodes, deep) {
var len = vnodes.length;
var res = new Array(len);
for (var i = 0; i < len; i++) {
res[i] = cloneVNode(vnodes[i], deep);
}
return res
}
/* */
var normalizeEvent = cached(function (name) {
var passive = name.charAt(0) === '&';
name = passive ? name.slice(1) : name;
var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
name = once$$1 ? name.slice(1) : name;
var capture = name.charAt(0) === '!';
name = capture ? name.slice(1) : name;
var plain = !(passive || once$$1 || capture);
return {
name: name,
plain: plain,
once: once$$1,
capture: capture,
passive: passive
}
});
function createFnInvoker (fns) {
function invoker () {
var arguments$1 = arguments;
var fns = invoker.fns;
if (Array.isArray(fns)) {
var cloned = fns.slice();
for (var i = 0; i < cloned.length; i++) {
cloned[i].apply(null, arguments$1);
}
} else {
// return handler return value for single handlers
return fns.apply(null, arguments)
}
}
invoker.fns = fns;
return invoker
}
// #6552
function prioritizePlainEvents (a, b) {
return a.plain ? -1 : b.plain ? 1 : 0
}
function updateListeners (
on,
oldOn,
add,
remove$$1,
vm
) {
var name, cur, old, event;
var toAdd = [];
var hasModifier = false;
for (name in on) {
cur = on[name];
old = oldOn[name];
event = normalizeEvent(name);
if (!event.plain) { hasModifier = true; }
if (isUndef(cur)) {
"development" !== 'production' && warn(
"Invalid handler for event \"" + (event.name) + "\": got " + String(cur),
vm
);
} else if (isUndef(old)) {
if (isUndef(cur.fns)) {
cur = on[name] = createFnInvoker(cur);
}
event.handler = cur;
toAdd.push(event);
} else if (cur !== old) {
old.fns = cur;
on[name] = old;
}
}
if (toAdd.length) {
if (hasModifier) { toAdd.sort(prioritizePlainEvents); }
for (var i = 0; i < toAdd.length; i++) {
var event$1 = toAdd[i];
add(event$1.name, event$1.handler, event$1.once, event$1.capture, event$1.passive);
}
}
for (name in oldOn) {
if (isUndef(on[name])) {
event = normalizeEvent(name);
remove$$1(event.name, oldOn[name], event.capture);
}
}
}
/* */
function mergeVNodeHook (def, hookKey, hook) {
var invoker;
var oldHook = def[hookKey];
function wrappedHook () {
hook.apply(this, arguments);
// important: remove merged hook to ensure it's called only once
// and prevent memory leak
remove(invoker.fns, wrappedHook);
}
if (isUndef(oldHook)) {
// no existing hook
invoker = createFnInvoker([wrappedHook]);
} else {
/* istanbul ignore if */
if (isDef(oldHook.fns) && isTrue(oldHook.merged)) {
// already a merged invoker
invoker = oldHook;
invoker.fns.push(wrappedHook);
} else {
// existing plain hook
invoker = createFnInvoker([oldHook, wrappedHook]);
}
}
invoker.merged = true;
def[hookKey] = invoker;
}
/* */
function extractPropsFromVNodeData (
data,
Ctor,
tag
) {
// we are only extracting raw values here.
// validation and default values are handled in the child
// component itself.
var propOptions = Ctor.options.props;
if (isUndef(propOptions)) {
return
}
var res = {};
var attrs = data.attrs;
var props = data.props;
if (isDef(attrs) || isDef(props)) {
for (var key in propOptions) {
var altKey = hyphenate(key);
{
var keyInLowerCase = key.toLowerCase();
if (
key !== keyInLowerCase &&
attrs && hasOwn(attrs, keyInLowerCase)
) {
tip(
"Prop \"" + keyInLowerCase + "\" is passed to component " +
(formatComponentName(tag || Ctor)) + ", but the declared prop name is" +
" \"" + key + "\". " +
"Note that HTML attributes are case-insensitive and camelCased " +
"props need to use their kebab-case equivalents when using in-DOM " +
"templates. You should probably use \"" + altKey + "\" instead of \"" + key + "\"."
);
}
}
checkProp(res, props, key, altKey, true) ||
checkProp(res, attrs, key, altKey, false);
}
}
return res
}
function checkProp (
res,
hash,
key,
altKey,
preserve
) {
if (isDef(hash)) {
if (hasOwn(hash, key)) {
res[key] = hash[key];
if (!preserve) {
delete hash[key];
}
return true
} else if (hasOwn(hash, altKey)) {
res[key] = hash[altKey];
if (!preserve) {
delete hash[altKey];
}
return true
}
}
return false
}
/* */
// The template compiler attempts to minimize the need for normalization by
// statically analyzing the template at compile time.
//
// For plain HTML markup, normalization can be completely skipped because the
// generated render function is guaranteed to return Array. There are
// two cases where extra normalization is needed:
// 1. When the children contains components - because a functional component
// may return an Array instead of a single root. In this case, just a simple
// normalization is needed - if any child is an Array, we flatten the whole
// thing with Array.prototype.concat. It is guaranteed to be only 1-level deep
// because functional components already normalize their own children.
function simpleNormalizeChildren (children) {
for (var i = 0; i < children.length; i++) {
if (Array.isArray(children[i])) {
return Array.prototype.concat.apply([], children)
}
}
return children
}
// 2. When the children contains constructs that always generated nested Arrays,
// e.g. , , v-for, or when the children is provided by user
// with hand-written render functions / JSX. In such cases a full normalization
// is needed to cater to all possible types of children values.
function normalizeChildren (children) {
return isPrimitive(children)
? [createTextVNode(children)]
: Array.isArray(children)
? normalizeArrayChildren(children)
: undefined
}
function isTextNode (node) {
return isDef(node) && isDef(node.text) && isFalse(node.isComment)
}
function normalizeArrayChildren (children, nestedIndex) {
var res = [];
var i, c, last;
for (i = 0; i < children.length; i++) {
c = children[i];
if (isUndef(c) || typeof c === 'boolean') { continue }
last = res[res.length - 1];
// nested
if (Array.isArray(c)) {
res.push.apply(res, normalizeArrayChildren(c, ((nestedIndex || '') + "_" + i)));
} else if (isPrimitive(c)) {
if (isTextNode(last)) {
// merge adjacent text nodes
// this is necessary for SSR hydration because text nodes are
// essentially merged when rendered to HTML strings
(last).text += String(c);
} else if (c !== '') {
// convert primitive to vnode
res.push(createTextVNode(c));
}
} else {
if (isTextNode(c) && isTextNode(last)) {
// merge adjacent text nodes
res[res.length - 1] = createTextVNode(last.text + c.text);
} else {
// default key for nested array children (likely generated by v-for)
if (isTrue(children._isVList) &&
isDef(c.tag) &&
isUndef(c.key) &&
isDef(nestedIndex)) {
c.key = "__vlist" + nestedIndex + "_" + i + "__";
}
res.push(c);
}
}
}
return res
}
/* */
function ensureCtor (comp, base) {
if (comp.__esModule && comp.default) {
comp = comp.default;
}
return isObject(comp)
? base.extend(comp)
: comp
}
function createAsyncPlaceholder (
factory,
data,
context,
children,
tag
) {
var node = createEmptyVNode();
node.asyncFactory = factory;
node.asyncMeta = { data: data, context: context, children: children, tag: tag };
return node
}
function resolveAsyncComponent (
factory,
baseCtor,
context
) {
if (isTrue(factory.error) && isDef(factory.errorComp)) {
return factory.errorComp
}
if (isDef(factory.resolved)) {
return factory.resolved
}
if (isTrue(factory.loading) && isDef(factory.loadingComp)) {
return factory.loadingComp
}
if (isDef(factory.contexts)) {
// already pending
factory.contexts.push(context);
} else {
var contexts = factory.contexts = [context];
var sync = true;
var forceRender = function () {
for (var i = 0, l = contexts.length; i < l; i++) {
contexts[i].$forceUpdate();
}
};
var resolve = once(function (res) {
// cache resolved
factory.resolved = ensureCtor(res, baseCtor);
// invoke callbacks only if this is not a synchronous resolve
// (async resolves are shimmed as synchronous during SSR)
if (!sync) {
forceRender();
}
});
var reject = once(function (reason) {
"development" !== 'production' && warn(
"Failed to resolve async component: " + (String(factory)) +
(reason ? ("\nReason: " + reason) : '')
);
if (isDef(factory.errorComp)) {
factory.error = true;
forceRender();
}
});
var res = factory(resolve, reject);
if (isObject(res)) {
if (typeof res.then === 'function') {
// () => Promise
if (isUndef(factory.resolved)) {
res.then(resolve, reject);
}
} else if (isDef(res.component) && typeof res.component.then === 'function') {
res.component.then(resolve, reject);
if (isDef(res.error)) {
factory.errorComp = ensureCtor(res.error, baseCtor);
}
if (isDef(res.loading)) {
factory.loadingComp = ensureCtor(res.loading, baseCtor);
if (res.delay === 0) {
factory.loading = true;
} else {
setTimeout(function () {
if (isUndef(factory.resolved) && isUndef(factory.error)) {
factory.loading = true;
forceRender();
}
}, res.delay || 200);
}
}
if (isDef(res.timeout)) {
setTimeout(function () {
if (isUndef(factory.resolved)) {
reject(
"timeout (" + (res.timeout) + "ms)"
);
}
}, res.timeout);
}
}
}
sync = false;
// return in case resolved synchronously
return factory.loading
? factory.loadingComp
: factory.resolved
}
}
/* */
function isAsyncPlaceholder (node) {
return node.isComment && node.asyncFactory
}
/* */
function getFirstComponentChild (children) {
if (Array.isArray(children)) {
for (var i = 0; i < children.length; i++) {
var c = children[i];
if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
return c
}
}
}
}
/* */
/* */
function initEvents (vm) {
vm._events = Object.create(null);
vm._hasHookEvent = false;
// init parent attached events
var listeners = vm.$options._parentListeners;
if (listeners) {
updateComponentListeners(vm, listeners);
}
}
var target;
function add (event, fn, once$$1) {
if (once$$1) {
target.$once(event, fn);
} else {
target.$on(event, fn);
}
}
function remove$1 (event, fn) {
target.$off(event, fn);
}
function updateComponentListeners (
vm,
listeners,
oldListeners
) {
target = vm;
updateListeners(listeners, oldListeners || {}, add, remove$1, vm);
}
function eventsMixin (Vue) {
var hookRE = /^hook:/;
Vue.prototype.$on = function (event, fn) {
var this$1 = this;
var vm = this;
if (Array.isArray(event)) {
for (var i = 0, l = event.length; i < l; i++) {
this$1.$on(event[i], fn);
}
} else {
(vm._events[event] || (vm._events[event] = [])).push(fn);
// optimize hook:event cost by using a boolean flag marked at registration
// instead of a hash lookup
if (hookRE.test(event)) {
vm._hasHookEvent = true;
}
}
return vm
};
Vue.prototype.$once = function (event, fn) {
var vm = this;
function on () {
vm.$off(event, on);
fn.apply(vm, arguments);
}
on.fn = fn;
vm.$on(event, on);
return vm
};
Vue.prototype.$off = function (event, fn) {
var this$1 = this;
var vm = this;
// all
if (!arguments.length) {
vm._events = Object.create(null);
return vm
}
// array of events
if (Array.isArray(event)) {
for (var i = 0, l = event.length; i < l; i++) {
this$1.$off(event[i], fn);
}
return vm
}
// specific event
var cbs = vm._events[event];
if (!cbs) {
return vm
}
if (arguments.length === 1) {
vm._events[event] = null;
return vm
}
if (fn) {
// specific handler
var cb;
var i$1 = cbs.length;
while (i$1--) {
cb = cbs[i$1];
if (cb === fn || cb.fn === fn) {
cbs.splice(i$1, 1);
break
}
}
}
return vm
};
Vue.prototype.$emit = function (event) {
var vm = this;
{
var lowerCaseEvent = event.toLowerCase();
if (lowerCaseEvent !== event && vm._events[lowerCaseEvent]) {
tip(
"Event \"" + lowerCaseEvent + "\" is emitted in component " +
(formatComponentName(vm)) + " but the handler is registered for \"" + event + "\". " +
"Note that HTML attributes are case-insensitive and you cannot use " +
"v-on to listen to camelCase events when using in-DOM templates. " +
"You should probably use \"" + (hyphenate(event)) + "\" instead of \"" + event + "\"."
);
}
}
var cbs = vm._events[event];
if (cbs) {
cbs = cbs.length > 1 ? toArray(cbs) : cbs;
var args = toArray(arguments, 1);
for (var i = 0, l = cbs.length; i < l; i++) {
try {
cbs[i].apply(vm, args);
} catch (e) {
handleError(e, vm, ("event handler for \"" + event + "\""));
}
}
}
return vm
};
}
/* */
/**
* Runtime helper for resolving raw children VNodes into a slot object.
*/
function resolveSlots (
children,
context
) {
var slots = {};
if (!children) {
return slots
}
var defaultSlot = [];
for (var i = 0, l = children.length; i < l; i++) {
var child = children[i];
var data = child.data;
// remove slot attribute if the node is resolved as a Vue slot node
if (data && data.attrs && data.attrs.slot) {
delete data.attrs.slot;
}
// named slots should only be respected if the vnode was rendered in the
// same context.
if ((child.context === context || child.functionalContext === context) &&
data && data.slot != null
) {
var name = child.data.slot;
var slot = (slots[name] || (slots[name] = []));
if (child.tag === 'template') {
slot.push.apply(slot, child.children);
} else {
slot.push(child);
}
} else {
defaultSlot.push(child);
}
}
// ignore whitespace
if (!defaultSlot.every(isWhitespace)) {
slots.default = defaultSlot;
}
return slots
}
function isWhitespace (node) {
return node.isComment || node.text === ' '
}
function resolveScopedSlots (
fns, // see flow/vnode
res
) {
res = res || {};
for (var i = 0; i < fns.length; i++) {
if (Array.isArray(fns[i])) {
resolveScopedSlots(fns[i], res);
} else {
res[fns[i].key] = fns[i].fn;
}
}
return res
}
/* */
var activeInstance = null;
var isUpdatingChildComponent = false;
function initLifecycle (vm) {
var options = vm.$options;
// locate first non-abstract parent
var parent = options.parent;
if (parent && !options.abstract) {
while (parent.$options.abstract && parent.$parent) {
parent = parent.$parent;
}
parent.$children.push(vm);
}
vm.$parent = parent;
vm.$root = parent ? parent.$root : vm;
vm.$children = [];
vm.$refs = {};
vm._watcher = null;
vm._inactive = null;
vm._directInactive = false;
vm._isMounted = false;
vm._isDestroyed = false;
vm._isBeingDestroyed = false;
}
function lifecycleMixin (Vue) {
Vue.prototype._update = function (vnode, hydrating) {
var vm = this;
if (vm._isMounted) {
callHook(vm, 'beforeUpdate');
}
var prevEl = vm.$el;
var prevVnode = vm._vnode;
var prevActiveInstance = activeInstance;
activeInstance = vm;
vm._vnode = vnode;
// Vue.prototype.__patch__ is injected in entry points
// based on the rendering backend used.
if (!prevVnode) {
// initial render
vm.$el = vm.__patch__(
vm.$el, vnode, hydrating, false /* removeOnly */,
vm.$options._parentElm,
vm.$options._refElm
);
// no need for the ref nodes after initial patch
// this prevents keeping a detached DOM tree in memory (#5851)
vm.$options._parentElm = vm.$options._refElm = null;
} else {
// updates
vm.$el = vm.__patch__(prevVnode, vnode);
}
activeInstance = prevActiveInstance;
// update __vue__ reference
if (prevEl) {
prevEl.__vue__ = null;
}
if (vm.$el) {
vm.$el.__vue__ = vm;
}
// if parent is an HOC, update its $el as well
if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
vm.$parent.$el = vm.$el;
}
// updated hook is called by the scheduler to ensure that children are
// updated in a parent's updated hook.
};
Vue.prototype.$forceUpdate = function () {
var vm = this;
if (vm._watcher) {
vm._watcher.update();
}
};
Vue.prototype.$destroy = function () {
var vm = this;
if (vm._isBeingDestroyed) {
return
}
callHook(vm, 'beforeDestroy');
vm._isBeingDestroyed = true;
// remove self from parent
var parent = vm.$parent;
if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
remove(parent.$children, vm);
}
// teardown watchers
if (vm._watcher) {
vm._watcher.teardown();
}
var i = vm._watchers.length;
while (i--) {
vm._watchers[i].teardown();
}
// remove reference from data ob
// frozen object may not have observer.
if (vm._data.__ob__) {
vm._data.__ob__.vmCount--;
}
// call the last hook...
vm._isDestroyed = true;
// invoke destroy hooks on current rendered tree
vm.__patch__(vm._vnode, null);
// fire destroyed hook
callHook(vm, 'destroyed');
// turn off all instance listeners.
vm.$off();
// remove __vue__ reference
if (vm.$el) {
vm.$el.__vue__ = null;
}
};
}
function mountComponent (
vm,
el,
hydrating
) {
vm.$el = el;
if (!vm.$options.render) {
vm.$options.render = createEmptyVNode;
{
/* istanbul ignore if */
if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
vm.$options.el || el) {
warn(
'You are using the runtime-only build of Vue where the template ' +
'compiler is not available. Either pre-compile the templates into ' +
'render functions, or use the compiler-included build.',
vm
);
} else {
warn(
'Failed to mount component: template or render function not defined.',
vm
);
}
}
}
callHook(vm, 'beforeMount');
var updateComponent;
/* istanbul ignore if */
if ("development" !== 'production' && config.performance && mark) {
updateComponent = function () {
var name = vm._name;
var id = vm._uid;
var startTag = "vue-perf-start:" + id;
var endTag = "vue-perf-end:" + id;
mark(startTag);
var vnode = vm._render();
mark(endTag);
measure((name + " render"), startTag, endTag);
mark(startTag);
vm._update(vnode, hydrating);
mark(endTag);
measure((name + " patch"), startTag, endTag);
};
} else {
updateComponent = function () {
vm._update(vm._render(), hydrating);
};
}
vm._watcher = new Watcher(vm, updateComponent, noop);
hydrating = false;
// manually mounted instance, call mounted on self
// mounted is called for render-created child components in its inserted hook
if (vm.$vnode == null) {
vm._isMounted = true;
callHook(vm, 'mounted');
}
return vm
}
function updateChildComponent (
vm,
propsData,
listeners,
parentVnode,
renderChildren
) {
{
isUpdatingChildComponent = true;
}
// determine whether component has slot children
// we need to do this before overwriting $options._renderChildren
var hasChildren = !!(
renderChildren || // has new static slots
vm.$options._renderChildren || // has old static slots
parentVnode.data.scopedSlots || // has new scoped slots
vm.$scopedSlots !== emptyObject // has old scoped slots
);
vm.$options._parentVnode = parentVnode;
vm.$vnode = parentVnode; // update vm's placeholder node without re-render
if (vm._vnode) { // update child tree's parent
vm._vnode.parent = parentVnode;
}
vm.$options._renderChildren = renderChildren;
// update $attrs and $listeners hash
// these are also reactive so they may trigger child update if the child
// used them during render
vm.$attrs = (parentVnode.data && parentVnode.data.attrs) || emptyObject;
vm.$listeners = listeners || emptyObject;
// update props
if (propsData && vm.$options.props) {
observerState.shouldConvert = false;
var props = vm._props;
var propKeys = vm.$options._propKeys || [];
for (var i = 0; i < propKeys.length; i++) {
var key = propKeys[i];
props[key] = validateProp(key, vm.$options.props, propsData, vm);
}
observerState.shouldConvert = true;
// keep a copy of raw propsData
vm.$options.propsData = propsData;
}
// update listeners
if (listeners) {
var oldListeners = vm.$options._parentListeners;
vm.$options._parentListeners = listeners;
updateComponentListeners(vm, listeners, oldListeners);
}
// resolve slots + force update if has children
if (hasChildren) {
vm.$slots = resolveSlots(renderChildren, parentVnode.context);
vm.$forceUpdate();
}
{
isUpdatingChildComponent = false;
}
}
function isInInactiveTree (vm) {
while (vm && (vm = vm.$parent)) {
if (vm._inactive) { return true }
}
return false
}
function activateChildComponent (vm, direct) {
if (direct) {
vm._directInactive = false;
if (isInInactiveTree(vm)) {
return
}
} else if (vm._directInactive) {
return
}
if (vm._inactive || vm._inactive === null) {
vm._inactive = false;
for (var i = 0; i < vm.$children.length; i++) {
activateChildComponent(vm.$children[i]);
}
callHook(vm, 'activated');
}
}
function deactivateChildComponent (vm, direct) {
if (direct) {
vm._directInactive = true;
if (isInInactiveTree(vm)) {
return
}
}
if (!vm._inactive) {
vm._inactive = true;
for (var i = 0; i < vm.$children.length; i++) {
deactivateChildComponent(vm.$children[i]);
}
callHook(vm, 'deactivated');
}
}
function callHook (vm, hook) {
var handlers = vm.$options[hook];
if (handlers) {
for (var i = 0, j = handlers.length; i < j; i++) {
try {
handlers[i].call(vm);
} catch (e) {
handleError(e, vm, (hook + " hook"));
}
}
}
if (vm._hasHookEvent) {
vm.$emit('hook:' + hook);
}
}
/* */
var MAX_UPDATE_COUNT = 100;
var queue = [];
var activatedChildren = [];
var has = {};
var circular = {};
var waiting = false;
var flushing = false;
var index = 0;
/**
* Reset the scheduler's state.
*/
function resetSchedulerState () {
index = queue.length = activatedChildren.length = 0;
has = {};
{
circular = {};
}
waiting = flushing = false;
}
/**
* Flush both queues and run the watchers.
*/
function flushSchedulerQueue () {
flushing = true;
var watcher, id;
// Sort queue before flush.
// This ensures that:
// 1. Components are updated from parent to child. (because parent is always
// created before the child)
// 2. A component's user watchers are run before its render watcher (because
// user watchers are created before the render watcher)
// 3. If a component is destroyed during a parent component's watcher run,
// its watchers can be skipped.
queue.sort(function (a, b) { return a.id - b.id; });
// do not cache length because more watchers might be pushed
// as we run existing watchers
for (index = 0; index < queue.length; index++) {
watcher = queue[index];
id = watcher.id;
has[id] = null;
watcher.run();
// in dev build, check and stop circular updates.
if ("development" !== 'production' && has[id] != null) {
circular[id] = (circular[id] || 0) + 1;
if (circular[id] > MAX_UPDATE_COUNT) {
warn(
'You may have an infinite update loop ' + (
watcher.user
? ("in watcher with expression \"" + (watcher.expression) + "\"")
: "in a component render function."
),
watcher.vm
);
break
}
}
}
// keep copies of post queues before resetting state
var activatedQueue = activatedChildren.slice();
var updatedQueue = queue.slice();
resetSchedulerState();
// call component updated and activated hooks
callActivatedHooks(activatedQueue);
callUpdatedHooks(updatedQueue);
// devtool hook
/* istanbul ignore if */
if (devtools && config.devtools) {
devtools.emit('flush');
}
}
function callUpdatedHooks (queue) {
var i = queue.length;
while (i--) {
var watcher = queue[i];
var vm = watcher.vm;
if (vm._watcher === watcher && vm._isMounted) {
callHook(vm, 'updated');
}
}
}
/**
* Queue a kept-alive component that was activated during patch.
* The queue will be processed after the entire tree has been patched.
*/
function queueActivatedComponent (vm) {
// setting _inactive to false here so that a render function can
// rely on checking whether it's in an inactive tree (e.g. router-view)
vm._inactive = false;
activatedChildren.push(vm);
}
function callActivatedHooks (queue) {
for (var i = 0; i < queue.length; i++) {
queue[i]._inactive = true;
activateChildComponent(queue[i], true /* true */);
}
}
/**
* Push a watcher into the watcher queue.
* Jobs with duplicate IDs will be skipped unless it's
* pushed when the queue is being flushed.
*/
function queueWatcher (watcher) {
var id = watcher.id;
if (has[id] == null) {
has[id] = true;
if (!flushing) {
queue.push(watcher);
} else {
// if already flushing, splice the watcher based on its id
// if already past its id, it will be run next immediately.
var i = queue.length - 1;
while (i > index && queue[i].id > watcher.id) {
i--;
}
queue.splice(i + 1, 0, watcher);
}
// queue the flush
if (!waiting) {
waiting = true;
nextTick(flushSchedulerQueue);
}
}
}
/* */
var uid$2 = 0;
/**
* A watcher parses an expression, collects dependencies,
* and fires callback when the expression value changes.
* This is used for both the $watch() api and directives.
*/
var Watcher = function Watcher (
vm,
expOrFn,
cb,
options
) {
this.vm = vm;
vm._watchers.push(this);
// options
if (options) {
this.deep = !!options.deep;
this.user = !!options.user;
this.lazy = !!options.lazy;
this.sync = !!options.sync;
} else {
this.deep = this.user = this.lazy = this.sync = false;
}
this.cb = cb;
this.id = ++uid$2; // uid for batching
this.active = true;
this.dirty = this.lazy; // for lazy watchers
this.deps = [];
this.newDeps = [];
this.depIds = new _Set();
this.newDepIds = new _Set();
this.expression = expOrFn.toString();
// parse expression for getter
if (typeof expOrFn === 'function') {
this.getter = expOrFn;
} else {
this.getter = parsePath(expOrFn);
if (!this.getter) {
this.getter = function () {};
"development" !== 'production' && warn(
"Failed watching path: \"" + expOrFn + "\" " +
'Watcher only accepts simple dot-delimited paths. ' +
'For full control, use a function instead.',
vm
);
}
}
this.value = this.lazy
? undefined
: this.get();
};
/**
* Evaluate the getter, and re-collect dependencies.
*/
Watcher.prototype.get = function get () {
pushTarget(this);
var value;
var vm = this.vm;
try {
value = this.getter.call(vm, vm);
} catch (e) {
if (this.user) {
handleError(e, vm, ("getter for watcher \"" + (this.expression) + "\""));
} else {
throw e
}
} finally {
// "touch" every property so they are all tracked as
// dependencies for deep watching
if (this.deep) {
traverse(value);
}
popTarget();
this.cleanupDeps();
}
return value
};
/**
* Add a dependency to this directive.
*/
Watcher.prototype.addDep = function addDep (dep) {
var id = dep.id;
if (!this.newDepIds.has(id)) {
this.newDepIds.add(id);
this.newDeps.push(dep);
if (!this.depIds.has(id)) {
dep.addSub(this);
}
}
};
/**
* Clean up for dependency collection.
*/
Watcher.prototype.cleanupDeps = function cleanupDeps () {
var this$1 = this;
var i = this.deps.length;
while (i--) {
var dep = this$1.deps[i];
if (!this$1.newDepIds.has(dep.id)) {
dep.removeSub(this$1);
}
}
var tmp = this.depIds;
this.depIds = this.newDepIds;
this.newDepIds = tmp;
this.newDepIds.clear();
tmp = this.deps;
this.deps = this.newDeps;
this.newDeps = tmp;
this.newDeps.length = 0;
};
/**
* Subscriber interface.
* Will be called when a dependency changes.
*/
Watcher.prototype.update = function update () {
/* istanbul ignore else */
if (this.lazy) {
this.dirty = true;
} else if (this.sync) {
this.run();
} else {
queueWatcher(this);
}
};
/**
* Scheduler job interface.
* Will be called by the scheduler.
*/
Watcher.prototype.run = function run () {
if (this.active) {
var value = this.get();
if (
value !== this.value ||
// Deep watchers and watchers on Object/Arrays should fire even
// when the value is the same, because the value may
// have mutated.
isObject(value) ||
this.deep
) {
// set new value
var oldValue = this.value;
this.value = value;
if (this.user) {
try {
this.cb.call(this.vm, value, oldValue);
} catch (e) {
handleError(e, this.vm, ("callback for watcher \"" + (this.expression) + "\""));
}
} else {
this.cb.call(this.vm, value, oldValue);
}
}
}
};
/**
* Evaluate the value of the watcher.
* This only gets called for lazy watchers.
*/
Watcher.prototype.evaluate = function evaluate () {
this.value = this.get();
this.dirty = false;
};
/**
* Depend on all deps collected by this watcher.
*/
Watcher.prototype.depend = function depend () {
var this$1 = this;
var i = this.deps.length;
while (i--) {
this$1.deps[i].depend();
}
};
/**
* Remove self from all dependencies' subscriber list.
*/
Watcher.prototype.teardown = function teardown () {
var this$1 = this;
if (this.active) {
// remove self from vm's watcher list
// this is a somewhat expensive operation so we skip it
// if the vm is being destroyed.
if (!this.vm._isBeingDestroyed) {
remove(this.vm._watchers, this);
}
var i = this.deps.length;
while (i--) {
this$1.deps[i].removeSub(this$1);
}
this.active = false;
}
};
/**
* Recursively traverse an object to evoke all converted
* getters, so that every nested property inside the object
* is collected as a "deep" dependency.
*/
var seenObjects = new _Set();
function traverse (val) {
seenObjects.clear();
_traverse(val, seenObjects);
}
function _traverse (val, seen) {
var i, keys;
var isA = Array.isArray(val);
if ((!isA && !isObject(val)) || !Object.isExtensible(val)) {
return
}
if (val.__ob__) {
var depId = val.__ob__.dep.id;
if (seen.has(depId)) {
return
}
seen.add(depId);
}
if (isA) {
i = val.length;
while (i--) { _traverse(val[i], seen); }
} else {
keys = Object.keys(val);
i = keys.length;
while (i--) { _traverse(val[keys[i]], seen); }
}
}
/* */
var sharedPropertyDefinition = {
enumerable: true,
configurable: true,
get: noop,
set: noop
};
function proxy (target, sourceKey, key) {
sharedPropertyDefinition.get = function proxyGetter () {
return this[sourceKey][key]
};
sharedPropertyDefinition.set = function proxySetter (val) {
this[sourceKey][key] = val;
};
Object.defineProperty(target, key, sharedPropertyDefinition);
}
function initState (vm) {
vm._watchers = [];
var opts = vm.$options;
if (opts.props) { initProps(vm, opts.props); }
if (opts.methods) { initMethods(vm, opts.methods); }
if (opts.data) {
initData(vm);
} else {
observe(vm._data = {}, true /* asRootData */);
}
if (opts.computed) { initComputed(vm, opts.computed); }
if (opts.watch && opts.watch !== nativeWatch) {
initWatch(vm, opts.watch);
}
}
function checkOptionType (vm, name) {
var option = vm.$options[name];
if (!isPlainObject(option)) {
warn(
("component option \"" + name + "\" should be an object."),
vm
);
}
}
function initProps (vm, propsOptions) {
var propsData = vm.$options.propsData || {};
var props = vm._props = {};
// cache prop keys so that future props updates can iterate using Array
// instead of dynamic object key enumeration.
var keys = vm.$options._propKeys = [];
var isRoot = !vm.$parent;
// root instance props should be converted
observerState.shouldConvert = isRoot;
var loop = function ( key ) {
keys.push(key);
var value = validateProp(key, propsOptions, propsData, vm);
/* istanbul ignore else */
{
if (isReservedAttribute(key) || config.isReservedAttr(key)) {
warn(
("\"" + key + "\" is a reserved attribute and cannot be used as component prop."),
vm
);
}
defineReactive$$1(props, key, value, function () {
if (vm.$parent && !isUpdatingChildComponent) {
warn(
"Avoid mutating a prop directly since the value will be " +
"overwritten whenever the parent component re-renders. " +
"Instead, use a data or computed property based on the prop's " +
"value. Prop being mutated: \"" + key + "\"",
vm
);
}
});
}
// static props are already proxied on the component's prototype
// during Vue.extend(). We only need to proxy props defined at
// instantiation here.
if (!(key in vm)) {
proxy(vm, "_props", key);
}
};
for (var key in propsOptions) loop( key );
observerState.shouldConvert = true;
}
function initData (vm) {
var data = vm.$options.data;
data = vm._data = typeof data === 'function'
? getData(data, vm)
: data || {};
if (!isPlainObject(data)) {
data = {};
"development" !== 'production' && warn(
'data functions should return an object:\n' +
'https://vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
vm
);
}
// proxy data on instance
var keys = Object.keys(data);
var props = vm.$options.props;
var methods = vm.$options.methods;
var i = keys.length;
while (i--) {
var key = keys[i];
{
if (methods && hasOwn(methods, key)) {
warn(
("Method \"" + key + "\" has already been defined as a data property."),
vm
);
}
}
if (props && hasOwn(props, key)) {
"development" !== 'production' && warn(
"The data property \"" + key + "\" is already declared as a prop. " +
"Use prop default value instead.",
vm
);
} else if (!isReserved(key)) {
proxy(vm, "_data", key);
}
}
// observe data
observe(data, true /* asRootData */);
}
function getData (data, vm) {
try {
return data.call(vm)
} catch (e) {
handleError(e, vm, "data()");
return {}
}
}
var computedWatcherOptions = { lazy: true };
function initComputed (vm, computed) {
"development" !== 'production' && checkOptionType(vm, 'computed');
var watchers = vm._computedWatchers = Object.create(null);
// computed properties are just getters during SSR
var isSSR = isServerRendering();
for (var key in computed) {
var userDef = computed[key];
var getter = typeof userDef === 'function' ? userDef : userDef.get;
if ("development" !== 'production' && getter == null) {
warn(
("Getter is missing for computed property \"" + key + "\"."),
vm
);
}
if (!isSSR) {
// create internal watcher for the computed property.
watchers[key] = new Watcher(
vm,
getter || noop,
noop,
computedWatcherOptions
);
}
// component-defined computed properties are already defined on the
// component prototype. We only need to define computed properties defined
// at instantiation here.
if (!(key in vm)) {
defineComputed(vm, key, userDef);
} else {
if (key in vm.$data) {
warn(("The computed property \"" + key + "\" is already defined in data."), vm);
} else if (vm.$options.props && key in vm.$options.props) {
warn(("The computed property \"" + key + "\" is already defined as a prop."), vm);
}
}
}
}
function defineComputed (
target,
key,
userDef
) {
var shouldCache = !isServerRendering();
if (typeof userDef === 'function') {
sharedPropertyDefinition.get = shouldCache
? createComputedGetter(key)
: userDef;
sharedPropertyDefinition.set = noop;
} else {
sharedPropertyDefinition.get = userDef.get
? shouldCache && userDef.cache !== false
? createComputedGetter(key)
: userDef.get
: noop;
sharedPropertyDefinition.set = userDef.set
? userDef.set
: noop;
}
if ("development" !== 'production' &&
sharedPropertyDefinition.set === noop) {
sharedPropertyDefinition.set = function () {
warn(
("Computed property \"" + key + "\" was assigned to but it has no setter."),
this
);
};
}
Object.defineProperty(target, key, sharedPropertyDefinition);
}
function createComputedGetter (key) {
return function computedGetter () {
var watcher = this._computedWatchers && this._computedWatchers[key];
if (watcher) {
if (watcher.dirty) {
watcher.evaluate();
}
if (Dep.target) {
watcher.depend();
}
return watcher.value
}
}
}
function initMethods (vm, methods) {
"development" !== 'production' && checkOptionType(vm, 'methods');
var props = vm.$options.props;
for (var key in methods) {
{
if (methods[key] == null) {
warn(
"Method \"" + key + "\" has an undefined value in the component definition. " +
"Did you reference the function correctly?",
vm
);
}
if (props && hasOwn(props, key)) {
warn(
("Method \"" + key + "\" has already been defined as a prop."),
vm
);
}
if ((key in vm) && isReserved(key)) {
warn(
"Method \"" + key + "\" conflicts with an existing Vue instance method. " +
"Avoid defining component methods that start with _ or $."
);
}
}
vm[key] = methods[key] == null ? noop : bind(methods[key], vm);
}
}
function initWatch (vm, watch) {
"development" !== 'production' && checkOptionType(vm, 'watch');
for (var key in watch) {
var handler = watch[key];
if (Array.isArray(handler)) {
for (var i = 0; i < handler.length; i++) {
createWatcher(vm, key, handler[i]);
}
} else {
createWatcher(vm, key, handler);
}
}
}
function createWatcher (
vm,
keyOrFn,
handler,
options
) {
if (isPlainObject(handler)) {
options = handler;
handler = handler.handler;
}
if (typeof handler === 'string') {
handler = vm[handler];
}
return vm.$watch(keyOrFn, handler, options)
}
function stateMixin (Vue) {
// flow somehow has problems with directly declared definition object
// when using Object.defineProperty, so we have to procedurally build up
// the object here.
var dataDef = {};
dataDef.get = function () { return this._data };
var propsDef = {};
propsDef.get = function () { return this._props };
{
dataDef.set = function (newData) {
warn(
'Avoid replacing instance root $data. ' +
'Use nested data properties instead.',
this
);
};
propsDef.set = function () {
warn("$props is readonly.", this);
};
}
Object.defineProperty(Vue.prototype, '$data', dataDef);
Object.defineProperty(Vue.prototype, '$props', propsDef);
Vue.prototype.$set = set;
Vue.prototype.$delete = del;
Vue.prototype.$watch = function (
expOrFn,
cb,
options
) {
var vm = this;
if (isPlainObject(cb)) {
return createWatcher(vm, expOrFn, cb, options)
}
options = options || {};
options.user = true;
var watcher = new Watcher(vm, expOrFn, cb, options);
if (options.immediate) {
cb.call(vm, watcher.value);
}
return function unwatchFn () {
watcher.teardown();
}
};
}
/* */
function initProvide (vm) {
var provide = vm.$options.provide;
if (provide) {
vm._provided = typeof provide === 'function'
? provide.call(vm)
: provide;
}
}
function initInjections (vm) {
var result = resolveInject(vm.$options.inject, vm);
if (result) {
observerState.shouldConvert = false;
Object.keys(result).forEach(function (key) {
/* istanbul ignore else */
{
defineReactive$$1(vm, key, result[key], function () {
warn(
"Avoid mutating an injected value directly since the changes will be " +
"overwritten whenever the provided component re-renders. " +
"injection being mutated: \"" + key + "\"",
vm
);
});
}
});
observerState.shouldConvert = true;
}
}
function resolveInject (inject, vm) {
if (inject) {
// inject is :any because flow is not smart enough to figure out cached
var result = Object.create(null);
var keys = hasSymbol
? Reflect.ownKeys(inject).filter(function (key) {
/* istanbul ignore next */
return Object.getOwnPropertyDescriptor(inject, key).enumerable
})
: Object.keys(inject);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
var provideKey = inject[key];
var source = vm;
while (source) {
if (source._provided && provideKey in source._provided) {
result[key] = source._provided[provideKey];
break
}
source = source.$parent;
}
if ("development" !== 'production' && !source) {
warn(("Injection \"" + key + "\" not found"), vm);
}
}
return result
}
}
/* */
function createFunctionalComponent (
Ctor,
propsData,
data,
context,
children
) {
var props = {};
var propOptions = Ctor.options.props;
if (isDef(propOptions)) {
for (var key in propOptions) {
props[key] = validateProp(key, propOptions, propsData || emptyObject);
}
} else {
if (isDef(data.attrs)) { mergeProps(props, data.attrs); }
if (isDef(data.props)) { mergeProps(props, data.props); }
}
// ensure the createElement function in functional components
// gets a unique context - this is necessary for correct named slot check
var _context = Object.create(context);
var h = function (a, b, c, d) { return createElement(_context, a, b, c, d, true); };
var vnode = Ctor.options.render.call(null, h, {
data: data,
props: props,
children: children,
parent: context,
listeners: data.on || emptyObject,
injections: resolveInject(Ctor.options.inject, context),
slots: function () { return resolveSlots(children, context); }
});
if (vnode instanceof VNode) {
vnode.functionalContext = context;
vnode.functionalOptions = Ctor.options;
if (data.slot) {
(vnode.data || (vnode.data = {})).slot = data.slot;
}
}
return vnode
}
function mergeProps (to, from) {
for (var key in from) {
to[camelize(key)] = from[key];
}
}
/* */
// hooks to be invoked on component VNodes during patch
var componentVNodeHooks = {
init: function init (
vnode,
hydrating,
parentElm,
refElm
) {
if (!vnode.componentInstance || vnode.componentInstance._isDestroyed) {
var child = vnode.componentInstance = createComponentInstanceForVnode(
vnode,
activeInstance,
parentElm,
refElm
);
child.$mount(hydrating ? vnode.elm : undefined, hydrating);
} else if (vnode.data.keepAlive) {
// kept-alive components, treat as a patch
var mountedNode = vnode; // work around flow
componentVNodeHooks.prepatch(mountedNode, mountedNode);
}
},
prepatch: function prepatch (oldVnode, vnode) {
var options = vnode.componentOptions;
var child = vnode.componentInstance = oldVnode.componentInstance;
updateChildComponent(
child,
options.propsData, // updated props
options.listeners, // updated listeners
vnode, // new parent vnode
options.children // new children
);
},
insert: function insert (vnode) {
var context = vnode.context;
var componentInstance = vnode.componentInstance;
if (!componentInstance._isMounted) {
componentInstance._isMounted = true;
callHook(componentInstance, 'mounted');
}
if (vnode.data.keepAlive) {
if (context._isMounted) {
// vue-router#1212
// During updates, a kept-alive component's child components may
// change, so directly walking the tree here may call activated hooks
// on incorrect children. Instead we push them into a queue which will
// be processed after the whole patch process ended.
queueActivatedComponent(componentInstance);
} else {
activateChildComponent(componentInstance, true /* direct */);
}
}
},
destroy: function destroy (vnode) {
var componentInstance = vnode.componentInstance;
if (!componentInstance._isDestroyed) {
if (!vnode.data.keepAlive) {
componentInstance.$destroy();
} else {
deactivateChildComponent(componentInstance, true /* direct */);
}
}
}
};
var hooksToMerge = Object.keys(componentVNodeHooks);
function createComponent (
Ctor,
data,
context,
children,
tag
) {
if (isUndef(Ctor)) {
return
}
var baseCtor = context.$options._base;
// plain options object: turn it into a constructor
if (isObject(Ctor)) {
Ctor = baseCtor.extend(Ctor);
}
// if at this stage it's not a constructor or an async component factory,
// reject.
if (typeof Ctor !== 'function') {
{
warn(("Invalid Component definition: " + (String(Ctor))), context);
}
return
}
// async component
var asyncFactory;
if (isUndef(Ctor.cid)) {
asyncFactory = Ctor;
Ctor = resolveAsyncComponent(asyncFactory, baseCtor, context);
if (Ctor === undefined) {
// return a placeholder node for async component, which is rendered
// as a comment node but preserves all the raw information for the node.
// the information will be used for async server-rendering and hydration.
return createAsyncPlaceholder(
asyncFactory,
data,
context,
children,
tag
)
}
}
data = data || {};
// resolve constructor options in case global mixins are applied after
// component constructor creation
resolveConstructorOptions(Ctor);
// transform component v-model data into props & events
if (isDef(data.model)) {
transformModel(Ctor.options, data);
}
// extract props
var propsData = extractPropsFromVNodeData(data, Ctor, tag);
// functional component
if (isTrue(Ctor.options.functional)) {
return createFunctionalComponent(Ctor, propsData, data, context, children)
}
// extract listeners, since these needs to be treated as
// child component listeners instead of DOM listeners
var listeners = data.on;
// replace with listeners with .native modifier
// so it gets processed during parent component patch.
data.on = data.nativeOn;
if (isTrue(Ctor.options.abstract)) {
// abstract components do not keep anything
// other than props & listeners & slot
// work around flow
var slot = data.slot;
data = {};
if (slot) {
data.slot = slot;
}
}
// merge component management hooks onto the placeholder node
mergeHooks(data);
// return a placeholder vnode
var name = Ctor.options.name || tag;
var vnode = new VNode(
("vue-component-" + (Ctor.cid) + (name ? ("-" + name) : '')),
data, undefined, undefined, undefined, context,
{ Ctor: Ctor, propsData: propsData, listeners: listeners, tag: tag, children: children },
asyncFactory
);
return vnode
}
function createComponentInstanceForVnode (
vnode, // we know it's MountedComponentVNode but flow doesn't
parent, // activeInstance in lifecycle state
parentElm,
refElm
) {
var vnodeComponentOptions = vnode.componentOptions;
var options = {
_isComponent: true,
parent: parent,
propsData: vnodeComponentOptions.propsData,
_componentTag: vnodeComponentOptions.tag,
_parentVnode: vnode,
_parentListeners: vnodeComponentOptions.listeners,
_renderChildren: vnodeComponentOptions.children,
_parentElm: parentElm || null,
_refElm: refElm || null
};
// check inline-template render functions
var inlineTemplate = vnode.data.inlineTemplate;
if (isDef(inlineTemplate)) {
options.render = inlineTemplate.render;
options.staticRenderFns = inlineTemplate.staticRenderFns;
}
return new vnodeComponentOptions.Ctor(options)
}
function mergeHooks (data) {
if (!data.hook) {
data.hook = {};
}
for (var i = 0; i < hooksToMerge.length; i++) {
var key = hooksToMerge[i];
var fromParent = data.hook[key];
var ours = componentVNodeHooks[key];
data.hook[key] = fromParent ? mergeHook$1(ours, fromParent) : ours;
}
}
function mergeHook$1 (one, two) {
return function (a, b, c, d) {
one(a, b, c, d);
two(a, b, c, d);
}
}
// transform component v-model info (value and callback) into
// prop and event handler respectively.
function transformModel (options, data) {
var prop = (options.model && options.model.prop) || 'value';
var event = (options.model && options.model.event) || 'input';(data.props || (data.props = {}))[prop] = data.model.value;
var on = data.on || (data.on = {});
if (isDef(on[event])) {
on[event] = [data.model.callback].concat(on[event]);
} else {
on[event] = data.model.callback;
}
}
/* */
var SIMPLE_NORMALIZE = 1;
var ALWAYS_NORMALIZE = 2;
// wrapper function for providing a more flexible interface
// without getting yelled at by flow
function createElement (
context,
tag,
data,
children,
normalizationType,
alwaysNormalize
) {
if (Array.isArray(data) || isPrimitive(data)) {
normalizationType = children;
children = data;
data = undefined;
}
if (isTrue(alwaysNormalize)) {
normalizationType = ALWAYS_NORMALIZE;
}
return _createElement(context, tag, data, children, normalizationType)
}
function _createElement (
context,
tag,
data,
children,
normalizationType
) {
if (isDef(data) && isDef((data).__ob__)) {
"development" !== 'production' && warn(
"Avoid using observed data object as vnode data: " + (JSON.stringify(data)) + "\n" +
'Always create fresh vnode data objects in each render!',
context
);
return createEmptyVNode()
}
// object syntax in v-bind
if (isDef(data) && isDef(data.is)) {
tag = data.is;
}
if (!tag) {
// in case of component :is set to falsy value
return createEmptyVNode()
}
// warn against non-primitive key
if ("development" !== 'production' &&
isDef(data) && isDef(data.key) && !isPrimitive(data.key)
) {
warn(
'Avoid using non-primitive value as key, ' +
'use string/number value instead.',
context
);
}
// support single function children as default scoped slot
if (Array.isArray(children) &&
typeof children[0] === 'function'
) {
data = data || {};
data.scopedSlots = { default: children[0] };
children.length = 0;
}
if (normalizationType === ALWAYS_NORMALIZE) {
children = normalizeChildren(children);
} else if (normalizationType === SIMPLE_NORMALIZE) {
children = simpleNormalizeChildren(children);
}
var vnode, ns;
if (typeof tag === 'string') {
var Ctor;
ns = (context.$vnode && context.$vnode.ns) || config.getTagNamespace(tag);
if (config.isReservedTag(tag)) {
// platform built-in elements
vnode = new VNode(
config.parsePlatformTagName(tag), data, children,
undefined, undefined, context
);
} else if (isDef(Ctor = resolveAsset(context.$options, 'components', tag))) {
// component
vnode = createComponent(Ctor, data, context, children, tag);
} else {
// unknown or unlisted namespaced elements
// check at runtime because it may get assigned a namespace when its
// parent normalizes children
vnode = new VNode(
tag, data, children,
undefined, undefined, context
);
}
} else {
// direct component options / constructor
vnode = createComponent(tag, data, context, children);
}
if (isDef(vnode)) {
if (ns) { applyNS(vnode, ns); }
return vnode
} else {
return createEmptyVNode()
}
}
function applyNS (vnode, ns) {
vnode.ns = ns;
if (vnode.tag === 'foreignObject') {
// use default namespace inside foreignObject
return
}
if (isDef(vnode.children)) {
for (var i = 0, l = vnode.children.length; i < l; i++) {
var child = vnode.children[i];
if (isDef(child.tag) && isUndef(child.ns)) {
applyNS(child, ns);
}
}
}
}
/* */
/**
* Runtime helper for rendering v-for lists.
*/
function renderList (
val,
render
) {
var ret, i, l, keys, key;
if (Array.isArray(val) || typeof val === 'string') {
ret = new Array(val.length);
for (i = 0, l = val.length; i < l; i++) {
ret[i] = render(val[i], i);
}
} else if (typeof val === 'number') {
ret = new Array(val);
for (i = 0; i < val; i++) {
ret[i] = render(i + 1, i);
}
} else if (isObject(val)) {
keys = Object.keys(val);
ret = new Array(keys.length);
for (i = 0, l = keys.length; i < l; i++) {
key = keys[i];
ret[i] = render(val[key], key, i);
}
}
if (isDef(ret)) {
(ret)._isVList = true;
}
return ret
}
/* */
/**
* Runtime helper for rendering
*/
function renderSlot (
name,
fallback,
props,
bindObject
) {
var scopedSlotFn = this.$scopedSlots[name];
if (scopedSlotFn) { // scoped slot
props = props || {};
if (bindObject) {
props = extend(extend({}, bindObject), props);
}
return scopedSlotFn(props) || fallback
} else {
var slotNodes = this.$slots[name];
// warn duplicate slot usage
if (slotNodes && "development" !== 'production') {
slotNodes._rendered && warn(
"Duplicate presence of slot \"" + name + "\" found in the same render tree " +
"- this will likely cause render errors.",
this
);
slotNodes._rendered = true;
}
return slotNodes || fallback
}
}
/* */
/**
* Runtime helper for resolving filters
*/
function resolveFilter (id) {
return resolveAsset(this.$options, 'filters', id, true) || identity
}
/* */
/**
* Runtime helper for checking keyCodes from config.
*/
function checkKeyCodes (
eventKeyCode,
key,
builtInAlias
) {
var keyCodes = config.keyCodes[key] || builtInAlias;
if (Array.isArray(keyCodes)) {
return keyCodes.indexOf(eventKeyCode) === -1
} else {
return keyCodes !== eventKeyCode
}
}
/* */
/**
* Runtime helper for merging v-bind="object" into a VNode's data.
*/
function bindObjectProps (
data,
tag,
value,
asProp,
isSync
) {
if (value) {
if (!isObject(value)) {
"development" !== 'production' && warn(
'v-bind without argument expects an Object or Array value',
this
);
} else {
if (Array.isArray(value)) {
value = toObject(value);
}
var hash;
var loop = function ( key ) {
if (
key === 'class' ||
key === 'style' ||
isReservedAttribute(key)
) {
hash = data;
} else {
var type = data.attrs && data.attrs.type;
hash = asProp || config.mustUseProp(tag, type, key)
? data.domProps || (data.domProps = {})
: data.attrs || (data.attrs = {});
}
if (!(key in hash)) {
hash[key] = value[key];
if (isSync) {
var on = data.on || (data.on = {});
on[("update:" + key)] = function ($event) {
value[key] = $event;
};
}
}
};
for (var key in value) loop( key );
}
}
return data
}
/* */
/**
* Runtime helper for rendering static trees.
*/
function renderStatic (
index,
isInFor
) {
var tree = this._staticTrees[index];
// if has already-rendered static tree and not inside v-for,
// we can reuse the same tree by doing a shallow clone.
if (tree && !isInFor) {
return Array.isArray(tree)
? cloneVNodes(tree)
: cloneVNode(tree)
}
// otherwise, render a fresh tree.
tree = this._staticTrees[index] =
this.$options.staticRenderFns[index].call(this._renderProxy);
markStatic(tree, ("__static__" + index), false);
return tree
}
/**
* Runtime helper for v-once.
* Effectively it means marking the node as static with a unique key.
*/
function markOnce (
tree,
index,
key
) {
markStatic(tree, ("__once__" + index + (key ? ("_" + key) : "")), true);
return tree
}
function markStatic (
tree,
key,
isOnce
) {
if (Array.isArray(tree)) {
for (var i = 0; i < tree.length; i++) {
if (tree[i] && typeof tree[i] !== 'string') {
markStaticNode(tree[i], (key + "_" + i), isOnce);
}
}
} else {
markStaticNode(tree, key, isOnce);
}
}
function markStaticNode (node, key, isOnce) {
node.isStatic = true;
node.key = key;
node.isOnce = isOnce;
}
/* */
function bindObjectListeners (data, value) {
if (value) {
if (!isPlainObject(value)) {
"development" !== 'production' && warn(
'v-on without argument expects an Object value',
this
);
} else {
var on = data.on = data.on ? extend({}, data.on) : {};
for (var key in value) {
var existing = on[key];
var ours = value[key];
on[key] = existing ? [].concat(ours, existing) : ours;
}
}
}
return data
}
/* */
function initRender (vm) {
vm._vnode = null; // the root of the child tree
vm._staticTrees = null;
var parentVnode = vm.$vnode = vm.$options._parentVnode; // the placeholder node in parent tree
var renderContext = parentVnode && parentVnode.context;
vm.$slots = resolveSlots(vm.$options._renderChildren, renderContext);
vm.$scopedSlots = emptyObject;
// bind the createElement fn to this instance
// so that we get proper render context inside it.
// args order: tag, data, children, normalizationType, alwaysNormalize
// internal version is used by render functions compiled from templates
vm._c = function (a, b, c, d) { return createElement(vm, a, b, c, d, false); };
// normalization is always applied for the public version, used in
// user-written render functions.
vm.$createElement = function (a, b, c, d) { return createElement(vm, a, b, c, d, true); };
// $attrs & $listeners are exposed for easier HOC creation.
// they need to be reactive so that HOCs using them are always updated
var parentData = parentVnode && parentVnode.data;
/* istanbul ignore else */
{
defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {
!isUpdatingChildComponent && warn("$attrs is readonly.", vm);
}, true);
defineReactive$$1(vm, '$listeners', vm.$options._parentListeners || emptyObject, function () {
!isUpdatingChildComponent && warn("$listeners is readonly.", vm);
}, true);
}
}
function renderMixin (Vue) {
Vue.prototype.$nextTick = function (fn) {
return nextTick(fn, this)
};
Vue.prototype._render = function () {
var vm = this;
var ref = vm.$options;
var render = ref.render;
var staticRenderFns = ref.staticRenderFns;
var _parentVnode = ref._parentVnode;
if (vm._isMounted) {
// if the parent didn't update, the slot nodes will be the ones from
// last render. They need to be cloned to ensure "freshness" for this render.
for (var key in vm.$slots) {
var slot = vm.$slots[key];
if (slot._rendered) {
vm.$slots[key] = cloneVNodes(slot, true /* deep */);
}
}
}
vm.$scopedSlots = (_parentVnode && _parentVnode.data.scopedSlots) || emptyObject;
if (staticRenderFns && !vm._staticTrees) {
vm._staticTrees = [];
}
// set parent vnode. this allows render functions to have access
// to the data on the placeholder node.
vm.$vnode = _parentVnode;
// render self
var vnode;
try {
vnode = render.call(vm._renderProxy, vm.$createElement);
} catch (e) {
handleError(e, vm, "render function");
// return error render result,
// or previous vnode to prevent render error causing blank component
/* istanbul ignore else */
{
vnode = vm.$options.renderError
? vm.$options.renderError.call(vm._renderProxy, vm.$createElement, e)
: vm._vnode;
}
}
// return empty vnode in case the render function errored out
if (!(vnode instanceof VNode)) {
if ("development" !== 'production' && Array.isArray(vnode)) {
warn(
'Multiple root nodes returned from render function. Render function ' +
'should return a single root node.',
vm
);
}
vnode = createEmptyVNode();
}
// set parent
vnode.parent = _parentVnode;
return vnode
};
// internal render helpers.
// these are exposed on the instance prototype to reduce generated render
// code size.
Vue.prototype._o = markOnce;
Vue.prototype._n = toNumber;
Vue.prototype._s = toString;
Vue.prototype._l = renderList;
Vue.prototype._t = renderSlot;
Vue.prototype._q = looseEqual;
Vue.prototype._i = looseIndexOf;
Vue.prototype._m = renderStatic;
Vue.prototype._f = resolveFilter;
Vue.prototype._k = checkKeyCodes;
Vue.prototype._b = bindObjectProps;
Vue.prototype._v = createTextVNode;
Vue.prototype._e = createEmptyVNode;
Vue.prototype._u = resolveScopedSlots;
Vue.prototype._g = bindObjectListeners;
}
/* */
var uid$1 = 0;
function initMixin (Vue) {
Vue.prototype._init = function (options) {
var vm = this;
// a uid
vm._uid = uid$1++;
var startTag, endTag;
/* istanbul ignore if */
if ("development" !== 'production' && config.performance && mark) {
startTag = "vue-perf-init:" + (vm._uid);
endTag = "vue-perf-end:" + (vm._uid);
mark(startTag);
}
// a flag to avoid this being observed
vm._isVue = true;
// merge options
if (options && options._isComponent) {
// optimize internal component instantiation
// since dynamic options merging is pretty slow, and none of the
// internal component options needs special treatment.
initInternalComponent(vm, options);
} else {
vm.$options = mergeOptions(
resolveConstructorOptions(vm.constructor),
options || {},
vm
);
}
/* istanbul ignore else */
{
initProxy(vm);
}
// expose real self
vm._self = vm;
initLifecycle(vm);
initEvents(vm);
initRender(vm);
callHook(vm, 'beforeCreate');
initInjections(vm); // resolve injections before data/props
initState(vm);
initProvide(vm); // resolve provide after data/props
callHook(vm, 'created');
/* istanbul ignore if */
if ("development" !== 'production' && config.performance && mark) {
vm._name = formatComponentName(vm, false);
mark(endTag);
measure(((vm._name) + " init"), startTag, endTag);
}
if (vm.$options.el) {
vm.$mount(vm.$options.el);
}
};
}
function initInternalComponent (vm, options) {
var opts = vm.$options = Object.create(vm.constructor.options);
// doing this because it's faster than dynamic enumeration.
opts.parent = options.parent;
opts.propsData = options.propsData;
opts._parentVnode = options._parentVnode;
opts._parentListeners = options._parentListeners;
opts._renderChildren = options._renderChildren;
opts._componentTag = options._componentTag;
opts._parentElm = options._parentElm;
opts._refElm = options._refElm;
if (options.render) {
opts.render = options.render;
opts.staticRenderFns = options.staticRenderFns;
}
}
function resolveConstructorOptions (Ctor) {
var options = Ctor.options;
if (Ctor.super) {
var superOptions = resolveConstructorOptions(Ctor.super);
var cachedSuperOptions = Ctor.superOptions;
if (superOptions !== cachedSuperOptions) {
// super option changed,
// need to resolve new options.
Ctor.superOptions = superOptions;
// check if there are any late-modified/attached options (#4976)
var modifiedOptions = resolveModifiedOptions(Ctor);
// update base extend options
if (modifiedOptions) {
extend(Ctor.extendOptions, modifiedOptions);
}
options = Ctor.options = mergeOptions(superOptions, Ctor.extendOptions);
if (options.name) {
options.components[options.name] = Ctor;
}
}
}
return options
}
function resolveModifiedOptions (Ctor) {
var modified;
var latest = Ctor.options;
var extended = Ctor.extendOptions;
var sealed = Ctor.sealedOptions;
for (var key in latest) {
if (latest[key] !== sealed[key]) {
if (!modified) { modified = {}; }
modified[key] = dedupe(latest[key], extended[key], sealed[key]);
}
}
return modified
}
function dedupe (latest, extended, sealed) {
// compare latest and sealed to ensure lifecycle hooks won't be duplicated
// between merges
if (Array.isArray(latest)) {
var res = [];
sealed = Array.isArray(sealed) ? sealed : [sealed];
extended = Array.isArray(extended) ? extended : [extended];
for (var i = 0; i < latest.length; i++) {
// push original options and not sealed options to exclude duplicated options
if (extended.indexOf(latest[i]) >= 0 || sealed.indexOf(latest[i]) < 0) {
res.push(latest[i]);
}
}
return res
} else {
return latest
}
}
function Vue$3 (options) {
if ("development" !== 'production' &&
!(this instanceof Vue$3)
) {
warn('Vue is a constructor and should be called with the `new` keyword');
}
this._init(options);
}
initMixin(Vue$3);
stateMixin(Vue$3);
eventsMixin(Vue$3);
lifecycleMixin(Vue$3);
renderMixin(Vue$3);
/* */
function initUse (Vue) {
Vue.use = function (plugin) {
var installedPlugins = (this._installedPlugins || (this._installedPlugins = []));
if (installedPlugins.indexOf(plugin) > -1) {
return this
}
// additional parameters
var args = toArray(arguments, 1);
args.unshift(this);
if (typeof plugin.install === 'function') {
plugin.install.apply(plugin, args);
} else if (typeof plugin === 'function') {
plugin.apply(null, args);
}
installedPlugins.push(plugin);
return this
};
}
/* */
function initMixin$1 (Vue) {
Vue.mixin = function (mixin) {
this.options = mergeOptions(this.options, mixin);
return this
};
}
/* */
function initExtend (Vue) {
/**
* Each instance constructor, including Vue, has a unique
* cid. This enables us to create wrapped "child
* constructors" for prototypal inheritance and cache them.
*/
Vue.cid = 0;
var cid = 1;
/**
* Class inheritance
*/
Vue.extend = function (extendOptions) {
extendOptions = extendOptions || {};
var Super = this;
var SuperId = Super.cid;
var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
if (cachedCtors[SuperId]) {
return cachedCtors[SuperId]
}
var name = extendOptions.name || Super.options.name;
{
if (!/^[a-zA-Z][\w-]*$/.test(name)) {
warn(
'Invalid component name: "' + name + '". Component names ' +
'can only contain alphanumeric characters and the hyphen, ' +
'and must start with a letter.'
);
}
}
var Sub = function VueComponent (options) {
this._init(options);
};
Sub.prototype = Object.create(Super.prototype);
Sub.prototype.constructor = Sub;
Sub.cid = cid++;
Sub.options = mergeOptions(
Super.options,
extendOptions
);
Sub['super'] = Super;
// For props and computed properties, we define the proxy getters on
// the Vue instances at extension time, on the extended prototype. This
// avoids Object.defineProperty calls for each instance created.
if (Sub.options.props) {
initProps$1(Sub);
}
if (Sub.options.computed) {
initComputed$1(Sub);
}
// allow further extension/mixin/plugin usage
Sub.extend = Super.extend;
Sub.mixin = Super.mixin;
Sub.use = Super.use;
// create asset registers, so extended classes
// can have their private assets too.
ASSET_TYPES.forEach(function (type) {
Sub[type] = Super[type];
});
// enable recursive self-lookup
if (name) {
Sub.options.components[name] = Sub;
}
// keep a reference to the super options at extension time.
// later at instantiation we can check if Super's options have
// been updated.
Sub.superOptions = Super.options;
Sub.extendOptions = extendOptions;
Sub.sealedOptions = extend({}, Sub.options);
// cache constructor
cachedCtors[SuperId] = Sub;
return Sub
};
}
function initProps$1 (Comp) {
var props = Comp.options.props;
for (var key in props) {
proxy(Comp.prototype, "_props", key);
}
}
function initComputed$1 (Comp) {
var computed = Comp.options.computed;
for (var key in computed) {
defineComputed(Comp.prototype, key, computed[key]);
}
}
/* */
function initAssetRegisters (Vue) {
/**
* Create asset registration methods.
*/
ASSET_TYPES.forEach(function (type) {
Vue[type] = function (
id,
definition
) {
if (!definition) {
return this.options[type + 's'][id]
} else {
/* istanbul ignore if */
{
if (type === 'component' && config.isReservedTag(id)) {
warn(
'Do not use built-in or reserved HTML elements as component ' +
'id: ' + id
);
}
}
if (type === 'component' && isPlainObject(definition)) {
definition.name = definition.name || id;
definition = this.options._base.extend(definition);
}
if (type === 'directive' && typeof definition === 'function') {
definition = { bind: definition, update: definition };
}
this.options[type + 's'][id] = definition;
return definition
}
};
});
}
/* */
var patternTypes = [String, RegExp, Array];
function getComponentName (opts) {
return opts && (opts.Ctor.options.name || opts.tag)
}
function matches (pattern, name) {
if (Array.isArray(pattern)) {
return pattern.indexOf(name) > -1
} else if (typeof pattern === 'string') {
return pattern.split(',').indexOf(name) > -1
} else if (isRegExp(pattern)) {
return pattern.test(name)
}
/* istanbul ignore next */
return false
}
function pruneCache (cache, current, filter) {
for (var key in cache) {
var cachedNode = cache[key];
if (cachedNode) {
var name = getComponentName(cachedNode.componentOptions);
if (name && !filter(name)) {
if (cachedNode !== current) {
pruneCacheEntry(cachedNode);
}
cache[key] = null;
}
}
}
}
function pruneCacheEntry (vnode) {
if (vnode) {
vnode.componentInstance.$destroy();
}
}
var KeepAlive = {
name: 'keep-alive',
abstract: true,
props: {
include: patternTypes,
exclude: patternTypes
},
created: function created () {
this.cache = Object.create(null);
},
destroyed: function destroyed () {
var this$1 = this;
for (var key in this$1.cache) {
pruneCacheEntry(this$1.cache[key]);
}
},
watch: {
include: function include (val) {
pruneCache(this.cache, this._vnode, function (name) { return matches(val, name); });
},
exclude: function exclude (val) {
pruneCache(this.cache, this._vnode, function (name) { return !matches(val, name); });
}
},
render: function render () {
var vnode = getFirstComponentChild(this.$slots.default);
var componentOptions = vnode && vnode.componentOptions;
if (componentOptions) {
// check pattern
var name = getComponentName(componentOptions);
if (name && (
(this.include && !matches(this.include, name)) ||
(this.exclude && matches(this.exclude, name))
)) {
return vnode
}
var key = vnode.key == null
// same constructor may get registered as different local components
// so cid alone is not enough (#3269)
? componentOptions.Ctor.cid + (componentOptions.tag ? ("::" + (componentOptions.tag)) : '')
: vnode.key;
if (this.cache[key]) {
vnode.componentInstance = this.cache[key].componentInstance;
} else {
this.cache[key] = vnode;
}
vnode.data.keepAlive = true;
}
return vnode
}
};
var builtInComponents = {
KeepAlive: KeepAlive
};
/* */
function initGlobalAPI (Vue) {
// config
var configDef = {};
configDef.get = function () { return config; };
{
configDef.set = function () {
warn(
'Do not replace the Vue.config object, set individual fields instead.'
);
};
}
Object.defineProperty(Vue, 'config', configDef);
// exposed util methods.
// NOTE: these are not considered part of the public API - avoid relying on
// them unless you are aware of the risk.
Vue.util = {
warn: warn,
extend: extend,
mergeOptions: mergeOptions,
defineReactive: defineReactive$$1
};
Vue.set = set;
Vue.delete = del;
Vue.nextTick = nextTick;
Vue.options = Object.create(null);
ASSET_TYPES.forEach(function (type) {
Vue.options[type + 's'] = Object.create(null);
});
// this is used to identify the "base" constructor to extend all plain-object
// components with in Weex's multi-instance scenarios.
Vue.options._base = Vue;
extend(Vue.options.components, builtInComponents);
initUse(Vue);
initMixin$1(Vue);
initExtend(Vue);
initAssetRegisters(Vue);
}
initGlobalAPI(Vue$3);
Object.defineProperty(Vue$3.prototype, '$isServer', {
get: isServerRendering
});
Object.defineProperty(Vue$3.prototype, '$ssrContext', {
get: function get () {
/* istanbul ignore next */
return this.$vnode && this.$vnode.ssrContext
}
});
Vue$3.version = '2.4.4';
/* */
// these are reserved for web because they are directly compiled away
// during template compilation
var isReservedAttr = makeMap('style,class');
// attributes that should be using props for binding
var acceptValue = makeMap('input,textarea,option,select,progress');
var mustUseProp = function (tag, type, attr) {
return (
(attr === 'value' && acceptValue(tag)) && type !== 'button' ||
(attr === 'selected' && tag === 'option') ||
(attr === 'checked' && tag === 'input') ||
(attr === 'muted' && tag === 'video')
)
};
var isEnumeratedAttr = makeMap('contenteditable,draggable,spellcheck');
var isBooleanAttr = makeMap(
'allowfullscreen,async,autofocus,autoplay,checked,compact,controls,declare,' +
'default,defaultchecked,defaultmuted,defaultselected,defer,disabled,' +
'enabled,formnovalidate,hidden,indeterminate,inert,ismap,itemscope,loop,multiple,' +
'muted,nohref,noresize,noshade,novalidate,nowrap,open,pauseonexit,readonly,' +
'required,reversed,scoped,seamless,selected,sortable,translate,' +
'truespeed,typemustmatch,visible'
);
var xlinkNS = 'http://www.w3.org/1999/xlink';
var isXlink = function (name) {
return name.charAt(5) === ':' && name.slice(0, 5) === 'xlink'
};
var getXlinkProp = function (name) {
return isXlink(name) ? name.slice(6, name.length) : ''
};
var isFalsyAttrValue = function (val) {
return val == null || val === false
};
/* */
function genClassForVnode (vnode) {
var data = vnode.data;
var parentNode = vnode;
var childNode = vnode;
while (isDef(childNode.componentInstance)) {
childNode = childNode.componentInstance._vnode;
if (childNode.data) {
data = mergeClassData(childNode.data, data);
}
}
while (isDef(parentNode = parentNode.parent)) {
if (parentNode.data) {
data = mergeClassData(data, parentNode.data);
}
}
return renderClass(data.staticClass, data.class)
}
function mergeClassData (child, parent) {
return {
staticClass: concat(child.staticClass, parent.staticClass),
class: isDef(child.class)
? [child.class, parent.class]
: parent.class
}
}
function renderClass (
staticClass,
dynamicClass
) {
if (isDef(staticClass) || isDef(dynamicClass)) {
return concat(staticClass, stringifyClass(dynamicClass))
}
/* istanbul ignore next */
return ''
}
function concat (a, b) {
return a ? b ? (a + ' ' + b) : a : (b || '')
}
function stringifyClass (value) {
if (Array.isArray(value)) {
return stringifyArray(value)
}
if (isObject(value)) {
return stringifyObject(value)
}
if (typeof value === 'string') {
return value
}
/* istanbul ignore next */
return ''
}
function stringifyArray (value) {
var res = '';
var stringified;
for (var i = 0, l = value.length; i < l; i++) {
if (isDef(stringified = stringifyClass(value[i])) && stringified !== '') {
if (res) { res += ' '; }
res += stringified;
}
}
return res
}
function stringifyObject (value) {
var res = '';
for (var key in value) {
if (value[key]) {
if (res) { res += ' '; }
res += key;
}
}
return res
}
/* */
var namespaceMap = {
svg: 'http://www.w3.org/2000/svg',
math: 'http://www.w3.org/1998/Math/MathML'
};
var isHTMLTag = makeMap(
'html,body,base,head,link,meta,style,title,' +
'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
's,samp,small,span,strong,sub,sup,time,u,var,wbr,area,audio,map,track,video,' +
'embed,object,param,source,canvas,script,noscript,del,ins,' +
'caption,col,colgroup,table,thead,tbody,td,th,tr,' +
'button,datalist,fieldset,form,input,label,legend,meter,optgroup,option,' +
'output,progress,select,textarea,' +
'details,dialog,menu,menuitem,summary,' +
'content,element,shadow,template,blockquote,iframe,tfoot'
);
// this map is intentionally selective, only covering SVG elements that may
// contain child elements.
var isSVG = makeMap(
'svg,animate,circle,clippath,cursor,defs,desc,ellipse,filter,font-face,' +
'foreignObject,g,glyph,image,line,marker,mask,missing-glyph,path,pattern,' +
'polygon,polyline,rect,switch,symbol,text,textpath,tspan,use,view',
true
);
var isPreTag = function (tag) { return tag === 'pre'; };
var isReservedTag = function (tag) {
return isHTMLTag(tag) || isSVG(tag)
};
function getTagNamespace (tag) {
if (isSVG(tag)) {
return 'svg'
}
// basic support for MathML
// note it doesn't support other MathML elements being component roots
if (tag === 'math') {
return 'math'
}
}
var unknownElementCache = Object.create(null);
function isUnknownElement (tag) {
/* istanbul ignore if */
if (!inBrowser) {
return true
}
if (isReservedTag(tag)) {
return false
}
tag = tag.toLowerCase();
/* istanbul ignore if */
if (unknownElementCache[tag] != null) {
return unknownElementCache[tag]
}
var el = document.createElement(tag);
if (tag.indexOf('-') > -1) {
// http://stackoverflow.com/a/28210364/1070244
return (unknownElementCache[tag] = (
el.constructor === window.HTMLUnknownElement ||
el.constructor === window.HTMLElement
))
} else {
return (unknownElementCache[tag] = /HTMLUnknownElement/.test(el.toString()))
}
}
var isTextInputType = makeMap('text,number,password,search,email,tel,url');
/* */
/**
* Query an element selector if it's not an element already.
*/
function query (el) {
if (typeof el === 'string') {
var selected = document.querySelector(el);
if (!selected) {
"development" !== 'production' && warn(
'Cannot find element: ' + el
);
return document.createElement('div')
}
return selected
} else {
return el
}
}
/* */
function createElement$1 (tagName, vnode) {
var elm = document.createElement(tagName);
if (tagName !== 'select') {
return elm
}
// false or null will remove the attribute but undefined will not
if (vnode.data && vnode.data.attrs && vnode.data.attrs.multiple !== undefined) {
elm.setAttribute('multiple', 'multiple');
}
return elm
}
function createElementNS (namespace, tagName) {
return document.createElementNS(namespaceMap[namespace], tagName)
}
function createTextNode (text) {
return document.createTextNode(text)
}
function createComment (text) {
return document.createComment(text)
}
function insertBefore (parentNode, newNode, referenceNode) {
parentNode.insertBefore(newNode, referenceNode);
}
function removeChild (node, child) {
node.removeChild(child);
}
function appendChild (node, child) {
node.appendChild(child);
}
function parentNode (node) {
return node.parentNode
}
function nextSibling (node) {
return node.nextSibling
}
function tagName (node) {
return node.tagName
}
function setTextContent (node, text) {
node.textContent = text;
}
function setAttribute (node, key, val) {
node.setAttribute(key, val);
}
var nodeOps = Object.freeze({
createElement: createElement$1,
createElementNS: createElementNS,
createTextNode: createTextNode,
createComment: createComment,
insertBefore: insertBefore,
removeChild: removeChild,
appendChild: appendChild,
parentNode: parentNode,
nextSibling: nextSibling,
tagName: tagName,
setTextContent: setTextContent,
setAttribute: setAttribute
});
/* */
var ref = {
create: function create (_, vnode) {
registerRef(vnode);
},
update: function update (oldVnode, vnode) {
if (oldVnode.data.ref !== vnode.data.ref) {
registerRef(oldVnode, true);
registerRef(vnode);
}
},
destroy: function destroy (vnode) {
registerRef(vnode, true);
}
};
function registerRef (vnode, isRemoval) {
var key = vnode.data.ref;
if (!key) { return }
var vm = vnode.context;
var ref = vnode.componentInstance || vnode.elm;
var refs = vm.$refs;
if (isRemoval) {
if (Array.isArray(refs[key])) {
remove(refs[key], ref);
} else if (refs[key] === ref) {
refs[key] = undefined;
}
} else {
if (vnode.data.refInFor) {
if (!Array.isArray(refs[key])) {
refs[key] = [ref];
} else if (refs[key].indexOf(ref) < 0) {
// $flow-disable-line
refs[key].push(ref);
}
} else {
refs[key] = ref;
}
}
}
/**
* Virtual DOM patching algorithm based on Snabbdom by
* Simon Friis Vindum (@paldepind)
* Licensed under the MIT License
* https://github.com/paldepind/snabbdom/blob/master/LICENSE
*
* modified by Evan You (@yyx990803)
*
* Not type-checking this because this file is perf-critical and the cost
* of making flow understand it is not worth it.
*/
var emptyNode = new VNode('', {}, []);
var hooks = ['create', 'activate', 'update', 'remove', 'destroy'];
function sameVnode (a, b) {
return (
a.key === b.key && (
(
a.tag === b.tag &&
a.isComment === b.isComment &&
isDef(a.data) === isDef(b.data) &&
sameInputType(a, b)
) || (
isTrue(a.isAsyncPlaceholder) &&
a.asyncFactory === b.asyncFactory &&
isUndef(b.asyncFactory.error)
)
)
)
}
function sameInputType (a, b) {
if (a.tag !== 'input') { return true }
var i;
var typeA = isDef(i = a.data) && isDef(i = i.attrs) && i.type;
var typeB = isDef(i = b.data) && isDef(i = i.attrs) && i.type;
return typeA === typeB || isTextInputType(typeA) && isTextInputType(typeB)
}
function createKeyToOldIdx (children, beginIdx, endIdx) {
var i, key;
var map = {};
for (i = beginIdx; i <= endIdx; ++i) {
key = children[i].key;
if (isDef(key)) { map[key] = i; }
}
return map
}
function createPatchFunction (backend) {
var i, j;
var cbs = {};
var modules = backend.modules;
var nodeOps = backend.nodeOps;
for (i = 0; i < hooks.length; ++i) {
cbs[hooks[i]] = [];
for (j = 0; j < modules.length; ++j) {
if (isDef(modules[j][hooks[i]])) {
cbs[hooks[i]].push(modules[j][hooks[i]]);
}
}
}
function emptyNodeAt (elm) {
return new VNode(nodeOps.tagName(elm).toLowerCase(), {}, [], undefined, elm)
}
function createRmCb (childElm, listeners) {
function remove$$1 () {
if (--remove$$1.listeners === 0) {
removeNode(childElm);
}
}
remove$$1.listeners = listeners;
return remove$$1
}
function removeNode (el) {
var parent = nodeOps.parentNode(el);
// element may have already been removed due to v-html / v-text
if (isDef(parent)) {
nodeOps.removeChild(parent, el);
}
}
var inPre = 0;
function createElm (vnode, insertedVnodeQueue, parentElm, refElm, nested) {
vnode.isRootInsert = !nested; // for transition enter check
if (createComponent(vnode, insertedVnodeQueue, parentElm, refElm)) {
return
}
var data = vnode.data;
var children = vnode.children;
var tag = vnode.tag;
if (isDef(tag)) {
{
if (data && data.pre) {
inPre++;
}
if (
!inPre &&
!vnode.ns &&
!(config.ignoredElements.length && config.ignoredElements.indexOf(tag) > -1) &&
config.isUnknownElement(tag)
) {
warn(
'Unknown custom element: <' + tag + '> - did you ' +
'register the component correctly? For recursive components, ' +
'make sure to provide the "name" option.',
vnode.context
);
}
}
vnode.elm = vnode.ns
? nodeOps.createElementNS(vnode.ns, tag)
: nodeOps.createElement(tag, vnode);
setScope(vnode);
/* istanbul ignore if */
{
createChildren(vnode, children, insertedVnodeQueue);
if (isDef(data)) {
invokeCreateHooks(vnode, insertedVnodeQueue);
}
insert(parentElm, vnode.elm, refElm);
}
if ("development" !== 'production' && data && data.pre) {
inPre--;
}
} else if (isTrue(vnode.isComment)) {
vnode.elm = nodeOps.createComment(vnode.text);
insert(parentElm, vnode.elm, refElm);
} else {
vnode.elm = nodeOps.createTextNode(vnode.text);
insert(parentElm, vnode.elm, refElm);
}
}
function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
var i = vnode.data;
if (isDef(i)) {
var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
if (isDef(i = i.hook) && isDef(i = i.init)) {
i(vnode, false /* hydrating */, parentElm, refElm);
}
// after calling the init hook, if the vnode is a child component
// it should've created a child instance and mounted it. the child
// component also has set the placeholder vnode's elm.
// in that case we can just return the element and be done.
if (isDef(vnode.componentInstance)) {
initComponent(vnode, insertedVnodeQueue);
if (isTrue(isReactivated)) {
reactivateComponent(vnode, insertedVnodeQueue, parentElm, refElm);
}
return true
}
}
}
function initComponent (vnode, insertedVnodeQueue) {
if (isDef(vnode.data.pendingInsert)) {
insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
vnode.data.pendingInsert = null;
}
vnode.elm = vnode.componentInstance.$el;
if (isPatchable(vnode)) {
invokeCreateHooks(vnode, insertedVnodeQueue);
setScope(vnode);
} else {
// empty component root.
// skip all element-related modules except for ref (#3455)
registerRef(vnode);
// make sure to invoke the insert hook
insertedVnodeQueue.push(vnode);
}
}
function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
var i;
// hack for #4339: a reactivated component with inner transition
// does not trigger because the inner node's created hooks are not called
// again. It's not ideal to involve module-specific logic in here but
// there doesn't seem to be a better way to do it.
var innerNode = vnode;
while (innerNode.componentInstance) {
innerNode = innerNode.componentInstance._vnode;
if (isDef(i = innerNode.data) && isDef(i = i.transition)) {
for (i = 0; i < cbs.activate.length; ++i) {
cbs.activate[i](emptyNode, innerNode);
}
insertedVnodeQueue.push(innerNode);
break
}
}
// unlike a newly created component,
// a reactivated keep-alive component doesn't insert itself
insert(parentElm, vnode.elm, refElm);
}
function insert (parent, elm, ref$$1) {
if (isDef(parent)) {
if (isDef(ref$$1)) {
if (ref$$1.parentNode === parent) {
nodeOps.insertBefore(parent, elm, ref$$1);
}
} else {
nodeOps.appendChild(parent, elm);
}
}
}
function createChildren (vnode, children, insertedVnodeQueue) {
if (Array.isArray(children)) {
for (var i = 0; i < children.length; ++i) {
createElm(children[i], insertedVnodeQueue, vnode.elm, null, true);
}
} else if (isPrimitive(vnode.text)) {
nodeOps.appendChild(vnode.elm, nodeOps.createTextNode(vnode.text));
}
}
function isPatchable (vnode) {
while (vnode.componentInstance) {
vnode = vnode.componentInstance._vnode;
}
return isDef(vnode.tag)
}
function invokeCreateHooks (vnode, insertedVnodeQueue) {
for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
cbs.create[i$1](emptyNode, vnode);
}
i = vnode.data.hook; // Reuse variable
if (isDef(i)) {
if (isDef(i.create)) { i.create(emptyNode, vnode); }
if (isDef(i.insert)) { insertedVnodeQueue.push(vnode); }
}
}
// set scope id attribute for scoped CSS.
// this is implemented as a special case to avoid the overhead
// of going through the normal attribute patching process.
function setScope (vnode) {
var i;
var ancestor = vnode;
while (ancestor) {
if (isDef(i = ancestor.context) && isDef(i = i.$options._scopeId)) {
nodeOps.setAttribute(vnode.elm, i, '');
}
ancestor = ancestor.parent;
}
// for slot content they should also get the scopeId from the host instance.
if (isDef(i = activeInstance) &&
i !== vnode.context &&
isDef(i = i.$options._scopeId)
) {
nodeOps.setAttribute(vnode.elm, i, '');
}
}
function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
for (; startIdx <= endIdx; ++startIdx) {
createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm);
}
}
function invokeDestroyHook (vnode) {
var i, j;
var data = vnode.data;
if (isDef(data)) {
if (isDef(i = data.hook) && isDef(i = i.destroy)) { i(vnode); }
for (i = 0; i < cbs.destroy.length; ++i) { cbs.destroy[i](vnode); }
}
if (isDef(i = vnode.children)) {
for (j = 0; j < vnode.children.length; ++j) {
invokeDestroyHook(vnode.children[j]);
}
}
}
function removeVnodes (parentElm, vnodes, startIdx, endIdx) {
for (; startIdx <= endIdx; ++startIdx) {
var ch = vnodes[startIdx];
if (isDef(ch)) {
if (isDef(ch.tag)) {
removeAndInvokeRemoveHook(ch);
invokeDestroyHook(ch);
} else { // Text node
removeNode(ch.elm);
}
}
}
}
function removeAndInvokeRemoveHook (vnode, rm) {
if (isDef(rm) || isDef(vnode.data)) {
var i;
var listeners = cbs.remove.length + 1;
if (isDef(rm)) {
// we have a recursively passed down rm callback
// increase the listeners count
rm.listeners += listeners;
} else {
// directly removing
rm = createRmCb(vnode.elm, listeners);
}
// recursively invoke hooks on child component root node
if (isDef(i = vnode.componentInstance) && isDef(i = i._vnode) && isDef(i.data)) {
removeAndInvokeRemoveHook(i, rm);
}
for (i = 0; i < cbs.remove.length; ++i) {
cbs.remove[i](vnode, rm);
}
if (isDef(i = vnode.data.hook) && isDef(i = i.remove)) {
i(vnode, rm);
} else {
rm();
}
} else {
removeNode(vnode.elm);
}
}
function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
var oldStartIdx = 0;
var newStartIdx = 0;
var oldEndIdx = oldCh.length - 1;
var oldStartVnode = oldCh[0];
var oldEndVnode = oldCh[oldEndIdx];
var newEndIdx = newCh.length - 1;
var newStartVnode = newCh[0];
var newEndVnode = newCh[newEndIdx];
var oldKeyToIdx, idxInOld, elmToMove, refElm;
// removeOnly is a special flag used only by
// to ensure removed elements stay in correct relative positions
// during leaving transitions
var canMove = !removeOnly;
while (oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
if (isUndef(oldStartVnode)) {
oldStartVnode = oldCh[++oldStartIdx]; // Vnode has been moved left
} else if (isUndef(oldEndVnode)) {
oldEndVnode = oldCh[--oldEndIdx];
} else if (sameVnode(oldStartVnode, newStartVnode)) {
patchVnode(oldStartVnode, newStartVnode, insertedVnodeQueue);
oldStartVnode = oldCh[++oldStartIdx];
newStartVnode = newCh[++newStartIdx];
} else if (sameVnode(oldEndVnode, newEndVnode)) {
patchVnode(oldEndVnode, newEndVnode, insertedVnodeQueue);
oldEndVnode = oldCh[--oldEndIdx];
newEndVnode = newCh[--newEndIdx];
} else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue);
canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
oldStartVnode = oldCh[++oldStartIdx];
newEndVnode = newCh[--newEndIdx];
} else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue);
canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
oldEndVnode = oldCh[--oldEndIdx];
newStartVnode = newCh[++newStartIdx];
} else {
if (isUndef(oldKeyToIdx)) { oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx); }
idxInOld = isDef(newStartVnode.key)
? oldKeyToIdx[newStartVnode.key]
: findIdxInOld(newStartVnode, oldCh, oldStartIdx, oldEndIdx);
if (isUndef(idxInOld)) { // New element
createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);
} else {
elmToMove = oldCh[idxInOld];
/* istanbul ignore if */
if ("development" !== 'production' && !elmToMove) {
warn(
'It seems there are duplicate keys that is causing an update error. ' +
'Make sure each v-for item has a unique key.'
);
}
if (sameVnode(elmToMove, newStartVnode)) {
patchVnode(elmToMove, newStartVnode, insertedVnodeQueue);
oldCh[idxInOld] = undefined;
canMove && nodeOps.insertBefore(parentElm, elmToMove.elm, oldStartVnode.elm);
} else {
// same key but different element. treat as new element
createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm);
}
}
newStartVnode = newCh[++newStartIdx];
}
}
if (oldStartIdx > oldEndIdx) {
refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
} else if (newStartIdx > newEndIdx) {
removeVnodes(parentElm, oldCh, oldStartIdx, oldEndIdx);
}
}
function findIdxInOld (node, oldCh, start, end) {
for (var i = start; i < end; i++) {
var c = oldCh[i];
if (isDef(c) && sameVnode(node, c)) { return i }
}
}
function patchVnode (oldVnode, vnode, insertedVnodeQueue, removeOnly) {
if (oldVnode === vnode) {
return
}
var elm = vnode.elm = oldVnode.elm;
if (isTrue(oldVnode.isAsyncPlaceholder)) {
if (isDef(vnode.asyncFactory.resolved)) {
hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
} else {
vnode.isAsyncPlaceholder = true;
}
return
}
// reuse element for static trees.
// note we only do this if the vnode is cloned -
// if the new node is not cloned it means the render functions have been
// reset by the hot-reload-api and we need to do a proper re-render.
if (isTrue(vnode.isStatic) &&
isTrue(oldVnode.isStatic) &&
vnode.key === oldVnode.key &&
(isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
) {
vnode.componentInstance = oldVnode.componentInstance;
return
}
var i;
var data = vnode.data;
if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
i(oldVnode, vnode);
}
var oldCh = oldVnode.children;
var ch = vnode.children;
if (isDef(data) && isPatchable(vnode)) {
for (i = 0; i < cbs.update.length; ++i) { cbs.update[i](oldVnode, vnode); }
if (isDef(i = data.hook) && isDef(i = i.update)) { i(oldVnode, vnode); }
}
if (isUndef(vnode.text)) {
if (isDef(oldCh) && isDef(ch)) {
if (oldCh !== ch) { updateChildren(elm, oldCh, ch, insertedVnodeQueue, removeOnly); }
} else if (isDef(ch)) {
if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }
addVnodes(elm, null, ch, 0, ch.length - 1, insertedVnodeQueue);
} else if (isDef(oldCh)) {
removeVnodes(elm, oldCh, 0, oldCh.length - 1);
} else if (isDef(oldVnode.text)) {
nodeOps.setTextContent(elm, '');
}
} else if (oldVnode.text !== vnode.text) {
nodeOps.setTextContent(elm, vnode.text);
}
if (isDef(data)) {
if (isDef(i = data.hook) && isDef(i = i.postpatch)) { i(oldVnode, vnode); }
}
}
function invokeInsertHook (vnode, queue, initial) {
// delay insert hooks for component root nodes, invoke them after the
// element is really inserted
if (isTrue(initial) && isDef(vnode.parent)) {
vnode.parent.data.pendingInsert = queue;
} else {
for (var i = 0; i < queue.length; ++i) {
queue[i].data.hook.insert(queue[i]);
}
}
}
var bailed = false;
// list of modules that can skip create hook during hydration because they
// are already rendered on the client or has no need for initialization
var isRenderedModule = makeMap('attrs,style,class,staticClass,staticStyle,key');
// Note: this is a browser-only function so we can assume elms are DOM nodes.
function hydrate (elm, vnode, insertedVnodeQueue) {
if (isTrue(vnode.isComment) && isDef(vnode.asyncFactory)) {
vnode.elm = elm;
vnode.isAsyncPlaceholder = true;
return true
}
{
if (!assertNodeMatch(elm, vnode)) {
return false
}
}
vnode.elm = elm;
var tag = vnode.tag;
var data = vnode.data;
var children = vnode.children;
if (isDef(data)) {
if (isDef(i = data.hook) && isDef(i = i.init)) { i(vnode, true /* hydrating */); }
if (isDef(i = vnode.componentInstance)) {
// child component. it should have hydrated its own tree.
initComponent(vnode, insertedVnodeQueue);
return true
}
}
if (isDef(tag)) {
if (isDef(children)) {
// empty element, allow client to pick up and populate children
if (!elm.hasChildNodes()) {
createChildren(vnode, children, insertedVnodeQueue);
} else {
// v-html and domProps: innerHTML
if (isDef(i = data) && isDef(i = i.domProps) && isDef(i = i.innerHTML)) {
if (i !== elm.innerHTML) {
/* istanbul ignore if */
if ("development" !== 'production' &&
typeof console !== 'undefined' &&
!bailed
) {
bailed = true;
console.warn('Parent: ', elm);
console.warn('server innerHTML: ', i);
console.warn('client innerHTML: ', elm.innerHTML);
}
return false
}
} else {
// iterate and compare children lists
var childrenMatch = true;
var childNode = elm.firstChild;
for (var i$1 = 0; i$1 < children.length; i$1++) {
if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue)) {
childrenMatch = false;
break
}
childNode = childNode.nextSibling;
}
// if childNode is not null, it means the actual childNodes list is
// longer than the virtual children list.
if (!childrenMatch || childNode) {
/* istanbul ignore if */
if ("development" !== 'production' &&
typeof console !== 'undefined' &&
!bailed
) {
bailed = true;
console.warn('Parent: ', elm);
console.warn('Mismatching childNodes vs. VNodes: ', elm.childNodes, children);
}
return false
}
}
}
}
if (isDef(data)) {
for (var key in data) {
if (!isRenderedModule(key)) {
invokeCreateHooks(vnode, insertedVnodeQueue);
break
}
}
}
} else if (elm.data !== vnode.text) {
elm.data = vnode.text;
}
return true
}
function assertNodeMatch (node, vnode) {
if (isDef(vnode.tag)) {
return (
vnode.tag.indexOf('vue-component') === 0 ||
vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
)
} else {
return node.nodeType === (vnode.isComment ? 8 : 3)
}
}
return function patch (oldVnode, vnode, hydrating, removeOnly, parentElm, refElm) {
if (isUndef(vnode)) {
if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }
return
}
var isInitialPatch = false;
var insertedVnodeQueue = [];
if (isUndef(oldVnode)) {
// empty mount (likely as component), create new root element
isInitialPatch = true;
createElm(vnode, insertedVnodeQueue, parentElm, refElm);
} else {
var isRealElement = isDef(oldVnode.nodeType);
if (!isRealElement && sameVnode(oldVnode, vnode)) {
// patch existing root node
patchVnode(oldVnode, vnode, insertedVnodeQueue, removeOnly);
} else {
if (isRealElement) {
// mounting to a real element
// check if this is server-rendered content and if we can perform
// a successful hydration.
if (oldVnode.nodeType === 1 && oldVnode.hasAttribute(SSR_ATTR)) {
oldVnode.removeAttribute(SSR_ATTR);
hydrating = true;
}
if (isTrue(hydrating)) {
if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
invokeInsertHook(vnode, insertedVnodeQueue, true);
return oldVnode
} else {
warn(
'The client-side rendered virtual DOM tree is not matching ' +
'server-rendered content. This is likely caused by incorrect ' +
'HTML markup, for example nesting block-level elements inside ' +
', or missing
. Bailing hydration and performing ' +
'full client-side render.'
);
}
}
// either not server-rendered, or hydration failed.
// create an empty node and replace it
oldVnode = emptyNodeAt(oldVnode);
}
// replacing existing element
var oldElm = oldVnode.elm;
var parentElm$1 = nodeOps.parentNode(oldElm);
createElm(
vnode,
insertedVnodeQueue,
// extremely rare edge case: do not insert if old element is in a
// leaving transition. Only happens when combining transition +
// keep-alive + HOCs. (#4590)
oldElm._leaveCb ? null : parentElm$1,
nodeOps.nextSibling(oldElm)
);
if (isDef(vnode.parent)) {
// component root element replaced.
// update parent placeholder node element, recursively
var ancestor = vnode.parent;
var patchable = isPatchable(vnode);
while (ancestor) {
for (var i = 0; i < cbs.destroy.length; ++i) {
cbs.destroy[i](ancestor);
}
ancestor.elm = vnode.elm;
if (patchable) {
for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
cbs.create[i$1](emptyNode, ancestor);
}
// #6513
// invoke insert hooks that may have been merged by create hooks.
// e.g. for directives that uses the "inserted" hook.
var insert = ancestor.data.hook.insert;
if (insert.merged) {
// start at index 1 to avoid re-invoking component mounted hook
for (var i$2 = 1; i$2 < insert.fns.length; i$2++) {
insert.fns[i$2]();
}
}
}
ancestor = ancestor.parent;
}
}
if (isDef(parentElm$1)) {
removeVnodes(parentElm$1, [oldVnode], 0, 0);
} else if (isDef(oldVnode.tag)) {
invokeDestroyHook(oldVnode);
}
}
}
invokeInsertHook(vnode, insertedVnodeQueue, isInitialPatch);
return vnode.elm
}
}
/* */
var directives = {
create: updateDirectives,
update: updateDirectives,
destroy: function unbindDirectives (vnode) {
updateDirectives(vnode, emptyNode);
}
};
function updateDirectives (oldVnode, vnode) {
if (oldVnode.data.directives || vnode.data.directives) {
_update(oldVnode, vnode);
}
}
function _update (oldVnode, vnode) {
var isCreate = oldVnode === emptyNode;
var isDestroy = vnode === emptyNode;
var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
var dirsWithInsert = [];
var dirsWithPostpatch = [];
var key, oldDir, dir;
for (key in newDirs) {
oldDir = oldDirs[key];
dir = newDirs[key];
if (!oldDir) {
// new directive, bind
callHook$1(dir, 'bind', vnode, oldVnode);
if (dir.def && dir.def.inserted) {
dirsWithInsert.push(dir);
}
} else {
// existing directive, update
dir.oldValue = oldDir.value;
callHook$1(dir, 'update', vnode, oldVnode);
if (dir.def && dir.def.componentUpdated) {
dirsWithPostpatch.push(dir);
}
}
}
if (dirsWithInsert.length) {
var callInsert = function () {
for (var i = 0; i < dirsWithInsert.length; i++) {
callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
}
};
if (isCreate) {
mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'insert', callInsert);
} else {
callInsert();
}
}
if (dirsWithPostpatch.length) {
mergeVNodeHook(vnode.data.hook || (vnode.data.hook = {}), 'postpatch', function () {
for (var i = 0; i < dirsWithPostpatch.length; i++) {
callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
}
});
}
if (!isCreate) {
for (key in oldDirs) {
if (!newDirs[key]) {
// no longer present, unbind
callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
}
}
}
}
var emptyModifiers = Object.create(null);
function normalizeDirectives$1 (
dirs,
vm
) {
var res = Object.create(null);
if (!dirs) {
return res
}
var i, dir;
for (i = 0; i < dirs.length; i++) {
dir = dirs[i];
if (!dir.modifiers) {
dir.modifiers = emptyModifiers;
}
res[getRawDirName(dir)] = dir;
dir.def = resolveAsset(vm.$options, 'directives', dir.name, true);
}
return res
}
function getRawDirName (dir) {
return dir.rawName || ((dir.name) + "." + (Object.keys(dir.modifiers || {}).join('.')))
}
function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {
var fn = dir.def && dir.def[hook];
if (fn) {
try {
fn(vnode.elm, dir, vnode, oldVnode, isDestroy);
} catch (e) {
handleError(e, vnode.context, ("directive " + (dir.name) + " " + hook + " hook"));
}
}
}
var baseModules = [
ref,
directives
];
/* */
function updateAttrs (oldVnode, vnode) {
var opts = vnode.componentOptions;
if (isDef(opts) && opts.Ctor.options.inheritAttrs === false) {
return
}
if (isUndef(oldVnode.data.attrs) && isUndef(vnode.data.attrs)) {
return
}
var key, cur, old;
var elm = vnode.elm;
var oldAttrs = oldVnode.data.attrs || {};
var attrs = vnode.data.attrs || {};
// clone observed objects, as the user probably wants to mutate it
if (isDef(attrs.__ob__)) {
attrs = vnode.data.attrs = extend({}, attrs);
}
for (key in attrs) {
cur = attrs[key];
old = oldAttrs[key];
if (old !== cur) {
setAttr(elm, key, cur);
}
}
// #4391: in IE9, setting type can reset value for input[type=radio]
/* istanbul ignore if */
if (isIE9 && attrs.value !== oldAttrs.value) {
setAttr(elm, 'value', attrs.value);
}
for (key in oldAttrs) {
if (isUndef(attrs[key])) {
if (isXlink(key)) {
elm.removeAttributeNS(xlinkNS, getXlinkProp(key));
} else if (!isEnumeratedAttr(key)) {
elm.removeAttribute(key);
}
}
}
}
function setAttr (el, key, value) {
if (isBooleanAttr(key)) {
// set attribute for blank value
// e.g. Select one
if (isFalsyAttrValue(value)) {
el.removeAttribute(key);
} else {
// technically allowfullscreen is a boolean attribute for 