Untitled

diff --git a/.hgtags b/.hgtags

 1f1342f58d8e7d3972928f193e3f40cbf4425230 pentadactyl-1.0b4.1

 962d8a1e823d0855e14aecaa294ef02e718401b1 pentadactyl-1.0b4.2

 d783bcace8c6a24bee7bd22ead22fe44baaebe90 pentadactyl-1.0b4.3

diff --git a/HACKING b/HACKING

   https://developer.mozilla.org/en/New_in_JavaScript_1.7#Block_scope_with_let

 

 * Reuse common local variable names E.g. "elem" is generally used for element,

 

 * Prefer // over /* */ comments (exceptions for big comments are usually OK)

   Right: if (HACK) // TODO: remove hack

 Functional tests are implemented using the Mozmill automated testing framework

 -- https://developer.mozilla.org/en/Mozmill_Tests.

 

 

 The host application binary tested can be overridden via the HOSTAPP_PATH

 makefile variable. E.g.,

diff --git a/common/Makefile b/common/Makefile

 #### configuration

 

 TOP           = $(shell pwd)

 OS            = $(shell uname -s)

 BUILD_DATE    = $(shell date "+%Y/%m/%d %H:%M:%S")

 BASE          = $(TOP)/../common

 GOOGLE_PROJ   = dactyl

 GOOGLE       = https://$(GOOGLE_PROJ).googlecode.com/files

 MANGLE      := $(shell date '+%s' | awk '{ printf "%x", $$1 }')

 MOZMILL       = mozmill

 HOSTAPP_PATH  = $(shell which $(HOSTAPP))

 

 BUILD_DIR     = build.$(VERSION).$(OS)

 

 .SILENT:

 

 #### rules

diff --git a/common/bootstrap.js b/common/bootstrap.js

 const categoryManager = Cc["@mozilla.org/categorymanager;1"].getService(Ci.nsICategoryManager);

 const manager = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);

 

 const BOOTSTRAP_CONTRACT = "@dactyl.googlecode.com/base/bootstrap";

 JSMLoader = JSMLoader || BOOTSTRAP_CONTRACT in Cc && Cc[BOOTSTRAP_CONTRACT].getService().wrappedJSObject.loader;

 

                           .getService(Components.interfaces.extIApplication)

                           .storage.get("dactyl.JSMLoader", null);

 

 function reportError(e) {

     dump("\ndactyl: bootstrap: " + e + "\n" + (e.stack || Error().stack) + "\n");

     Cu.reportError(e);

     let chars = "0123456789abcdefghijklmnopqrstuv";

     for (let n = Date.now(); n; n = Math.round(n / chars.length))

         suffix += chars[n % chars.length];

 

     for each (let line in manifest.split("\n")) {

         let fields = line.split(/\s+/);

             break;

 

         case "resource":

             resources.push(fields[1], fields[1] + suffix);

             resourceProto.setSubstitution(fields[1], getURI(fields[2]));

             resourceProto.setSubstitution(fields[1] + suffix, getURI(fields[2]));

         }

     }

 

     try {

         module("resource://dactyl-content/disable-acr.jsm").init(addon.id);

     }

         reportError(e);

     }

 

         Services.scriptloader.loadSubScript("resource://dactyl" + suffix + "/bootstrap.jsm",

 

 

     JSMLoader.bootstrap = this;

 

 

     JSMLoader.init(suffix);

     JSMLoader.load("base.jsm", global);

                 wrappedJSObject: {}

             },

             createInstance: function () this.instance

 

 

     for each (let component in components)

         component.register();

             reportError(e);

         }

 

             Services.obs.notifyObservers(null, "dactyl-purge", null);

 

 

         JSMLoader.purge();

         for each (let [category, entry] in categories)

