0.8.20.2, 2013-07-19, Update to hterm 1.14.

* Update to hterm 1.14.

0.8.20.1, 2013-07-18, Update to hterm 1.13.

* Disable zoom warning on newer Chrome builds.

0.8.20, 2013-07-08, Stable release of 0.8.19.4

* Stable release of 0.8.19.4

0.8.19.4, 2013-06-24, Update to hterm 1.12.

* Include zoom warning fix from hterm 1.12.

0.8.19.3, 2013-06-20, Update to hterm 1.11.

* Include 'send-encoding'/'receive-encoding' preferences from hterm 1.11.

0.8.19.2, 2013-06-20, Update to hterm 1.10.

* Include 'characer-encoding' preference from hterm 1.10.

0.8.19.1, 2013-06-19, Update to hterm 1.9.

* Include Shift-Tab fixes from hterm 1.9.

0.8.19, 2013-06-19, Stable release of 0.8.18.5

* Stable release of 0.8.18.5.

0.8.18.5, 2013-05-31, Overscroll fix.

* Update to hterm 1.8.

0.8.18.4, 2013-05-31, Small fixes.

* Update to hterm 1.7.
* BUG=245459: Disable the "Are you sure?" before-unload dialog when open as a
  window.

0.8.18.3, 2013-05-03, Update to libdot 1.3.

* Update to libdot 1.3.

0.8.18.2, 2013-04-16, Update to hterm 1.4.

* Update to hterm 1.4.
* Modify ./bin/mkzip.sh to warn if nassh_deps.concat.js is not current.

0.8.18.1, 2013-04-08, Update to hterm 1.3.

* Update to hterm 1.3 to get clear screen, media key, and alt-backspace changes.

0.8.18, 2014-04-08, Stable release of 0.8.17.3

* Stable release of 0.8.17.3.

0.8.17.3, 2013-04-02, Add preferences export/import.

* Added some basic plumbing for preference import/export.  Must be driven from
  the command line console at the moment.

0.8.17.2, 2013-04-01, Rebuild nacl plugin with ixany fix.

* Rebuild plugin with https://codereview.chromium.org/13008014/.
  BUG=chromium:218361, ...ixany/tostop being set in termios

0.8.17.1, 2013-03-28, Add relay port option, update nacl plugin

* Update NaCl plugin to the latest source.
* Add ability to specify relay port.

0.8.16.3, 2013-03-19, Update to hterm 1.2

* Update to hterm 1.2 to get terminal bell fix.

0.8.16.2, 2013-03-18, Fix crosh/prefs pages

* Fix script includes in nassh_preferences_editor.html and crosh.html pages.

0.8.16.1, 2013-03-14, Grab bag of fixes

* Update to libdot 1.1, hterm 1.1.
* Add notice about the age of the hterm library on startup in TOT builds.
* BUG=chromium-os:34460, can't delete connections with on-screen "[DEL] Delete"
  button.
* BUG=chromium-os:39287, col walking in connection manager doesn't work quite
  right.
* BUG=chromium-os:39594, When focused, Enter button does not respond to pressing
  the Enter key.

0.8.16, 2013-02-28, Stable release of 0.8.15.1

* Stable release of 0.8.15.1.

0.8.15.1, 2013-02-26, Improve character size precision.

* Change hterm.ScrollPort..measureCharacterSize to average out 100 characters
  rather than measuring just one.  The improved precision is necessary on
  high-dpi devices.
* Fix a bug in measureCharacterSize that got the zoomFactor wrong (we never
  re-measured after disabling zoom adjustments.)

0.8.15, 2013-02-25, Stable release of 0.8.14.1.

* Stable release of 0.8.14.1.

0.8.14.1, 2013-02-25, Fix column-list scrolling.

* Swap out the flexbox based listbox for an old skool table.  The flexbox
  version didn't scroll properly and didn't handle text-overflow: ellipsis.

0.8.14, 2013-02-22, Stable release of 0.8.13.1.

* Stable release of 0.8.13.1.

0.8.13.1, 2013-02-22, Fix version detection regression.

* Fix version detection regression.

0.8.13, 2013-02-22, Re-release of 0.8.13 with correct icon.

* Re-release after fix to ../libdot/bin/mkzip.sh to use the correct app icon.

0.8.12.1, 2013-02-22, Combine changelogs.

* Combine doc/changelog-dev.txt and doc/changelog-stable.txt into
  doc/changelog.txt.
* Unreleased No-op dev version bump so we can re-package 0.8.12 as 0.8.13, but
  with the correct icon.

0.8.12, 2013-02-22, Stable release of 0.8.11.6

* Stable release of 0.8.11.6

