|  | @@ -12,14 +12,14 @@
 | 
	
		
			
				|  |  |   * See the License for the specific language governing permissions and
 | 
	
		
			
				|  |  |   * limitations under the License.
 | 
	
		
			
				|  |  |   */
 | 
	
		
			
				|  |  | +/* eslint-disable no-var */
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  "use strict";
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -// eslint-disable-next-line no-var
 | 
	
		
			
				|  |  |  var FontInspector = (function FontInspectorClosure() {
 | 
	
		
			
				|  |  | -  let fonts;
 | 
	
		
			
				|  |  | -  let active = false;
 | 
	
		
			
				|  |  | -  const fontAttribute = "data-font-name";
 | 
	
		
			
				|  |  | +  var fonts;
 | 
	
		
			
				|  |  | +  var active = false;
 | 
	
		
			
				|  |  | +  var fontAttribute = "data-font-name";
 | 
	
		
			
				|  |  |    function removeSelection() {
 | 
	
		
			
				|  |  |      const divs = document.querySelectorAll(`span[${fontAttribute}]`);
 | 
	
		
			
				|  |  |      for (const div of divs) {
 | 
	
	
		
			
				|  | @@ -47,10 +47,10 @@ var FontInspector = (function FontInspectorClosure() {
 | 
	
		
			
				|  |  |      ) {
 | 
	
		
			
				|  |  |        return;
 | 
	
		
			
				|  |  |      }
 | 
	
		
			
				|  |  | -    const fontName = e.target.dataset.fontName;
 | 
	
		
			
				|  |  | -    const selects = document.getElementsByTagName("input");
 | 
	
		
			
				|  |  | -    for (let i = 0; i < selects.length; ++i) {
 | 
	
		
			
				|  |  | -      const select = selects[i];
 | 
	
		
			
				|  |  | +    var fontName = e.target.dataset.fontName;
 | 
	
		
			
				|  |  | +    var selects = document.getElementsByTagName("input");
 | 
	
		
			
				|  |  | +    for (var i = 0; i < selects.length; ++i) {
 | 
	
		
			
				|  |  | +      var select = selects[i];
 | 
	
		
			
				|  |  |        if (select.dataset.fontName !== fontName) {
 | 
	
		
			
				|  |  |          continue;
 | 
	
		
			
				|  |  |        }
 | 
	
	
		
			
				|  | @@ -66,8 +66,8 @@ var FontInspector = (function FontInspectorClosure() {
 | 
	
		
			
				|  |  |      panel: null,
 | 
	
		
			
				|  |  |      manager: null,
 | 
	
		
			
				|  |  |      init: function init(pdfjsLib) {
 | 
	
		
			
				|  |  | -      const panel = this.panel;
 | 
	
		
			
				|  |  | -      const tmp = document.createElement("button");
 | 
	
		
			
				|  |  | +      var panel = this.panel;
 | 
	
		
			
				|  |  | +      var tmp = document.createElement("button");
 | 
	
		
			
				|  |  |        tmp.addEventListener("click", resetSelection);
 | 
	
		
			
				|  |  |        tmp.textContent = "Refresh";
 | 
	
		
			
				|  |  |        panel.appendChild(tmp);
 | 
	
	
		
			
				|  | @@ -95,27 +95,27 @@ var FontInspector = (function FontInspectorClosure() {
 | 
	
		
			
				|  |  |      // FontInspector specific functions.
 | 
	
		
			
				|  |  |      fontAdded: function fontAdded(fontObj, url) {
 | 
	
		
			
				|  |  |        function properties(obj, list) {
 | 
	
		
			
				|  |  | -        const moreInfo = document.createElement("table");
 | 
	
		
			
				|  |  | -        for (let i = 0; i < list.length; i++) {
 | 
	
		
			
				|  |  | -          const tr = document.createElement("tr");
 | 
	
		
			
				|  |  | -          const td1 = document.createElement("td");
 | 
	
		
			
				|  |  | +        var moreInfo = document.createElement("table");
 | 
	
		
			
				|  |  | +        for (var i = 0; i < list.length; i++) {
 | 
	
		
			
				|  |  | +          var tr = document.createElement("tr");
 | 
	
		
			
				|  |  | +          var td1 = document.createElement("td");
 | 
	
		
			
				|  |  |            td1.textContent = list[i];
 | 
	
		
			
				|  |  |            tr.appendChild(td1);
 | 
	
		
			
				|  |  | -          const td2 = document.createElement("td");
 | 
	
		
			
				|  |  | +          var td2 = document.createElement("td");
 | 
	
		
			
				|  |  |            td2.textContent = obj[list[i]].toString();
 | 
	
		
			
				|  |  |            tr.appendChild(td2);
 | 
	
		
			
				|  |  |            moreInfo.appendChild(tr);
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  |          return moreInfo;
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  | -      const moreInfo = properties(fontObj, ["name", "type"]);
 | 
	
		
			
				|  |  | +      var moreInfo = properties(fontObj, ["name", "type"]);
 | 
	
		
			
				|  |  |        const fontName = fontObj.loadedName;
 | 
	
		
			
				|  |  | -      const font = document.createElement("div");
 | 
	
		
			
				|  |  | -      const name = document.createElement("span");
 | 
	
		
			
				|  |  | +      var font = document.createElement("div");
 | 
	
		
			
				|  |  | +      var name = document.createElement("span");
 | 
	
		
			
				|  |  |        name.textContent = fontName;
 | 
	
		
			
				|  |  | -      const download = document.createElement("a");
 | 
	
		
			
				|  |  | +      var download = document.createElement("a");
 | 
	
		
			
				|  |  |        if (url) {
 | 
	
		
			
				|  |  | -        url = /url\(['"]?([^)"']+)/.exec(url);
 | 
	
		
			
				|  |  | +        url = /url\(['"]?([^\)"']+)/.exec(url);
 | 
	
		
			
				|  |  |          download.href = url[1];
 | 
	
		
			
				|  |  |        } else if (fontObj.data) {
 | 
	
		
			
				|  |  |          download.href = URL.createObjectURL(
 | 
	
	
		
			
				|  | @@ -123,17 +123,17 @@ var FontInspector = (function FontInspectorClosure() {
 | 
	
		
			
				|  |  |          );
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  |        download.textContent = "Download";
 | 
	
		
			
				|  |  | -      const logIt = document.createElement("a");
 | 
	
		
			
				|  |  | +      var logIt = document.createElement("a");
 | 
	
		
			
				|  |  |        logIt.href = "";
 | 
	
		
			
				|  |  |        logIt.textContent = "Log";
 | 
	
		
			
				|  |  | -      logIt.addEventListener("click", function (event) {
 | 
	
		
			
				|  |  | +      logIt.addEventListener("click", function(event) {
 | 
	
		
			
				|  |  |          event.preventDefault();
 | 
	
		
			
				|  |  |          console.log(fontObj);
 | 
	
		
			
				|  |  |        });
 | 
	
		
			
				|  |  |        const select = document.createElement("input");
 | 
	
		
			
				|  |  |        select.setAttribute("type", "checkbox");
 | 
	
		
			
				|  |  |        select.dataset.fontName = fontName;
 | 
	
		
			
				|  |  | -      select.addEventListener("click", function () {
 | 
	
		
			
				|  |  | +      select.addEventListener("click", function() {
 | 
	
		
			
				|  |  |          selectFont(fontName, select.checked);
 | 
	
		
			
				|  |  |        });
 | 
	
		
			
				|  |  |        font.appendChild(select);
 | 
	
	
		
			
				|  | @@ -155,17 +155,15 @@ var FontInspector = (function FontInspectorClosure() {
 | 
	
		
			
				|  |  |    };
 | 
	
		
			
				|  |  |  })();
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -let opMap;
 | 
	
		
			
				|  |  | +var opMap;
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  // Manages all the page steppers.
 | 
	
		
			
				|  |  | -//
 | 
	
		
			
				|  |  | -// eslint-disable-next-line no-var
 | 
	
		
			
				|  |  |  var StepperManager = (function StepperManagerClosure() {
 | 
	
		
			
				|  |  | -  let steppers = [];
 | 
	
		
			
				|  |  | -  let stepperDiv = null;
 | 
	
		
			
				|  |  | -  let stepperControls = null;
 | 
	
		
			
				|  |  | -  let stepperChooser = null;
 | 
	
		
			
				|  |  | -  let breakPoints = Object.create(null);
 | 
	
		
			
				|  |  | +  var steppers = [];
 | 
	
		
			
				|  |  | +  var stepperDiv = null;
 | 
	
		
			
				|  |  | +  var stepperControls = null;
 | 
	
		
			
				|  |  | +  var stepperChooser = null;
 | 
	
		
			
				|  |  | +  var breakPoints = Object.create(null);
 | 
	
		
			
				|  |  |    return {
 | 
	
		
			
				|  |  |      // Properties/functions needed by PDFBug.
 | 
	
		
			
				|  |  |      id: "Stepper",
 | 
	
	
		
			
				|  | @@ -173,10 +171,10 @@ var StepperManager = (function StepperManagerClosure() {
 | 
	
		
			
				|  |  |      panel: null,
 | 
	
		
			
				|  |  |      manager: null,
 | 
	
		
			
				|  |  |      init: function init(pdfjsLib) {
 | 
	
		
			
				|  |  | -      const self = this;
 | 
	
		
			
				|  |  | +      var self = this;
 | 
	
		
			
				|  |  |        stepperControls = document.createElement("div");
 | 
	
		
			
				|  |  |        stepperChooser = document.createElement("select");
 | 
	
		
			
				|  |  | -      stepperChooser.addEventListener("change", function (event) {
 | 
	
		
			
				|  |  | +      stepperChooser.addEventListener("change", function(event) {
 | 
	
		
			
				|  |  |          self.selectStepper(this.value);
 | 
	
		
			
				|  |  |        });
 | 
	
		
			
				|  |  |        stepperControls.appendChild(stepperChooser);
 | 
	
	
		
			
				|  | @@ -188,7 +186,7 @@ var StepperManager = (function StepperManagerClosure() {
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |        opMap = Object.create(null);
 | 
	
		
			
				|  |  | -      for (const key in pdfjsLib.OPS) {
 | 
	
		
			
				|  |  | +      for (var key in pdfjsLib.OPS) {
 | 
	
		
			
				|  |  |          opMap[pdfjsLib.OPS[key]] = key;
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  |      },
 | 
	
	
		
			
				|  | @@ -201,17 +199,17 @@ var StepperManager = (function StepperManagerClosure() {
 | 
	
		
			
				|  |  |      active: false,
 | 
	
		
			
				|  |  |      // Stepper specific functions.
 | 
	
		
			
				|  |  |      create: function create(pageIndex) {
 | 
	
		
			
				|  |  | -      const debug = document.createElement("div");
 | 
	
		
			
				|  |  | +      var debug = document.createElement("div");
 | 
	
		
			
				|  |  |        debug.id = "stepper" + pageIndex;
 | 
	
		
			
				|  |  | -      debug.hidden = true;
 | 
	
		
			
				|  |  | +      debug.setAttribute("hidden", true);
 | 
	
		
			
				|  |  |        debug.className = "stepper";
 | 
	
		
			
				|  |  |        stepperDiv.appendChild(debug);
 | 
	
		
			
				|  |  | -      const b = document.createElement("option");
 | 
	
		
			
				|  |  | +      var b = document.createElement("option");
 | 
	
		
			
				|  |  |        b.textContent = "Page " + (pageIndex + 1);
 | 
	
		
			
				|  |  |        b.value = pageIndex;
 | 
	
		
			
				|  |  |        stepperChooser.appendChild(b);
 | 
	
		
			
				|  |  | -      const initBreakPoints = breakPoints[pageIndex] || [];
 | 
	
		
			
				|  |  | -      const stepper = new Stepper(debug, pageIndex, initBreakPoints);
 | 
	
		
			
				|  |  | +      var initBreakPoints = breakPoints[pageIndex] || [];
 | 
	
		
			
				|  |  | +      var stepper = new Stepper(debug, pageIndex, initBreakPoints);
 | 
	
		
			
				|  |  |        steppers.push(stepper);
 | 
	
		
			
				|  |  |        if (steppers.length === 1) {
 | 
	
		
			
				|  |  |          this.selectStepper(pageIndex, false);
 | 
	
	
		
			
				|  | @@ -219,18 +217,22 @@ var StepperManager = (function StepperManagerClosure() {
 | 
	
		
			
				|  |  |        return stepper;
 | 
	
		
			
				|  |  |      },
 | 
	
		
			
				|  |  |      selectStepper: function selectStepper(pageIndex, selectPanel) {
 | 
	
		
			
				|  |  | -      let i;
 | 
	
		
			
				|  |  | +      var i;
 | 
	
		
			
				|  |  |        pageIndex = pageIndex | 0;
 | 
	
		
			
				|  |  |        if (selectPanel) {
 | 
	
		
			
				|  |  |          this.manager.selectPanel(this);
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  |        for (i = 0; i < steppers.length; ++i) {
 | 
	
		
			
				|  |  | -        const stepper = steppers[i];
 | 
	
		
			
				|  |  | -        stepper.panel.hidden = stepper.pageIndex !== pageIndex;
 | 
	
		
			
				|  |  | +        var stepper = steppers[i];
 | 
	
		
			
				|  |  | +        if (stepper.pageIndex === pageIndex) {
 | 
	
		
			
				|  |  | +          stepper.panel.removeAttribute("hidden");
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          stepper.panel.setAttribute("hidden", true);
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  | -      const options = stepperChooser.options;
 | 
	
		
			
				|  |  | +      var options = stepperChooser.options;
 | 
	
		
			
				|  |  |        for (i = 0; i < options.length; ++i) {
 | 
	
		
			
				|  |  | -        const option = options[i];
 | 
	
		
			
				|  |  | +        var option = options[i];
 | 
	
		
			
				|  |  |          option.selected = (option.value | 0) === pageIndex;
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  |      },
 | 
	
	
		
			
				|  | @@ -241,11 +243,11 @@ var StepperManager = (function StepperManagerClosure() {
 | 
	
		
			
				|  |  |    };
 | 
	
		
			
				|  |  |  })();
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -// The stepper for each page's operatorList.
 | 
	
		
			
				|  |  | -const Stepper = (function StepperClosure() {
 | 
	
		
			
				|  |  | +// The stepper for each page's IRQueue.
 | 
	
		
			
				|  |  | +var Stepper = (function StepperClosure() {
 | 
	
		
			
				|  |  |    // Shorter way to create element and optionally set textContent.
 | 
	
		
			
				|  |  |    function c(tag, textContent) {
 | 
	
		
			
				|  |  | -    const d = document.createElement(tag);
 | 
	
		
			
				|  |  | +    var d = document.createElement(tag);
 | 
	
		
			
				|  |  |      if (textContent) {
 | 
	
		
			
				|  |  |        d.textContent = textContent;
 | 
	
		
			
				|  |  |      }
 | 
	
	
		
			
				|  | @@ -254,7 +256,7 @@ const Stepper = (function StepperClosure() {
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |    function simplifyArgs(args) {
 | 
	
		
			
				|  |  |      if (typeof args === "string") {
 | 
	
		
			
				|  |  | -      const MAX_STRING_LENGTH = 75;
 | 
	
		
			
				|  |  | +      var MAX_STRING_LENGTH = 75;
 | 
	
		
			
				|  |  |        return args.length <= MAX_STRING_LENGTH
 | 
	
		
			
				|  |  |          ? args
 | 
	
		
			
				|  |  |          : args.substring(0, MAX_STRING_LENGTH) + "...";
 | 
	
	
		
			
				|  | @@ -264,9 +266,10 @@ const Stepper = (function StepperClosure() {
 | 
	
		
			
				|  |  |      }
 | 
	
		
			
				|  |  |      if ("length" in args) {
 | 
	
		
			
				|  |  |        // array
 | 
	
		
			
				|  |  | -      const MAX_ITEMS = 10,
 | 
	
		
			
				|  |  | -        simpleArgs = [];
 | 
	
		
			
				|  |  | -      let i, ii;
 | 
	
		
			
				|  |  | +      var simpleArgs = [],
 | 
	
		
			
				|  |  | +        i,
 | 
	
		
			
				|  |  | +        ii;
 | 
	
		
			
				|  |  | +      var MAX_ITEMS = 10;
 | 
	
		
			
				|  |  |        for (i = 0, ii = Math.min(MAX_ITEMS, args.length); i < ii; i++) {
 | 
	
		
			
				|  |  |          simpleArgs.push(simplifyArgs(args[i]));
 | 
	
		
			
				|  |  |        }
 | 
	
	
		
			
				|  | @@ -275,32 +278,30 @@ const Stepper = (function StepperClosure() {
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  |        return simpleArgs;
 | 
	
		
			
				|  |  |      }
 | 
	
		
			
				|  |  | -    const simpleObj = {};
 | 
	
		
			
				|  |  | -    for (const key in args) {
 | 
	
		
			
				|  |  | +    var simpleObj = {};
 | 
	
		
			
				|  |  | +    for (var key in args) {
 | 
	
		
			
				|  |  |        simpleObj[key] = simplifyArgs(args[key]);
 | 
	
		
			
				|  |  |      }
 | 
	
		
			
				|  |  |      return simpleObj;
 | 
	
		
			
				|  |  |    }
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -  // eslint-disable-next-line no-shadow
 | 
	
		
			
				|  |  | -  class Stepper {
 | 
	
		
			
				|  |  | -    constructor(panel, pageIndex, initialBreakPoints) {
 | 
	
		
			
				|  |  | -      this.panel = panel;
 | 
	
		
			
				|  |  | -      this.breakPoint = 0;
 | 
	
		
			
				|  |  | -      this.nextBreakPoint = null;
 | 
	
		
			
				|  |  | -      this.pageIndex = pageIndex;
 | 
	
		
			
				|  |  | -      this.breakPoints = initialBreakPoints;
 | 
	
		
			
				|  |  | -      this.currentIdx = -1;
 | 
	
		
			
				|  |  | -      this.operatorListIdx = 0;
 | 
	
		
			
				|  |  | -    }
 | 
	
		
			
				|  |  | -
 | 
	
		
			
				|  |  | -    init(operatorList) {
 | 
	
		
			
				|  |  | -      const panel = this.panel;
 | 
	
		
			
				|  |  | -      const content = c("div", "c=continue, s=step");
 | 
	
		
			
				|  |  | -      const table = c("table");
 | 
	
		
			
				|  |  | +  function Stepper(panel, pageIndex, initialBreakPoints) {
 | 
	
		
			
				|  |  | +    this.panel = panel;
 | 
	
		
			
				|  |  | +    this.breakPoint = 0;
 | 
	
		
			
				|  |  | +    this.nextBreakPoint = null;
 | 
	
		
			
				|  |  | +    this.pageIndex = pageIndex;
 | 
	
		
			
				|  |  | +    this.breakPoints = initialBreakPoints;
 | 
	
		
			
				|  |  | +    this.currentIdx = -1;
 | 
	
		
			
				|  |  | +    this.operatorListIdx = 0;
 | 
	
		
			
				|  |  | +  }
 | 
	
		
			
				|  |  | +  Stepper.prototype = {
 | 
	
		
			
				|  |  | +    init: function init(operatorList) {
 | 
	
		
			
				|  |  | +      var panel = this.panel;
 | 
	
		
			
				|  |  | +      var content = c("div", "c=continue, s=step");
 | 
	
		
			
				|  |  | +      var table = c("table");
 | 
	
		
			
				|  |  |        content.appendChild(table);
 | 
	
		
			
				|  |  |        table.cellSpacing = 0;
 | 
	
		
			
				|  |  | -      const headerRow = c("tr");
 | 
	
		
			
				|  |  | +      var headerRow = c("tr");
 | 
	
		
			
				|  |  |        table.appendChild(headerRow);
 | 
	
		
			
				|  |  |        headerRow.appendChild(c("th", "Break"));
 | 
	
		
			
				|  |  |        headerRow.appendChild(c("th", "Idx"));
 | 
	
	
		
			
				|  | @@ -309,13 +310,12 @@ const Stepper = (function StepperClosure() {
 | 
	
		
			
				|  |  |        panel.appendChild(content);
 | 
	
		
			
				|  |  |        this.table = table;
 | 
	
		
			
				|  |  |        this.updateOperatorList(operatorList);
 | 
	
		
			
				|  |  | -    }
 | 
	
		
			
				|  |  | -
 | 
	
		
			
				|  |  | -    updateOperatorList(operatorList) {
 | 
	
		
			
				|  |  | -      const self = this;
 | 
	
		
			
				|  |  | +    },
 | 
	
		
			
				|  |  | +    updateOperatorList: function updateOperatorList(operatorList) {
 | 
	
		
			
				|  |  | +      var self = this;
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |        function cboxOnClick() {
 | 
	
		
			
				|  |  | -        const x = +this.dataset.idx;
 | 
	
		
			
				|  |  | +        var x = +this.dataset.idx;
 | 
	
		
			
				|  |  |          if (this.checked) {
 | 
	
		
			
				|  |  |            self.breakPoints.push(x);
 | 
	
		
			
				|  |  |          } else {
 | 
	
	
		
			
				|  | @@ -324,26 +324,26 @@ const Stepper = (function StepperClosure() {
 | 
	
		
			
				|  |  |          StepperManager.saveBreakPoints(self.pageIndex, self.breakPoints);
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -      const MAX_OPERATORS_COUNT = 15000;
 | 
	
		
			
				|  |  | +      var MAX_OPERATORS_COUNT = 15000;
 | 
	
		
			
				|  |  |        if (this.operatorListIdx > MAX_OPERATORS_COUNT) {
 | 
	
		
			
				|  |  |          return;
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -      const chunk = document.createDocumentFragment();
 | 
	
		
			
				|  |  | -      const operatorsToDisplay = Math.min(
 | 
	
		
			
				|  |  | +      var chunk = document.createDocumentFragment();
 | 
	
		
			
				|  |  | +      var operatorsToDisplay = Math.min(
 | 
	
		
			
				|  |  |          MAX_OPERATORS_COUNT,
 | 
	
		
			
				|  |  |          operatorList.fnArray.length
 | 
	
		
			
				|  |  |        );
 | 
	
		
			
				|  |  | -      for (let i = this.operatorListIdx; i < operatorsToDisplay; i++) {
 | 
	
		
			
				|  |  | -        const line = c("tr");
 | 
	
		
			
				|  |  | +      for (var i = this.operatorListIdx; i < operatorsToDisplay; i++) {
 | 
	
		
			
				|  |  | +        var line = c("tr");
 | 
	
		
			
				|  |  |          line.className = "line";
 | 
	
		
			
				|  |  |          line.dataset.idx = i;
 | 
	
		
			
				|  |  |          chunk.appendChild(line);
 | 
	
		
			
				|  |  | -        const checked = this.breakPoints.includes(i);
 | 
	
		
			
				|  |  | -        const args = operatorList.argsArray[i] || [];
 | 
	
		
			
				|  |  | +        var checked = this.breakPoints.includes(i);
 | 
	
		
			
				|  |  | +        var args = operatorList.argsArray[i] || [];
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -        const breakCell = c("td");
 | 
	
		
			
				|  |  | -        const cbox = c("input");
 | 
	
		
			
				|  |  | +        var breakCell = c("td");
 | 
	
		
			
				|  |  | +        var cbox = c("input");
 | 
	
		
			
				|  |  |          cbox.type = "checkbox";
 | 
	
		
			
				|  |  |          cbox.className = "points";
 | 
	
		
			
				|  |  |          cbox.checked = checked;
 | 
	
	
		
			
				|  | @@ -353,14 +353,14 @@ const Stepper = (function StepperClosure() {
 | 
	
		
			
				|  |  |          breakCell.appendChild(cbox);
 | 
	
		
			
				|  |  |          line.appendChild(breakCell);
 | 
	
		
			
				|  |  |          line.appendChild(c("td", i.toString()));
 | 
	
		
			
				|  |  | -        const fn = opMap[operatorList.fnArray[i]];
 | 
	
		
			
				|  |  | -        let decArgs = args;
 | 
	
		
			
				|  |  | +        var fn = opMap[operatorList.fnArray[i]];
 | 
	
		
			
				|  |  | +        var decArgs = args;
 | 
	
		
			
				|  |  |          if (fn === "showText") {
 | 
	
		
			
				|  |  | -          const glyphs = args[0];
 | 
	
		
			
				|  |  | -          const newArgs = [];
 | 
	
		
			
				|  |  | -          let str = [];
 | 
	
		
			
				|  |  | -          for (let j = 0; j < glyphs.length; j++) {
 | 
	
		
			
				|  |  | -            const glyph = glyphs[j];
 | 
	
		
			
				|  |  | +          var glyphs = args[0];
 | 
	
		
			
				|  |  | +          var newArgs = [];
 | 
	
		
			
				|  |  | +          var str = [];
 | 
	
		
			
				|  |  | +          for (var j = 0; j < glyphs.length; j++) {
 | 
	
		
			
				|  |  | +            var glyph = glyphs[j];
 | 
	
		
			
				|  |  |              if (typeof glyph === "object" && glyph !== null) {
 | 
	
		
			
				|  |  |                str.push(glyph.fontChar);
 | 
	
		
			
				|  |  |              } else {
 | 
	
	
		
			
				|  | @@ -380,54 +380,54 @@ const Stepper = (function StepperClosure() {
 | 
	
		
			
				|  |  |          line.appendChild(c("td", JSON.stringify(simplifyArgs(decArgs))));
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  |        if (operatorsToDisplay < operatorList.fnArray.length) {
 | 
	
		
			
				|  |  | -        const lastCell = c("td", "...");
 | 
	
		
			
				|  |  | +        line = c("tr");
 | 
	
		
			
				|  |  | +        var lastCell = c("td", "...");
 | 
	
		
			
				|  |  |          lastCell.colspan = 4;
 | 
	
		
			
				|  |  |          chunk.appendChild(lastCell);
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  |        this.operatorListIdx = operatorList.fnArray.length;
 | 
	
		
			
				|  |  |        this.table.appendChild(chunk);
 | 
	
		
			
				|  |  | -    }
 | 
	
		
			
				|  |  | -
 | 
	
		
			
				|  |  | -    getNextBreakPoint() {
 | 
	
		
			
				|  |  | -      this.breakPoints.sort(function (a, b) {
 | 
	
		
			
				|  |  | +    },
 | 
	
		
			
				|  |  | +    getNextBreakPoint: function getNextBreakPoint() {
 | 
	
		
			
				|  |  | +      this.breakPoints.sort(function(a, b) {
 | 
	
		
			
				|  |  |          return a - b;
 | 
	
		
			
				|  |  |        });
 | 
	
		
			
				|  |  | -      for (let i = 0; i < this.breakPoints.length; i++) {
 | 
	
		
			
				|  |  | +      for (var i = 0; i < this.breakPoints.length; i++) {
 | 
	
		
			
				|  |  |          if (this.breakPoints[i] > this.currentIdx) {
 | 
	
		
			
				|  |  |            return this.breakPoints[i];
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  |        return null;
 | 
	
		
			
				|  |  | -    }
 | 
	
		
			
				|  |  | -
 | 
	
		
			
				|  |  | -    breakIt(idx, callback) {
 | 
	
		
			
				|  |  | +    },
 | 
	
		
			
				|  |  | +    breakIt: function breakIt(idx, callback) {
 | 
	
		
			
				|  |  |        StepperManager.selectStepper(this.pageIndex, true);
 | 
	
		
			
				|  |  | -      this.currentIdx = idx;
 | 
	
		
			
				|  |  | -
 | 
	
		
			
				|  |  | -      const listener = evt => {
 | 
	
		
			
				|  |  | -        switch (evt.keyCode) {
 | 
	
		
			
				|  |  | +      var self = this;
 | 
	
		
			
				|  |  | +      var dom = document;
 | 
	
		
			
				|  |  | +      self.currentIdx = idx;
 | 
	
		
			
				|  |  | +      var listener = function(e) {
 | 
	
		
			
				|  |  | +        switch (e.keyCode) {
 | 
	
		
			
				|  |  |            case 83: // step
 | 
	
		
			
				|  |  | -            document.removeEventListener("keydown", listener);
 | 
	
		
			
				|  |  | -            this.nextBreakPoint = this.currentIdx + 1;
 | 
	
		
			
				|  |  | -            this.goTo(-1);
 | 
	
		
			
				|  |  | +            dom.removeEventListener("keydown", listener);
 | 
	
		
			
				|  |  | +            self.nextBreakPoint = self.currentIdx + 1;
 | 
	
		
			
				|  |  | +            self.goTo(-1);
 | 
	
		
			
				|  |  |              callback();
 | 
	
		
			
				|  |  |              break;
 | 
	
		
			
				|  |  |            case 67: // continue
 | 
	
		
			
				|  |  | -            document.removeEventListener("keydown", listener);
 | 
	
		
			
				|  |  | -            this.nextBreakPoint = this.getNextBreakPoint();
 | 
	
		
			
				|  |  | -            this.goTo(-1);
 | 
	
		
			
				|  |  | +            dom.removeEventListener("keydown", listener);
 | 
	
		
			
				|  |  | +            var breakPoint = self.getNextBreakPoint();
 | 
	
		
			
				|  |  | +            self.nextBreakPoint = breakPoint;
 | 
	
		
			
				|  |  | +            self.goTo(-1);
 | 
	
		
			
				|  |  |              callback();
 | 
	
		
			
				|  |  |              break;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  |        };
 | 
	
		
			
				|  |  | -      document.addEventListener("keydown", listener);
 | 
	
		
			
				|  |  | -      this.goTo(idx);
 | 
	
		
			
				|  |  | -    }
 | 
	
		
			
				|  |  | -
 | 
	
		
			
				|  |  | -    goTo(idx) {
 | 
	
		
			
				|  |  | -      const allRows = this.panel.getElementsByClassName("line");
 | 
	
		
			
				|  |  | -      for (let x = 0, xx = allRows.length; x < xx; ++x) {
 | 
	
		
			
				|  |  | -        const row = allRows[x];
 | 
	
		
			
				|  |  | +      dom.addEventListener("keydown", listener);
 | 
	
		
			
				|  |  | +      self.goTo(idx);
 | 
	
		
			
				|  |  | +    },
 | 
	
		
			
				|  |  | +    goTo: function goTo(idx) {
 | 
	
		
			
				|  |  | +      var allRows = this.panel.getElementsByClassName("line");
 | 
	
		
			
				|  |  | +      for (var x = 0, xx = allRows.length; x < xx; ++x) {
 | 
	
		
			
				|  |  | +        var row = allRows[x];
 | 
	
		
			
				|  |  |          if ((row.dataset.idx | 0) === idx) {
 | 
	
		
			
				|  |  |            row.style.backgroundColor = "rgb(251,250,207)";
 | 
	
		
			
				|  |  |            row.scrollIntoView();
 | 
	
	
		
			
				|  | @@ -435,21 +435,20 @@ const Stepper = (function StepperClosure() {
 | 
	
		
			
				|  |  |            row.style.backgroundColor = null;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  | -    }
 | 
	
		
			
				|  |  | -  }
 | 
	
		
			
				|  |  | +    },
 | 
	
		
			
				|  |  | +  };
 | 
	
		
			
				|  |  |    return Stepper;
 | 
	
		
			
				|  |  |  })();
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -// eslint-disable-next-line no-var
 | 
	
		
			
				|  |  |  var Stats = (function Stats() {
 | 
	
		
			
				|  |  | -  let stats = [];
 | 
	
		
			
				|  |  | +  var stats = [];
 | 
	
		
			
				|  |  |    function clear(node) {
 | 
	
		
			
				|  |  |      while (node.hasChildNodes()) {
 | 
	
		
			
				|  |  |        node.removeChild(node.lastChild);
 | 
	
		
			
				|  |  |      }
 | 
	
		
			
				|  |  |    }
 | 
	
		
			
				|  |  |    function getStatIndex(pageNumber) {
 | 
	
		
			
				|  |  | -    for (let i = 0, ii = stats.length; i < ii; ++i) {
 | 
	
		
			
				|  |  | +    for (var i = 0, ii = stats.length; i < ii; ++i) {
 | 
	
		
			
				|  |  |        if (stats[i].pageNumber === pageNumber) {
 | 
	
		
			
				|  |  |          return i;
 | 
	
		
			
				|  |  |        }
 | 
	
	
		
			
				|  | @@ -470,27 +469,27 @@ var Stats = (function Stats() {
 | 
	
		
			
				|  |  |        if (!stat) {
 | 
	
		
			
				|  |  |          return;
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  | -      const statsIndex = getStatIndex(pageNumber);
 | 
	
		
			
				|  |  | +      var statsIndex = getStatIndex(pageNumber);
 | 
	
		
			
				|  |  |        if (statsIndex !== false) {
 | 
	
		
			
				|  |  |          const b = stats[statsIndex];
 | 
	
		
			
				|  |  |          this.panel.removeChild(b.div);
 | 
	
		
			
				|  |  |          stats.splice(statsIndex, 1);
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  | -      const wrapper = document.createElement("div");
 | 
	
		
			
				|  |  | +      var wrapper = document.createElement("div");
 | 
	
		
			
				|  |  |        wrapper.className = "stats";
 | 
	
		
			
				|  |  | -      const title = document.createElement("div");
 | 
	
		
			
				|  |  | +      var title = document.createElement("div");
 | 
	
		
			
				|  |  |        title.className = "title";
 | 
	
		
			
				|  |  |        title.textContent = "Page: " + pageNumber;
 | 
	
		
			
				|  |  | -      const statsDiv = document.createElement("div");
 | 
	
		
			
				|  |  | +      var statsDiv = document.createElement("div");
 | 
	
		
			
				|  |  |        statsDiv.textContent = stat.toString();
 | 
	
		
			
				|  |  |        wrapper.appendChild(title);
 | 
	
		
			
				|  |  |        wrapper.appendChild(statsDiv);
 | 
	
		
			
				|  |  |        stats.push({ pageNumber, div: wrapper });
 | 
	
		
			
				|  |  | -      stats.sort(function (a, b) {
 | 
	
		
			
				|  |  | +      stats.sort(function(a, b) {
 | 
	
		
			
				|  |  |          return a.pageNumber - b.pageNumber;
 | 
	
		
			
				|  |  |        });
 | 
	
		
			
				|  |  |        clear(this.panel);
 | 
	
		
			
				|  |  | -      for (let i = 0, ii = stats.length; i < ii; ++i) {
 | 
	
		
			
				|  |  | +      for (var i = 0, ii = stats.length; i < ii; ++i) {
 | 
	
		
			
				|  |  |          this.panel.appendChild(stats[i].div);
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  |      },
 | 
	
	
		
			
				|  | @@ -503,27 +502,30 @@ var Stats = (function Stats() {
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |  // Manages all the debugging tools.
 | 
	
		
			
				|  |  |  window.PDFBug = (function PDFBugClosure() {
 | 
	
		
			
				|  |  | -  const panelWidth = 300;
 | 
	
		
			
				|  |  | -  const buttons = [];
 | 
	
		
			
				|  |  | -  let activePanel = null;
 | 
	
		
			
				|  |  | +  var panelWidth = 300;
 | 
	
		
			
				|  |  | +  var buttons = [];
 | 
	
		
			
				|  |  | +  var activePanel = null;
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |    return {
 | 
	
		
			
				|  |  |      tools: [FontInspector, StepperManager, Stats],
 | 
	
		
			
				|  |  |      enable(ids) {
 | 
	
		
			
				|  |  | -      const all = ids.length === 1 && ids[0] === "all";
 | 
	
		
			
				|  |  | -      const tools = this.tools;
 | 
	
		
			
				|  |  | -      for (let i = 0; i < tools.length; ++i) {
 | 
	
		
			
				|  |  | -        const tool = tools[i];
 | 
	
		
			
				|  |  | +      var all = false,
 | 
	
		
			
				|  |  | +        tools = this.tools;
 | 
	
		
			
				|  |  | +      if (ids.length === 1 && ids[0] === "all") {
 | 
	
		
			
				|  |  | +        all = true;
 | 
	
		
			
				|  |  | +      }
 | 
	
		
			
				|  |  | +      for (var i = 0; i < tools.length; ++i) {
 | 
	
		
			
				|  |  | +        var tool = tools[i];
 | 
	
		
			
				|  |  |          if (all || ids.includes(tool.id)) {
 | 
	
		
			
				|  |  |            tool.enabled = true;
 | 
	
		
			
				|  |  |          }
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  |        if (!all) {
 | 
	
		
			
				|  |  |          // Sort the tools by the order they are enabled.
 | 
	
		
			
				|  |  | -        tools.sort(function (a, b) {
 | 
	
		
			
				|  |  | -          let indexA = ids.indexOf(a.id);
 | 
	
		
			
				|  |  | +        tools.sort(function(a, b) {
 | 
	
		
			
				|  |  | +          var indexA = ids.indexOf(a.id);
 | 
	
		
			
				|  |  |            indexA = indexA < 0 ? tools.length : indexA;
 | 
	
		
			
				|  |  | -          let indexB = ids.indexOf(b.id);
 | 
	
		
			
				|  |  | +          var indexB = ids.indexOf(b.id);
 | 
	
		
			
				|  |  |            indexB = indexB < 0 ? tools.length : indexB;
 | 
	
		
			
				|  |  |            return indexA - indexB;
 | 
	
		
			
				|  |  |          });
 | 
	
	
		
			
				|  | @@ -539,14 +541,14 @@ window.PDFBug = (function PDFBugClosure() {
 | 
	
		
			
				|  |  |         *    Panel
 | 
	
		
			
				|  |  |         *    ...
 | 
	
		
			
				|  |  |         */
 | 
	
		
			
				|  |  | -      const ui = document.createElement("div");
 | 
	
		
			
				|  |  | +      var ui = document.createElement("div");
 | 
	
		
			
				|  |  |        ui.id = "PDFBug";
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -      const controls = document.createElement("div");
 | 
	
		
			
				|  |  | +      var controls = document.createElement("div");
 | 
	
		
			
				|  |  |        controls.setAttribute("class", "controls");
 | 
	
		
			
				|  |  |        ui.appendChild(controls);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | -      const panels = document.createElement("div");
 | 
	
		
			
				|  |  | +      var panels = document.createElement("div");
 | 
	
		
			
				|  |  |        panels.setAttribute("class", "panels");
 | 
	
		
			
				|  |  |        ui.appendChild(panels);
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -554,17 +556,17 @@ window.PDFBug = (function PDFBugClosure() {
 | 
	
		
			
				|  |  |        container.style.right = panelWidth + "px";
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  |        // Initialize all the debugging tools.
 | 
	
		
			
				|  |  | -      const tools = this.tools;
 | 
	
		
			
				|  |  | -      const self = this;
 | 
	
		
			
				|  |  | -      for (let i = 0; i < tools.length; ++i) {
 | 
	
		
			
				|  |  | -        const tool = tools[i];
 | 
	
		
			
				|  |  | -        const panel = document.createElement("div");
 | 
	
		
			
				|  |  | -        const panelButton = document.createElement("button");
 | 
	
		
			
				|  |  | +      var tools = this.tools;
 | 
	
		
			
				|  |  | +      var self = this;
 | 
	
		
			
				|  |  | +      for (var i = 0; i < tools.length; ++i) {
 | 
	
		
			
				|  |  | +        var tool = tools[i];
 | 
	
		
			
				|  |  | +        var panel = document.createElement("div");
 | 
	
		
			
				|  |  | +        var panelButton = document.createElement("button");
 | 
	
		
			
				|  |  |          panelButton.textContent = tool.name;
 | 
	
		
			
				|  |  |          panelButton.addEventListener(
 | 
	
		
			
				|  |  |            "click",
 | 
	
		
			
				|  |  | -          (function (selected) {
 | 
	
		
			
				|  |  | -            return function (event) {
 | 
	
		
			
				|  |  | +          (function(selected) {
 | 
	
		
			
				|  |  | +            return function(event) {
 | 
	
		
			
				|  |  |                event.preventDefault();
 | 
	
		
			
				|  |  |                self.selectPanel(selected);
 | 
	
		
			
				|  |  |              };
 | 
	
	
		
			
				|  | @@ -590,7 +592,7 @@ window.PDFBug = (function PDFBugClosure() {
 | 
	
		
			
				|  |  |        this.selectPanel(0);
 | 
	
		
			
				|  |  |      },
 | 
	
		
			
				|  |  |      cleanup() {
 | 
	
		
			
				|  |  | -      for (let i = 0, ii = this.tools.length; i < ii; i++) {
 | 
	
		
			
				|  |  | +      for (var i = 0, ii = this.tools.length; i < ii; i++) {
 | 
	
		
			
				|  |  |          if (this.tools[i].enabled) {
 | 
	
		
			
				|  |  |            this.tools[i].cleanup();
 | 
	
		
			
				|  |  |          }
 | 
	
	
		
			
				|  | @@ -604,12 +606,17 @@ window.PDFBug = (function PDFBugClosure() {
 | 
	
		
			
				|  |  |          return;
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  |        activePanel = index;
 | 
	
		
			
				|  |  | -      const tools = this.tools;
 | 
	
		
			
				|  |  | -      for (let j = 0; j < tools.length; ++j) {
 | 
	
		
			
				|  |  | -        const isActive = j === index;
 | 
	
		
			
				|  |  | -        buttons[j].classList.toggle("active", isActive);
 | 
	
		
			
				|  |  | -        tools[j].active = isActive;
 | 
	
		
			
				|  |  | -        tools[j].panel.hidden = !isActive;
 | 
	
		
			
				|  |  | +      var tools = this.tools;
 | 
	
		
			
				|  |  | +      for (var j = 0; j < tools.length; ++j) {
 | 
	
		
			
				|  |  | +        if (j === index) {
 | 
	
		
			
				|  |  | +          buttons[j].setAttribute("class", "active");
 | 
	
		
			
				|  |  | +          tools[j].active = true;
 | 
	
		
			
				|  |  | +          tools[j].panel.removeAttribute("hidden");
 | 
	
		
			
				|  |  | +        } else {
 | 
	
		
			
				|  |  | +          buttons[j].setAttribute("class", "");
 | 
	
		
			
				|  |  | +          tools[j].active = false;
 | 
	
		
			
				|  |  | +          tools[j].panel.setAttribute("hidden", "true");
 | 
	
		
			
				|  |  | +        }
 | 
	
		
			
				|  |  |        }
 | 
	
		
			
				|  |  |      },
 | 
	
		
			
				|  |  |    };
 |