diff --git a/common/components/protocols.js b/common/components/protocols.js

 

 function StringChannel(data, contentType, uri) {

     let channel = services.StreamChannel(uri);

     if (contentType)

         channel.contentType = contentType;

     channel.contentCharset = "UTF-8";

     if (doctype) {

         this.writes.push(doctype + "[\n");

         try {

         }

         catch (e) {}

         if (!open)

             this.writes.push("\n]");

     }

     this.writes.push(channelStream);

 

diff --git a/common/content/abbreviations.js b/common/content/abbreviations.js

 

 /** @scope modules */

 

 var Abbreviation = Class("Abbreviation", {

     init: function (modes, lhs, rhs) {

         this.modes = modes.sort();

         this.rhs = rhs;

     },

 

     equals: function (other) this.lhs == other.lhs && this.rhs == other.rhs,

 

     expand: function (editor) String(callable(this.rhs) ? this.rhs(editor) : this.rhs),

 

     modesEqual: function (modes) array.equals(this.modes, modes),

 

     inMode: function (mode) this.modes.some(function (_mode) _mode == mode),

 

     inModes: function (modes) modes.some(function (mode) this.inMode(mode), this),

 

     removeMode: function (mode) {

         this.modes = this.modes.filter(function (m) m != mode).sort();

     },

 

     get modeChar() Abbreviation.modeChar(this.modes)

 }, {

     modeChar: function (_modes) {

         this._store = {};

     },

 

     get empty() !values(this._store).nth(util.identity, 0),

 

     /**

      *

      * @param {Mode} mode The mode of the abbreviation.

      * @param {string} lhs The LHS of the abbreviation.

      */

     get: function (mode, lhs) {

         let abbrevs = this._store[mode];

     },

 

     /**

      *     each mode.

      */

     get merged() {

     },

 

     /**

      *

      * @param {Array} modes List of modes.

      * @param {string} lhs The LHS of the abbreviation.

      */

 

         function abbrevs(hive)

             hive.merged.filter(function (abbr) (abbr.inModes(modes) && abbr.lhs.indexOf(lhs) == 0));

         let list = <table>

                 <tr highlight="Title">

                     <td/>

                 </tr>

                 <col style="min-width: 6em; padding-right: 1em;"/>

                 {

 

         // TODO: Move this to an ItemList to show this automatically

         if (list.*.length() === list.text().length() + 2)

         else

             commandline.commandOutput(list);

     }

             context.completions = group.merged.filter(fn);

         };

     },

     commands: function () {

         function addAbbreviationCommands(modes, ch, modeDescription) {

             modes.sort();

                     dactyl.assert(!args.length || abbreviations._check.test(lhs),

                                   _("error.invalidArgument"));

 

                     else {

                         if (args["-javascript"])

                             rhs = contexts.bindMacro({ literalArg: rhs }, "-javascript", ["editor"]);

                         args["-group"].add(modes, lhs, rhs);

                     }

                 }, {

                     completer: function (context, args) {

                         if (args.length == 1)

                             return completion.abbreviation(context, modes, args["-group"]);

                     if (args.bang)

                         args["-group"].clear(modes);

                     else if (!args["-group"].remove(modes, args[0]))

                 }, {

                     argCount: "?",

                     bang: true,

         }

 

         addAbbreviationCommands([modes.INSERT, modes.COMMAND_LINE], "", "");

     }

 });

 