0.8.11.6, 2013-01-20, Address review comments, restrict to >=M23

* Includes changes that were made during 0.8.11.5 code reviews.
* Remove the nacl (not pnacl) plugin and the code to load it in Chrome 22 and
  lower.
* Restrict to Chrome 23 and higher in manifest.json.

0.8.11.5, 2013-01-06, Dialog cleanup, scrollbar fixes

* Fix size of rowNodes element in hterm.ScrollPort so that it doesn't cover
  the scrollbar.
* Fix bug where we'd focus the wrong connection profile after creating
  a new one.
* Populate the username and hostname fields as soon as the description
  loses focus.

0.8.11.4, 2013-01-05, More getBoundingClientRect fixes

* Fix remaining getBoundingClientRect issues so that all tests pass.

0.8.11.3, 2013-01-05, Fix preferences page

* Fix preferences page.

0.8.11.2, 2013-01-05, Fix crosh

* Fix crosh init.

0.8.11.1, 2013-01-04, libs and fixin's

* Removed "pattern" attribute on hostname input box.
  BUG=chromium-os:36832 host field doesn't accept IPv6 addresses.
* Use getBoundingClientRect() so we can handle sub-pixel positioning.
  BUG=chromium-os:31840, Sub-pixel text positioning breaks cursor position
  calculations
* Make connection dialog size a function of window size.
* Explicitly specify the size of new windows open with Ctrl-Shift-N.
  BUG=chromium-os:38272 The second Secure Shell window is always very small

* Add ability to register new init functions via lib.registerInit.  These
  will be called in order during lib.init().
* Make ensureRuntimeDependencies private and call it during lib.init().
* Move lib.getStack to lib.f.getStack.
* Add "escapeHTML" flag to lib.f.replaceVars.
* Add lib.f.alarm to wrap callbacks with a timer that logs a warning
  message if the callback isn't invoked before time expires.

* Update existing preference record when a dupe is passed to
  lib.PreferenceManager..definePreference, rather than throw an exception.
* Change lib.PreferenceManager..defineChildren to take a factory function
  instead of a constructor, so that children can be of different classes.
* Add opt_hint to lib.PreferenceManager..createChild, to allow callers to
  include an opaque string in a generated id.
* Add opt_id to lib.PreferenceManager..createChild, to allow callers to
  specify a child id.
* Add opt_default to getChild.  If passed, getChild will return
  it, rather than throw an exception.
* Pass the preference manager instance, rather than the storage object,
  to the child factory when creating a new child.  This gives the
  child instance much more context to work with.
* Add lib.PreferenceManager.diffChildLists utility function to make it
  easy to find out what's changed in a list of children since you last
  saw it.

* Add nassh.test() to launch the tests from a chrome-extension: url,
  since file: urls don't appear to allow XHR anymore.
* Fix stack trace logging in lib.TestManager.Test..run.
* Make lib.TestManager.Result..completeTest_ throw a TestComplete
  exception even for re-completes.  This ensures the test case is interrupted.

0.8.9.2, 2013-01-03, Fix OSC 52 with UTF-8 text.

* Convert UTF-8 strings to UTF-16 before copying to clipboard for OSC 52.

0.8.9.1, 2012-12-12, Add Alt/Meta-0..9 handlers.

* Add prefs to send Alt/Meta-1..9 to the host.  Preferences default to
  autodetect based on OS platform and window type.

0.8.9.0, 2012-12-12, Add Ctrl-Shift-K and Ctrl-1..9 handlers.

* Add Terminal.prototype.wipe() method to clear primary screen, alternate
  screen, and scrollback buffer.
* Map Ctrl-Shift-K to term_.wipe().
* Detect the window type during hterm.init() so we can branch based on the
  open-as-window state.
* Add prefs to send Ctrl-1..9 to the host.  Preferences default to
  autodetect based on OS platform and window type.
* Add "Pro Tip" about open-as-window for non-OS X users who are not opened
  in a dedicated app window.

BUG=chromium-os:35507, Pass alt/ctrl 0..9
BUG=chromium-os:32111, Add ability to clear scrollback buffer

0.8.8, 2012-12-10, Stable release of 0.8.8.10.

* Stable release of 0.8.8.10.

0.8.8.10, 2012-11-30, Chrome 21 fixes.

* Fix to properly select lib.Storage.Local on Chrome 21.
* Re-read from storage *before* trying to resolve selected the profile in
  connectToProfile().
* Add lib.Storage.Memory for the test harness.

0.8.8.9, 2012-11-28, Rebuild Pepper 25 binaries

* Tweak build scripts and rebuild Pepper 25 based nacl binaries.

0.8.8.8, 2012-11-27, Pepper 25 changes