diff --git a/common/content/autocommands.js b/common/content/autocommands.js

      *

      * @param {string} event The event name filter.

      * @param {string} pattern The URL pattern filter.

      */

     get: function (event, pattern) {

         return this._store.filter(function (autoCmd) autoCmd.match(event, regexp));

     remove: deprecated("group.autocmd.remove", { get: function remove() autocommands.user.closure.remove }),

 

     /**

      *

      * @param {string} event The event name filter.

      * @param {string} regexp The URL pattern filter.

      */

 

         function cmds(hive) {

             let cmds = {};

                     <td colspan="3">----- Auto Commands -----</td>

                 </tr>

                 {

                         <tr highlight="Title">

                             <td colspan="3">{hive.name}</td>

                         </tr> +

         let lastPattern = null;

         var { url, doc } = args;

         if (url)

         else

             var { uri, doc } = buffer;

 

                             args["-group"].remove(event, regexp); // remove all

                     }

                     else

                 }

             }, {

                 bang: true,

diff --git a/common/content/bookmarks.js b/common/content/bookmarks.js

 // also includes methods for dealing with keywords and search engines

 var Bookmarks = Module("bookmarks", {

     init: function () {

         storage.addObserver("bookmark-cache", function (key, event, arg) {

             if (["add", "change", "remove"].indexOf(event) >= 0)

                 autocommands.trigger("Bookmark" + event[0].toUpperCase() + event.substr(1),

                              valueOf: function () arg

                          }

                      }, arg));

         }, window);

     },

 

     get format() ({

         anchored: false,

         title: ["URL", "Info"],

      *

      * @param {Element} elem A form element for which to add a keyword.

      */

         if (elem instanceof HTMLFormElement || elem.form)

             var [url, post, charset] = util.parseForm(elem);

         else

             commands.commandToString({ command: "bmark", options: options, arguments: [url] }) + " -keyword ");

     },

 

     /**

      * Toggles the bookmarked state of the given URL. If the URL is

      * bookmarked, all bookmarks for said URL are removed.

             if (!alias)

                 alias = "search"; // for search engines which we can't find a suitable alias

 

                 alias += ++aliases[alias];

             else

                 aliases[alias] = 0;

     getSuggestions: function getSuggestions(engineName, query, callback) {

         const responseType = "application/x-suggestions+json";

 

         if (engine && engine.supportsResponseType(responseType))

             var queryURI = engine.getSubmission(query, responseType).uri.spec;

         if (!queryURI)

             param = query.substr(offset + 1);

         }

 

         if (engine) {

             if (engine.searchForm && !param)

                 return engine.searchForm;

                 let frames = buffer.allFrames();

                 if (!args.bang)

                     return  [

                         for ([, win] in Iterator(frames))];

                 context.keys.text = "title";

                 context.keys.description = "url";

                         context.title = ["Page URL"];

                         let frames = buffer.allFrames();

                         context.completions = [

                             for ([, win] in Iterator(frames))];

                         return;

                     }

             "Delete a bookmark",

             function (args) {

                 if (args.bang)

                         function (resp) {

                             if (resp && resp.match(/^y(es)?$/i)) {

                                 bookmarks.remove(Object.keys(bookmarkcache.bookmarks));

                             }

                         });

                 else {

                         let context = CompletionContext(args.join(" "));

                         context.fork("bookmark", 0, completion, "bookmark",

                                      args["-tags"], { keyword: args["-keyword"], title: args["-title"] });

                     }

 

                     dactyl.echomsg({ message: _("bookmark.deleted", deletedCount) });

             if (item && item.url.indexOf("%s") > -1)

                 context.fork("keyword/" + keyword, keyword.length + space.length, null, function (context) {

                     context.format = history.format;

                     // context.background = true;

                     context.compare = CompletionContext.Sort.unsorted;

                     context.generate = function () {

                     return;

                 let ctxt = context.fork(name, 0);

 

                 ctxt.keys = { text: util.identity, description: function () "" };

                 ctxt.compare = CompletionContext.Sort.unsorted;

                 ctxt.filterFunc = null;

diff --git a/common/content/browser.js b/common/content/browser.js

         "content-document-global-created": function (win, uri) {

             let top = util.topWindow(win);

 

         }

     },

 

             title: doc.title

         };

 

             args.tab = tabs.getContentIndex(doc) + 1;

             args.doc = {

                 valueOf: function () doc,

                 toString: function () "tabs.getTab(" + (args.tab - 1) + ").linkedBrowser.contentDocument"

             };

         }

 

         autocommands.trigger(name, args);

     progressListener: {

         // XXX: function may later be needed to detect a canceled synchronous openURL()

         onStateChange: util.wrapCallback(function onStateChange(webProgress, request, flags, status) {

                 dactyl.applyTriggerObserver("browser.stateChange", arguments);

                 // This fires when the load event is initiated

                 // only thrown for the current tab, not when another tab changes

                     while (document.commandDispatcher.focusedWindow == webProgress.DOMWindow

                            && modes.have(modes.INPUT))

                         modes.pop();

 

                 }

                     // Workaround for bugs 591425 and 606877, dactyl bug #81

                     config.browser.mCurrentBrowser.collapsed = false;

                     if (!dactyl.focusedElement || dactyl.focusedElement === document.documentElement)

                         dactyl.focusContent();

                 }

             }

         }),

         onSecurityChange: util.wrapCallback(function onSecurityChange(webProgress, request, state) {

             onSecurityChange.superapply(this, arguments);

             ["o"], "Open one or more URLs",

             function () { CommandExMode().open("open "); });

 

         mappings.add([modes.NORMAL], ["O"],

             "Open one or more URLs, based on current location",

 

         mappings.add([modes.NORMAL], ["t"],

             "Open one or more URLs in a new tab",

 

         mappings.add([modes.NORMAL], ["T"],

             "Open one or more URLs in a new tab, based on current location",

 

         mappings.add([modes.NORMAL], ["w"],

             "Open one or more URLs in a new window",

 

         mappings.add([modes.NORMAL], ["W"],

             "Open one or more URLs in a new window, based on current location",

 

             "Open home directory",

             function () { dactyl.open("~"); });

 

             "Open homepage",

             function () { BrowserHome(); });

 

             "Open homepage in a new tab",

             function () {

                 let homepages = gHomeButton.getHomePage();

                 dactyl.open(homepages, { from: "homepage", where: dactyl.NEW_TAB });

             });

 

             "Redraw the screen",

             function () { ex.redraw(); });

     }

diff --git a/common/content/buffer.js b/common/content/buffer.js

         this.evaluateXPath = util.evaluateXPath;

         this.pageInfo = {};

 

         this.addPageInfoSection("f", "Feeds", function (verbose) {

             const feedTypes = {

                 "application/rss+xml": "RSS",

             }

 

             if (!verbose && nFeed)

         });

 

         this.addPageInfoSection("g", "General Info", function (verbose) {

 

             if (!verbose) {

                 if (pageSize[0])

                 yield lastMod;

                 return;

             }

         });

 

         this.addPageInfoSection("m", "Meta Tags", function (verbose) {

             // get meta tag data, sort and put into pageMeta[]

             let metaNodes = buffer.focusedFrame.document.getElementsByTagName("meta");

 

                         .sort(function (a, b) util.compareIgnoreCase(a[0], b[0]));

         });

 

         dactyl.commands["buffer.viewSource"] = function (event) {

             let elem = event.originalTarget;

         };

     },

 

     allFrames: function allFrames(win, focusedFirst) {

         let frames = [];

         (function rec(frame) {

                 frames.push(frame);

             Array.forEach(frame.frames, rec);

         })(win || content);

      * @returns {string}

      */

     get currentWord() Buffer.currentWord(this.focusedFrame),

 

     /**

      * Returns true if a scripts are allowed to focus the given input

     focusAllowed: function focusAllowed(elem) {

         if (elem instanceof Window && !Editor.getEditor(elem))

             return true;

         let doc = elem.ownerDocument || elem.document || elem;

     },

 

     /**

      */

     focusElement: function focusElement(elem) {

         let win = elem.ownerDocument && elem.ownerDocument.defaultView || elem;

         win.document.dactylFocusAllowed = true;

 

         if (isinstance(elem, [HTMLFrameElement, HTMLIFrameElement]))

     },

 

     /**

      * regular expressions, or with a @rel or @rev attribute matching

      * the given relation. Each frame is searched beginning with the

      * last link and progressing to the first, once checking for

      */

     followLink: function followLink(elem, where) {

         let doc = elem.ownerDocument;

         let { left: offsetX, top: offsetY } = elem.getBoundingClientRect();

 

         if (isinstance(elem, [HTMLFrameElement, HTMLIFrameElement]))

                     ctrlKey: ctrlKey, shiftKey: shiftKey, metaKey: ctrlKey

                 }));

             });

         });

     },

 

      * @property {nsISelectionController} The current document's selection

      *     controller.

      */

 

     /**

      * Opens the appropriate context menu for *elem*.

         try {

             window.urlSecurityCheck(uri.spec, doc.nodePrincipal);

 

                 onSubmit: function (path) {

                     let file = io.File(path);

                     if (file.exists() && file.isDirectory())

                              | persist.PERSIST_FLAGS_REPLACE_EXISTING_FILES;

 

         let downloadListener = new window.DownloadListener(window,

                                   null, null, null, persist));

 

         persist.progressListener = update(Object.create(downloadListener), {

 

                 return onStateChange.superapply(this, arguments);

         });

 

         persist.saveURI(uri, null, null, null, null, file);

      */

     findScrollable: function findScrollable(dir, horizontal) {

         function find(elem) {

                 elem = elem.parentNode;

             for (; elem && elem.parentNode instanceof Element; elem = elem.parentNode)

                 if (Buffer.isScrollable(elem, dir, horizontal))

                         doc.documentElement);

         }

         let doc = this.focusedFrame.document;

     },

 

     /**

         return win;

     },

 

     // TODO: allow callback for filtering out unwanted frames? User defined?

     /**

      * Shifts the focus to another frame within the buffer. Each buffer

      * @param {Node} elem The element to query.

      */

     showElementInfo: function showElementInfo(elem) {

     },

 

     /**

     showPageInfo: function showPageInfo(verbose, sections) {

         // Ctrl-g single line output

         if (!verbose) {

 

                 function (opt) template.map(buffer.pageInfo[opt].action(), util.identity, ", "),

                 ", ");

 

             if (bookmarkcache.isBookmarked(this.URL))

 

             let pageInfoText = <>{file.quote()} [{info}] {title}</>;

             dactyl.echo(pageInfoText, commandline.FORCE_SINGLELINE);

      * specified *url*. Either the default viewer or the configured external

      * editor is used.

      *

      * @default The current buffer.

      * @param {boolean} useExternalEditor View the source in the external editor.

      */

         let doc = this.focusedFrame.document;

 

             else

                 window.openDialog("chrome://global/content/viewSource.xul",

                                   "_blank", "all,dialog=no",

         }

         else {

             if (useExternalEditor)

             else {

                 const PREFIX = "view-source:";

                 if (url.indexOf(PREFIX) == 0)

                     url = url.substr(PREFIX.length);

      * immediately.

      *

      * @param {Document} doc The document to view.

      */

     viewSourceExternally: Class("viewSourceExternally",

         XPCOM([Ci.nsIWebProgressListener, Ci.nsISupportsWeakReference]), {

         init: function init(doc, callback) {

             this.callback = callable(callback) ? callback :

                 function (file, temp) {

                                               function () { temp && file.remove(false); });

                     return true;

                 };

             return null;

         },

 

                 try {

                     var ok = this.callback(this.file, true);

                 }

      * Adjusts the page zoom of the current buffer relative to the

      * current zoom level.

      *

      * @param {boolean} fullZoom If true, zoom all content of the page,

      */

     bumpZoomLevel: function bumpZoomLevel(steps, fullZoom) {

         if (fullZoom === undefined)

         this.setZoom(Math.round(values[i] * 100), fullZoom);

     },

 

     scrollTop: deprecated("buffer.scrollToPercent", function scrollTop() buffer.scrollToPercent(null, 0)),

     scrollBottom: deprecated("buffer.scrollToPercent", function scrollBottom() buffer.scrollToPercent(null, 100)),

     scrollStart: deprecated("buffer.scrollToPercent", function scrollStart() buffer.scrollToPercent(0, null)),

     scrollColumns: deprecated("buffer.scrollHorizontal", function scrollColumns(cols) buffer.scrollHorizontal("columns", cols)),

     scrollPages: deprecated("buffer.scrollHorizontal", function scrollPages(pages) buffer.scrollVertical("pages", pages)),

     scrollTo: deprecated("Buffer.scrollTo", function scrollTo(x, y) content.scrollTo(x, y)),

 }, {

     PageInfo: Struct("PageInfo", "name", "title", "action")

                         .localize("title"),

      *

      * @returns {string}

      */

         let selection = win.getSelection();

         if (selection.rangeCount == 0)

             return "";

 

         let range = selection.getRangeAt(0).cloneRange();

             let re = options.get("iskeyword").regexp;

             Editor.extendRange(range, true,  re, true);

             Editor.extendRange(range, false, re, true);

         }

         return util.domToString(range);

     },

 

 

         var names = [];

         if (node.title)

 

         if (node.alt)

 

         if (!isinstance(node, Document) && node.textContent)

 

         names.push([decodeURIComponent(url.replace(/.*?([^\/]*)\/*$/, "$1")), "File Name"]);

 

             elem.scrollLeft = left;

         if (top != null)

             elem.scrollTop = top;

     },

 

     /**

         else

             throw Error();

 

         let left = elem.dactylScrollDestX !== undefined ? elem.dactylScrollDestX : elem.scrollLeft;

         elem.dactylScrollDestX = undefined;

 

         Buffer.scrollTo(elem, left + number * increment, null);

     },

 

         else

             throw Error();

 

         let top = elem.dactylScrollDestY !== undefined ? elem.dactylScrollDestY : elem.scrollTop;

         elem.dactylScrollDestY = undefined;

 

         Buffer.scrollTo(elem, null, top + number * increment);

     },

 

     },

 

     openUploadPrompt: function openUploadPrompt(elem) {

             onSubmit: function onSubmit(path) {

                 let file = io.File(path);

                 dactyl.assert(file.exists());

 

                 // FIXME: arg handling is a bit of a mess, check for filename

                 dactyl.assert(!arg || arg[0] == ">" && !util.OS.isWindows,

 

                 prefs.withContext(function () {

                     if (arg) {

                         prefs.set("print.print_to_filename", io.File(arg.substr(1)).path);

                         dactyl.echomsg(_("print.toFile", arg.substr(1)));

                     }

                     else

                     level = Math.constrain(level, Buffer.ZOOM_MIN, Buffer.ZOOM_MAX);

                 }

                 else

 

                 buffer.setZoom(level, args.bang);

             },

             let styles = iter([s.title, []] for (s in values(buffer.alternateStyleSheets))).toObject();

 

             buffer.alternateStyleSheets.forEach(function (style) {

             });

 

             context.completions = [[title, href.join(", ")] for ([title, href] in Iterator(styles))];

         };

 

             let filter = context.filter.toLowerCase();

             let defItem = { parent: { getTitle: function () "" } };

             let tabGroups = {};

             tabs.getGroups();

                 let group = (tab.tabItem || tab._tabViewTabItem || defItem).parent || defItem.parent;

                     tabGroups[group.id] = [group.getTitle(), []];

                 group = tabGroups[group.id];

                 group[1].push([i, tab.linkedBrowser]);

             });

                 command: function () "tabs.select"

             };

             context.compare = CompletionContext.Sort.number;

 

             for (let [id, vals] in Iterator(tabGroups))

                 context.fork(id, 0, this, function (context, [name, browsers]) {

                             else if (i == tabs.index(tabs.alternate))

                                 indicator = "#";

 

                             let url = browser.contentDocument.location.href;

                             i = i + 1;

 

                             return {

                                 tab: tab,

                                 id: i - 1,

                                 url: url,

             function () { dactyl.clipboardWrite(buffer.uri.spec, true); });

 

         mappings.add([modes.NORMAL],

             function (args) { buffer.incrementURL(Math.max(args.count, 1)); },

             { count: true });

 

         mappings.add([modes.NORMAL],

             function (args) { buffer.incrementURL(-Math.max(args.count, 1)); },

             { count: true });

 

             "Go to parent directory",

             function (args) { buffer.climbUrlPath(Math.max(args.count, 1)); },

             { count: true });

 

             "Go to the root of the website",

             function () { buffer.climbUrlPath(-1); });

 

             },

             { count: true });

 

             function () { modes.push(modes.CARET); });

 

             "Stop loading the current web page",

             function () { ex.stop(); });

 

             "Scroll to the absolute right of the document",

             function () { buffer.scrollToPercent(100, null); });

 

             "Go to the top of the document",

             function (args) { buffer.scrollToPercent(null, args.count != null ? args.count : 0); },

             { count: true });

 

             "Go to the end of the document",

             function (args) { buffer.scrollToPercent(null, args.count != null ? args.count : 100); },

             { count: true });

             function (args) { buffer._scrollByScrollSize(args.count, false); },

             { count: true });

 

             "Scroll up a full page",

             function (args) { buffer.scrollVertical("pages", -Math.max(args.count, 1)); },

             { count: true });

 

             "Scroll down a full page",

             function (args) { buffer.scrollVertical("pages", Math.max(args.count, 1)); },

             { count: true });

 

             "Focus next frame",

             function (args) { buffer.shiftFrameFocus(Math.max(args.count, 1)); },

             { count: true });

 

             "Focus previous frame",

             function (args) { buffer.shiftFrameFocus(-Math.max(args.count, 1)); },

             { count: true });

 

             "Follow the link labeled 'next' or '>' if it exists",

             function (args) {

                 buffer.findLink("next", options["nextpattern"], (args.count || 1) - 1, true);

             },

             { count: true });

 

             "Follow the link labeled 'prev', 'previous' or '<' if it exists",

             function (args) {

                 buffer.findLink("previous", options["previouspattern"], (args.count || 1) - 1, true);

             },

             { count: true });

 

             "Toggle between rendered and source view",

             function () { buffer.viewSource(null, false); });

 

             "View source with an external editor",

             function () { buffer.viewSource(null, true); });

 

             "Focus last used input field",

             function (args) {

                 let elem = buffer.lastInputField;

 

                 if (args.count >= 1 || !elem || !events.isContentNode(elem)) {

 

                     let frames = buffer.allFrames(null, true);

 

                         if (isinstance(elem, [HTMLFrameElement, HTMLIFrameElement]))

                             return Editor.getEditor(elem.contentWindow);

 

                             return false;

 

                         let computedStyle = util.computedStyle(elem);

                         let rect = elem.getBoundingClientRect();

                         return computedStyle.visibility != "hidden" && computedStyle.display != "none" &&

                     });

 

                     dactyl.assert(elements.length > 0);

             },

             { count: true });

 

                 let url = dactyl.clipboardRead();

                 dactyl.assert(url, _("error.clipboardEmpty"));

             });

 

             "Open (put) a URL based on the current clipboard contents in the current buffer",

             function () {

             });

 

             "Open (put) a URL based on the current clipboard contents in a new buffer",

             function () {

             });

 

         // reloading

             "Reload the current web page",

             function () { tabs.reload(tabs.getTab(), false); });

 

             "Reload while skipping the cache",

             function () { tabs.reload(tabs.getTab(), true); });

 

             });

 

         // zooming

             "Enlarge text zoom of current web page",

             function (args) { buffer.zoomIn(Math.max(args.count, 1), false); },

             { count: true });

 

             "Enlarge text zoom of current web page by a larger amount",

             function (args) { buffer.zoomIn(Math.max(args.count, 1) * 3, false); },

             { count: true });

 

             "Reduce text zoom of current web page",

             function (args) { buffer.zoomOut(Math.max(args.count, 1), false); },

             { count: true });

 

             "Reduce text zoom of current web page by a larger amount",

             function (args) { buffer.zoomOut(Math.max(args.count, 1) * 3, false); },

             { count: true });

 

             "Set text zoom value of current web page",

             function (args) { buffer.setZoom(args.count > 1 ? args.count : 100, false); },

             { count: true });

 

             "Enlarge full zoom of current web page",

             function (args) { buffer.zoomIn(Math.max(args.count, 1), true); },

             { count: true });

 

             "Enlarge full zoom of current web page by a larger amount",

             function (args) { buffer.zoomIn(Math.max(args.count, 1) * 3, true); },

             { count: true });

 

             "Reduce full zoom of current web page",

             function (args) { buffer.zoomOut(Math.max(args.count, 1), true); },

             { count: true });

 

             "Reduce full zoom of current web page by a larger amount",

             function (args) { buffer.zoomOut(Math.max(args.count, 1) * 3, true); },

             { count: true });

 

             "Set full zoom value of current web page",

             function (args) { buffer.setZoom(args.count > 1 ? args.count : 100, true); },

             { count: true });

 

         // page info

             "Print the current file name",

             function () { buffer.showPageInfo(false); });

 

             "Print file information",

             function () { buffer.showPageInfo(true); });

     },

                 validator: function (value) RegExp(value)

             });

 

         options.add(["nextpattern"],

             "Patterns to use when guessing the next page in a document sequence",

             "regexplist", UTF8("'\\bnext\\b',^>$,^(>>|»)$,^(>|»),(>|»)$,'\\bmore\\b'"),

 

         options.add(["pageinfo", "pa"],

             "Define which sections are shown by the :pageinfo command",

             { get values() values(buffer.pageInfo).toObject() });

 

         options.add(["scroll", "scr"],

diff --git a/common/content/commandline.js b/common/content/commandline.js

                 return this.commandbar;

             }

         });

     },

     addElement: function addElement(obj) {

         const self = this;

                     if (obj.value != null)

                         return [obj.value[0],

                                 obj.get ? obj.get.call(this, elem) : elem.value]