* Build pnacl binaries with Pepper 25.
* Add Chrome >=24 plugin selection.

0.8.8.7, 2012-10-31, Fix missing 'var' in preference manager.

* Add a missing 'var' keyword in lib_preference_manager.js.

0.8.8.6, 2012-10-31, Fixes for options page and Chrome 21 storage

* Fix 'enable-bold' pref.
* Fix non-text inputs in options page.
* Fix copy/paste error in lib.Storage.Local (which is only used in
  Chrome <= 21).

BUG=chromium-os:35109, Disable bold fonts

0.8.8.5, 2012-10-25, Options page, baud rate, c/p cleanup

* Initial add of an options page, thanks to Mike Frysinger.
* Tweak the nacl plugin to set a default baud rate for the tty.
* It turns out webkit stops sending "paste" events if you have a child with
  -webkit-user-select: none.  This patch works around the issue by calling
  preventDefault() from the mousedown event, instead of using
  -webkit-user-select.
* eraseToRight: If the current background color is default, then delete instead
  of inserting spaces.  This trims the trailing whitespace in the most common
  case.
* Replace new-lines with carriage-returns on paste, since it's the right thing
  to do.
* Add osc52.vim and osc52.sh scripts to help users with clipboard integration.

BUG=chromium-os:35643, Incorrect tty baud rate

0.8.8.4, 2012-10-15, Reland 0.8.8.1 changes

* Broke 0.8.8.1 changes into smaller CLs for easier review.  This commit marks
  the re-integration of the changes.
* Re-order includes in nassh_connect_dialog.html
* Make hterm.init call back on a timeout.
* Removed lib.f.alarm for now.  This function was released as part of 0.8.8.1
  but I'm holding off on landing it until later.

0.8.8.3, 2012-10-15, Include pnacl binary.

* Actually include the pnacl binary in the package.

0.8.8.2, 2012-10-14, Use pnacl on Chrome >= 23.

* Add a pnacl version of the plugin which we load only in Chrome >= 23.

0.8.8.1, 2012-10-14, Chrome stable vs storage.sync fix.

* Fix nassh.PreferenceManager to degrade to window.localStorage if
  chrome.storage.sync is not available.
* Add lib.f.alarm.
* Fix scroll-on-output preference.

0.8.8.0, 2012-10-08, Synchronized preferences.

* Add lib.Storage.Local and lib.Storage.Chrome classes to normalize the API
  between window.localStorage and chrome.storage.
* Generalize nassh.PreferenceManager profile management code into
  lib.PreferenceManager so that other code can easily define child preferences.
* Add preference to override the default color palette.

0.8.7, 2012-10-08, Stable release of 0.8.7.5.

* Stable release of 0.8.7.5.

0.8.7.5, 2012-10-2, Text selection fix.

* Fix mouse-based text selection when the selection involves styled text.

0.8.7.4, 2012-09-26, Insert lines fix.

* Fix hterm.Terminal.insertLines to move the correct rows.  This fixes the
  Reverse Index (RI) sequence (and probably others) that depended on it.

0.8.7.3, 2012-09-25, Styled holes

* Backfill holes created by Erase Characters (ECH) and Delete Characters (DCH)
  with spaces in the current text style.
* Fix minor issue with Character Attributes (SGR) with colors 100-107.  These
  were setting the foreground color instead of the background.

BUG=chromium-os:30258, Text attributes not rendered for whitespace at the end
    of a line

0.8.7.2, 2012-09-24, Fix regressions, disable pnacl

* Recompile nacl plugin without pnacl to avoid crashes on Mac and extreme
  slowness elsewhere.
* Fix keyboard regression that prevented multi-accelerator sequences
  (ctrl-alt-foo, etc) from working.
* Stop bolding colors >= 16.

BUG=chromium-os:34306, hterm shows wrong colors for bold colors 16 through 249

0.8.7.1, 2012-09-20, Some keyboard fixes and pnacl

* Recompile nacl plugin with --pnacl enabled.
  (See https://gerrit.chromium.org/gerrit/#/c/33519/.)
* Changed hterm_keyboard.js to only add modifier munging to strings that
  came from the "default" action.  Other actions are assumed to already
  be appropriate for the in use modifier.
* Make Alt-F1...F12 send F11-F22.  This similar to xterm with the "VT220
  Keyboard" option is enabled, except xterm uses Ctrl as the modifier.  We use
  Alt because Ctrl-F1...F12 are not capturable on Chrome OS devices.

BUG=chromium-os:30857, Shift+F6 doesn't work
BUG=chromium-os:32608, Add extended function key (F13-24) support.

0.8.7.0, 2012-09-13, Handle synthetic keystrokes on OS X.

* Added a "textInput" event handler to hterm_keyboard.js.  We're not actually
  supposed to get these, but we do on the Mac in the case where a third party
  app sends synthetic keystrokes to Chrome.

Internal bugs:
6111077 Bluetooth OTP not working with hterm
6838548 Bluetooth OTP is not able to make past SSHinaTab

0.8.6, 2012-09-13, Stable release of 0.8.6.0.

* Stable release of 0.8.6.0.

0.8.6.0, 2012-09-11, Increase max-string-sequence, add enable-clipboard-notice

* Increased the size of the max-string-sequence pref from 1,024 to 100,000, in
  order to support larger clipboard transfers via OSC 52.
* Add an enable-clipboard-notice preference, defaulted to true.  Change this
  to false to turn off the "Selection Copied" message.
* Added etc/osc52.el, a reference implementation of emacs-to-hterm clipboard
  sync.  The script should also work for xterm and other OSC 52 compliant
  terminals.

0.8.5, 2012-09-07, Stable release of 0.8.5.1.

* Stable release of 0.8.5.1.

0.8.5.1, 2012-09-07, Fix triple-click selection.

* Another selection bug.  Triple clicks result in the selection of exactly one
  full row.  This means that the selection ends at the 0 offset of the following
  x-row.  hterm.Terminal.getSelectionText assumed that an x-row couldn't be
  selected, only elements within the row could be.  You could also get into
  this state if you manually selected exactly to the end of a row.

0.8.5.0, 2012-09-06, Fix selection bug.

* The code that tried to determine which node came first in a single-line
  selection was busted.  It didn't work if the selection involved styled
  text.
* Clear location.hash when "(C)hoose another connection" is selected.
* Allow Ctrl-W to close window at the reconnect prompt.
* Show product name and version in the title by default.

BUG=chromium-os:34003
BUG=chromium-os:34149

0.8.4, 2012-09-05, Stable release of 0.8.4.0

* Stable release of 0.8.4.0

0.8.4.0, 2012-09-05, Fix another OSC 4 regression.

* We were mishandling hex X11 rgb values.  They weren't being translated into
  decimal, and would result in invalid CSS rgba(...) values.

0.8.3, 2012-09-05, Stable release of 0.8.3.0

*  Stable release of 0.8.3.0

0.8.3.0, 2012-09-04, Reject invalid resizes.

* Reject attempts to resize or realize a row or column count <= 0.  This fixed
  a bug where new windows opened with ctrl-shift-n would usually hang if
  performed from an active connection.

BUG=chromium-os:34123

0.8.2, 2012-08-27, Stable release of 0.8.2.11

* Stable release of 0.8.2.11.

0.8.2.11, 2012-08-28, Fix OSC-4 regression.

* Fixes a regression that broke OSC-4, color palette read/write, and adds a
  testcase to catch future regressions.

0.8.2.10, 2012-08-24, Fix another missing-rows bug.

* Fix a bug where we'd shift the rowNodes element up to offset hidden nodes
  before the top fold, but never compensated by making the rowNodes element
  taller.

0.8.2.9, 2012-08-22, Don't clear selection for copy-on-select.

* Remove the delay and selection clearing from copy-on-select.  The copy now
  happens immediately, and the selection is not cleared.

BUG=chromium-os:33786, hterm: double paste on right-click

0.8.2.8, 2012-08-21, backout dialog resize CL.

* Remove the dialog size CL, since it requires M21.

0.8.2.7, 2012-08-21, writelnUTF16 fix.

* Actually append '\r\n' in hterm.Terminal.io.writelnUTF16.

0.8.2.6, 2012-08-21, UTF8 fix, copy fix, dialog cleanup

* Fix display of utf-8 data from translated messages.
* connect dialog: Select the previous connection by default.
* connect dialog: Fix dis/enable issues with the buttons.
* connect dialog: Double click to connect.
* Re-add copy-on-select delay.
* Add 'close-on-exit' preference to control whether or not the window closes
  on exit.  Defaults to on.
* Properly handle overflow lines during clipboard copy.
* Offer to reconnect on disconnect.
* Session id parsing in connection arguments.

BUG=chromium-os:27974, Exit command does not close the hterm window
BUG=chromium-os:27020, newlines added during clipboard copy
BUG=chromium-os:29217, offer to reconnect after disconnect

0.8.2.5, 2012-08-15, Misc cleanup.

* Add 'enable-clipboard-write' preference to enable/disable the OSC 52
  (host write to system clipboard) sequence, on by default.
* Change default Windows font to "Terminal".
* Fix the delete profile/delete identity behavior in the connect dialog.
* Fix the placeholder text of the "Terminal Profile" field in the connect
  dialog.
* Remeasure the character size on resize, to catch browser zoom changes.
* Don't show the size overlay for alt/primary screen swaps.

BUG=30604, font face 'Lucida Console' Bold characters disabled

0.8.2.4, 2012-08-13, Add missing dep to crosh.html.

* Fix missing lib_utf8.js in crosh.html.

0.8.2.3, 2012-08-13, NaCl plugin fixes.

* Various termios fixes for input and output transformation. Fixes
  drawing issue with some ncurses applications.

0.8.2.2, 2012-08-10, Add Ctrl-Shift-N to open new instance.

* Make Ctrl-Shift-N/Meta-Shift-N keyboard combinations open a new window.

0.8.2.1, 2012-08-10, VT mouse, copy/paste work, and bug fixes.

* Moved common libraries under the "lib" object.
* Add "hterm_" prefix to the hterm source files.
* Add 'use strict' everywhere, fix some fallout.
* Split hterm.js filesystem functions into lib.fs.
* Split hterm.js utility functions into lib.f.
* Remove unused dialogs.js,css code.
* Implement character set selection (SCS)
* Pass Alt-*-Tab to the browser.
* Fix bug which may abort connections with "Unknown error 4294967292".
* Encode pasted text as UTF-8.
* Properly encode and decode UTF-8, handling surrogate pairs and
  retaining state between terminal writes.
* Add mouse support via DECSET modes 1000, 1002, 1003.
* Add mouse button paste.  Preference 'mouse-paste-button' defaults to off
  on typical X11, on everywhere else (including Aura on X11).
* Add ability to automatically copy the mouse selection to the keyboard.
  Preference 'copy-on-select' defaults to on.
* Add ability to let Shift-Insert cause a clipboard paste.  Preference
  'shift-insert-paste' defaults to on.
* Add partial OSC 52 support to allow the host to write to the system clipboard.
* Fix extra-long line wrapping.
* Add basic line editing for local ssh prompts (password, fingerprint prompt,
  and the "~C" command line).
* Add websockets to the google proxy and make it the default connection type.
* Fix ssh "target command" parsing.
* Make the JavaScript side of things more robust against a NaCl plugin crash.

BUG=chromium-os:30296, UTF-8 decoder is not a function of input stream; will
    break when UTF-8 sequence split across reads
BUG=chromium-os:30297, UTF-8 decoder does not conform to Unicode standard
    re: invalid sequences
BUG=chromium-os:29490, Middle click should paste in the terminal
BUG=chromium-os:26288, hterm: Add mouse support via DECSET 1000, 1002, 1003

0.8.2.0, 2012-06-14, Localization and Accessibility for the connect dialog

* Add message_manager.js to manage string bundles.
* Add a bunch of new strings for the dialog.
* Make nassh_connect_dialog.html/js use the new strings.
* Fix minor issue with argument parsing.

0.8.1.0, 2012-06-12, New connection dialog, flow control

* New nassh binary:
  - Support for flow control (try aafire!)
  - Use Pepper host resolver when possible.
  - Smaller TCP window in ssh (try ^C in aafire!)
* Add preferences for background-size and background-position
* Move hterm.NaSSH out to NaSSH.  This is in preparation for upcoming changes
  to further isolate the terminal from commands that run within it.
* Fix handling of the cursor overflow flag for the ICH, ED, EL, DL,
  DCH, and ECH commands.
* nassh_box.css: Add box layout css library.
* nassh_connect_dialog.css: New file, connect dialog styles.
* google_relay.js: Moved to nassh_google_relay.js
* nassh.html: Update script tags.
* nassh_connect_dialog.html:
  - New file, connect dialog UI, making liberal use of nassh_box.css.
  - TODO: i18n, a11y.
* nassh_google_relay.html: Moved from google_relay.html
* colors.js:
  - Added Ned Stark reference.
  - Added rgba color support.
  - Added setAlpha(), mix(), and crackRGB().
* frame.js:
  - First draft of the interface between the terminal and a third party dialog.
  - This will change substantially as the interface is fleshed out.
* google_relay_html.js: moved to nassh_google_relay_html.js.
* hterm.js:
  - Add getURL().
  - Rename old ferr() to fthrow(), make ferr() be like flog() except using
    console.error().
  - Add removeFile() and readDirectory() utility functions.
* nassh.js:
  - Moved most code out into nassh_command_instance.js, some into nassh_main.js.
  - Only static utility functions (and the namespace delcaration) remaing here,
    since this file is now shared by nassh_command_instance.js and
    nassh_connect_dialog.js.
* nassh_column_list.js: "Resuable" multicolumn list control.
* nassh_command_instance.js:
  - Sorry, rename and modifications in the same CL.
  - Update to work with Dmitry's outputWindow changes.
  - Add another session variable so we can distinguish between a
    reload-for-relay-auth, and a user initiated reload.  Now we can re-display
    the connect dialog ONLY for user initiated reloads, even when using a relay.
  - Integrate with nassh_connect_dialog.js.
* nassh_connect_dialog.js:
  - New file containing most of the code backing the new connect dialog.
  - TODO: i18n.
* nassh_css_variables.js:
  - OMG.  CSS variables hack until they land for real.
  - This allows the connect dialog to adapt to the user's color scheme.
* nassh_google_relay.js:
  - s/NaSSH./nassh./g
  - Refactor "destination" into "resumePath", since it was really only being
    used as an opaque place to resume to.
  - Integrate with Dmitry's writeWindow changes.
* nassh_google_relay_html.js: Move from google_relay_html.js.
* nassh_main.js: Split out of nassh.js.
* nassh_preferences.js:
  - New file containing nassh specific preferences.
  - Contains "global" nassh preferences, as well as a collection of remembered
    connection "profiles".
* nassh_streams.js: s/NaSSH./nassh./g
* preference_manager.js:
  - Promote out of the hterm namespace.
  - Allow for multiple preference observers.
  - Allow for after-the-fact registration of preference observers.
  - Throw an error when set() called for unknown pref.
  - Add setLater to set a pref after a timeout and coalesce multiple calls.
  - Fix error when notified about changes to prefs that are no longer declared.
* screen.js:
  - Cache textContent in deleteChars for a decent speedup.
* scrollport.js:
  - Remove focus outline now that the cursor changes style for focus.
* terminal.js:
  - Cache foreground and background colors for major speedup.
  - Add focus/unfocused cursor styles.
  - Remove default background gradient.
* terminal_io.js:
  - Add createFrame().
  - Add setTerminalProfile().
* vt.js: s/cssToX11/rgbToX11/.

BUG=chromium-os:25417, Split screen scrolling in hterm about 5x slower than in
    konsole
BUG=chromium-os:25563, Support specifying imported keys files in hterm
BUG=chromium-os:30103, Add a UI for port forwarding.
BUG=chromium-os:30302, CSI K (erase in line) does not clear wrap-around flag

0.8.0.6, 2012-05-14, rginda@chromium.org

* Add hterm.NaSSH..removeDirectory().

0.8.0.5, 2012-05-11, rginda@chromium.org

* Fix double invocation of initialization code.  This also fixed the reload
  loop when connecting via a relay.
* Minor faq and jsdoc cleanup.

0.8.0.4, 2012-05-11, rginda@chromium.org

* Add hterm.NaSSH..removeFile().

0.8.0.3, 2012-05-10, rginda@chromium.org

* Fix "parseState_" typo in 'ESC %' handler.

0.8.0.2, 2012-05-10, rginda@chromium.org

* Remove trailing comma from messages.json.
* Ensure that /.ssh directory exists before starting.
* Update FAQ to point out that keys don't work on 0.7.9.
* Change manifest-dev.json and package.sh script to move dev version from
  internal home directory to public web store.

0.8.0.1, 2012-05-10, rginda@chromium.org

* Add 'enable-8-bit-control' preference to enable eight bit control sequences.
  This is off by default (which matches xterm) in order to avoid accidental
  usage of some sequences that require termination.  If you encounter one of
  these on accident (while cat'ing binary data, for example) the terminal
  will appear to lock up while waiting for the terminator byte.
* Add 'max-unterminated-sequence' preference to prevent sequences that require
  a terminator from running away forever.
* Squelch warning that used to appear when clearing an empty screen.
* Refactor the parser logic a bit to make it easier to back up when
  we fail to find the end of a string sequence.
* Fix to DECSTBM to resepect origin mode when resetting the cursor position
  after setting the VT scroll region.
* Make soft-reset more like xterm.
* Resize the terminal after the character measurements change rather than
  re-measure the character during a resize.  The latter causes the terminal
  to get the row, column count wrong based on event ordering.
* Fix text wrapping to not wrap text pushed to the right in insert mode. Only
  wrap newly-printed text.
* Fix default tab-stop handling to not restore on resize after TBC. Also fix
  some cases where tab-stops would be dropped.
* Fix ED to erase to the start and end of the screen, independent of scroll
  area.
* Fix a number of issues in color handling. In particular, treat toggling bold
  and inverse independently from setting color indices.
* Fix to ECH to not shift text to the right of the cursor.
* Fix to argument parsing to always treat zero as a default value.
* Remove extra '/' from google_relay.js proxy request.
* Fix alt-sends-what/alt-is-meta pref change handlers.
* Don't re-display connection dialog after a relay redirect.
* Add showFileImporter hack.  This makes it possible to import files from the
  device filesystem into the Secure Shell filesystem.  This makes it "easy"
  to get keypairs and ssh configs into Secure Shell.
* Stop assuming an unspecified port means port 22, since the config file may
  have a different default set.

Internal bug:
6375936 hterm hangs when \x90, \x9D, or \x9E is printed

BUG=chromium-os:30142,chromium-os:30303,chromium-os:30305,chromium-os:30345
BUG=chromium-os:30105,chromium-os:29955,chromium-os:25563

0.7.9.3, 2012-04-20, rginda@chromium.org

* Show app name and version number at startup.
* Add cursor blink preference.
* Add doc/faq.txt.

0.7.9.2, 2012-04-19, rginda@chromium.org

* More sanitary handling of color names in the palette set/get sequence.
* Added colors.js file to contain color utilities and palettes.
* Remove old vt100.js file.

0.7.9.1, 2012-04-18, rginda@chromium.org

* Allow Ctrl +/-/0 to control browser zoom when the browser zoom isn't already
  set to 100%.  This makes it possible to dismiss the new "zoom warning" using
  keyboard shortcuts.

0.7.9.0, 2012-04-18, rginda@chromium.org

* Modify nassh plugin to accept a hash of environment variables.
* Add 'environment' preference, set by default to { TERM: 'xterm-256color' }.
* Implement Operating System Command (OSC) 4.  This allows the host to set
  or read the terminal color palette.
* Reset color palette on soft terminal reset.
* Add JSDoc to text_attributes.js.
* Merge COLORS_16 and COLORS_256 objects into a single
  TextAttributes.prototype.defaultColorPalette object.
* Fix bold-implies-bright logic for extended colors.
* Add a stern warning message when the browser zoom is not 100%.
* Change the naming convention for sessionStorage keys (added a dot, as in
  googleRelay.queryString).
* Add logic to re-display the connect-to dialog on reload, only if nassh was not
  started from a bookmark.
* Fetch the HTML5 persistent filesystem at nassh startup.
* Add NaSSH..removeAllKnownHosts() and NaSSH..removeKnownHostByIndex(i).  These
  can be accessed from the JS console as 'term_.command.remove...()'.
* Fix Terminal.isPrimaryScreen() assign-instead-of-test typo.
* Fix G0/G2/G3 character set control "ESC (", etc. to properly handle a
  mid-sequence ESC character.  (Thanks to nethack for turning this up :)

BUG=chromium-os:28050,chromium-os:25122

0.7.8.3, 2012-04-11, rginda@chromium.org

* Fix 'home-keys-scroll' preference.

0.7.8.2, 2012-04-11, rginda@chromium.org

* Fix google_relay.html CSP issues.

0.7.8.1, 2012-04-10, rginda@chromium.org

* Fix update_url in manifest.

0.7.8.0, 2012-04-10, rginda@chromium.org

* Replace 'alt-sends-escape' preference with 'alt-sends-what'.  The new pref
  can be set to 'escape', '8-bit', or 'browser-key'.  If set to 'escape' (the
  default), hterm will send ESC (as if alt-sends-escape were true, the previous
  default).  If set to '8-bit', hterm sends the unshifted character + 128 (as
  if alt-sends-escape were false).  If set to 'browser-key', hterm waits for
  the keypress event, and sends whatever character code the browser thinks best.
  On Mac, this will depend on your keyboard locale.  Composed characters
  (requiring multiple keystrokes) aren't yet implemented.  'browser-key'
  shoudn't be used in cases where Chrome uses Alt sequences for the browser.

0.7.7.1, 2012-04-10, rginda@chromium.org

* Fix crosh.html/js to work with CSP.

BUG=chromium-os:29179
TEST=Install on ChromeOS, press Ctrl-Alt-T.

0.7.7.0, 2012-04-08, rginda@chromium.org

* Fix version number.  We should have gone to 0.7.7.0 rather than 0.7.6.4 :/
* Renamed to "Secure Shell".
* Updated stable manifest to include CSP and new icons.

BUG=chromium-os:29148

0.7.6.6, 2012-04-06, rginda@chromium.org

* Update to the latest nassh binaries.

0.7.6.5, 2012-04-06, rginda@chromium.org

* Fix Ctrl-\.
* Added keyboard related preferences, 'home-keys-scroll', 'page-keys-scroll',
  'meta-sends-escape', 'backspace-sends-backspace'.
* Added altSendsEscape option to keyboard (and 'alt-sends-escape' pref).  The
  default for alt-is-meta is now false, while alt-sends-escape is true.  This
  lets Alt and Meta be distinct keys when possible (like on a Mac), while making
  Alt work "almost" like meta by default.
* Added a little platform detection logic so we don't burn BOTH Alt-1..9 and
  Meta-1..9 on every platform.
* Fixed broken backspaceSendsBackspace behavior.
* Fix Meta-Space to send ESC \x20 rather than ESC [.
* Fix character sizing issues, which solves the missing underscores in some
  fonts, and should solve partial/completely missing terminal row issues.
* Add background-image pref, defaults to a mostly transparent gradient.
* Change a few one-byte colors to work better with both light and dark
  backgrounds.

Internal bugs:
6100845 Significant color differences with hterm compared to shellinabox
6183497 Backspace sends delete to emacs
6270109 option-space sends ESC [
6270158 hterm (OS X): option-v and option-1 thru option-9 have no effect
6063659 First line of the console appears off the top of the screen

BUG=chromium-os:28771,chromium-os:28611

0.7.6.4, 2012-04-04, rginda@chromium.org

* Add 'manifest_version': 2 to manifest file, specify default
  Content Security Policy (CSP) policy.
* Kick off nassh initialization from nassh.js rather than
  nassh.html to make CSP happy.
* Move dialog code from terminal.* into nassh.*, makes CSP happier
  and it's the right thing to do.

BUG=chromium-os:28561

0.7.6.3, 2012-03-19, rginda@chromium.org

* Fix regression that caused hterm to fail to load if the chosen font was not
  "safe" for bold charcters.

BUG=chromium-os:28020

0.7.6.2, 2012-03-16, rginda@chromium.org

* Fix regression in terminal reset.

BUG=chromium-os:27950

0.7.6.1, 2012-03-15, rginda@chromium.org

* Make the relay code more resiliant to intermittent failures.

0.7.6.0, 2012-03-14, rginda@chromium.org

* Refactor and clean up of the relay server code.
* Add backoff logic to relay server code.
* Promote Terminal.showOverlay to Terminal.IO.showOverlay.
* PASS on handling Meta-~, since on Mac Meta is Cmd and Cmd-~ is the 'switch
  between windows of this app' sequence.

0.7.5.2, 2102-03-07, rginda@chromium.org

* Re-add default tab width, add a testcase to catch future regressions.

0.7.5.1, 2102-03-07, rginda@chromium.org

* Cached scroll-on-output and scroll-on-keystroke preferences to avoid the
  performance hit of reading a preference for each bit of output and keystroke.

0.7.5.0, 2102-03-07, rginda@chromium.org

* Add preferences.  Preferences are persisted to localStorage.  Active hterm
  instances will respond to preference changes by listening to the 'storage'
  event.
* Preferences can be grouped into "profiles" so that it's possible
  to maintain multiple terminal configurations and easily switch
  between them.
* The preference profile can be selected at load-time by adding
  'profile=NAME' to the url used to load nassh.html or crosh.html.

0.7.4.4, 2012-02-28, rginda@chromium.org

* Add ability to detect fonts with mismatched bold/normal sizes, and disable
  bold characters when that happens.

0.7.4.3, 2012-02-28, rginda@chromium.org

* Switch out "Andale Mono" in favor of "Menlo" in the default font family list,
  since bold characters in Andale Mono are a different width than normal
  weight characters.

0.7.4.2, 2012-02-28, rginda@chromium.org

* Fix CONNECTING message to take a single DESTINATION parameter rather
  than distinct USER and HOST parameters.  This avoids an issue in the
  chrome i18n code that chokes on the translated messages.
  http://crosbug.com/26620

0.7.4.1, 2012-02-28, rginda@chromium.org

* Fix remaining issues with ESC 0x20 handler.

0.7.4.0, 2012-02-28, rginda@chromium.org

* Fix permission issue in package.sh script.
* Remove spash screen.
* Fix syntax error in ESC 0x20 handler.
* Warn before closing an active crosh tab.

0.7.3.0, 2012-02-17, rginda@chromium.org

* Manifest files split into -dev and -stable versions.
* Add an altIsMeta flag, on by default.
* Treat Meta-C/Meta-Shift-V the same as Ctrl-C/Ctrl-Shift-V to
  make mac users happy.
* Pass (Ctrl|Meta)-Shift-B bookmark bar key to browser.
* Pass (Ctrl|Alt|Meta)-1/9 to the browser so as not to block
  tab switching.
* Skip pro-tip if nassh started with a known location.
* Fix TextAttributes.prototype.reset().

BUG=chromium-os:25824,chromium-os:25833,chromium-os:26082
BUG=chromium-os:26280,chromium-os:26285,chromium-os:26463
TEST=test_harness.html, 55/55 tests passed.
