@stackoverflow/stacks 1.6.2 → 1.6.4

package/lib/ts/controllers/s-popover.ts

@@ -1,8 +1,12 @@
-import { createPopper, Placement } from '@popperjs/core';
-import type * as Popper from '@popperjs/core';
+import { createPopper, Placement } from "@popperjs/core";
+import type * as Popper from "@popperjs/core";
 import * as Stacks from "../stacks";
 
-type OutsideClickBehavior = "always" | "never" | "if-in-viewport" | "after-dismissal";
+type OutsideClickBehavior =
+    | "always"
+    | "never"
+    | "if-in-viewport"
+    | "after-dismissal";
 
 export abstract class BasePopoverController extends Stacks.StacksController {
     private popper!: Popper.Instance;
@@ -31,7 +35,9 @@ export abstract class BasePopoverController extends Stacks.StacksController {
      */
     get isVisible() {
         const popoverElement = this.popoverElement;
-        return popoverElement ? popoverElement.classList.contains("is-visible") : false;
+        return popoverElement
+            ? popoverElement.classList.contains("is-visible")
+            : false;
     }
 
     /**
@@ -39,28 +45,43 @@ export abstract class BasePopoverController extends Stacks.StacksController {
      */
     get isInViewport() {
         const element = this.popoverElement;
-        if (!this.isVisible || !element) { return false; }
+        if (!this.isVisible || !element) {
+            return false;
+        }
 
         // From https://stackoverflow.com/a/5354536.  Theoretically, this could be calculated using Popper's detectOverflow function,
         // but it's unclear how to access that with our current configuration.
 
         const rect = element.getBoundingClientRect();
-        const viewHeight = Math.max(document.documentElement.clientHeight, window.innerHeight);
-        const viewWidth = Math.max(document.documentElement.clientWidth, window.innerWidth);
-
-        return rect.bottom > 0 && rect.top < viewHeight && rect.right > 0 && rect.left < viewWidth;
+        const viewHeight = Math.max(
+            document.documentElement.clientHeight,
+            window.innerHeight
+        );
+        const viewWidth = Math.max(
+            document.documentElement.clientWidth,
+            window.innerWidth
+        );
+
+        return (
+            rect.bottom > 0 &&
+            rect.top < viewHeight &&
+            rect.right > 0 &&
+            rect.left < viewWidth
+        );
     }
 
     protected get shouldHideOnOutsideClick() {
-        const hideBehavior = <OutsideClickBehavior>this.data.get("hide-on-outside-click");
+        const hideBehavior = <OutsideClickBehavior>(
+            this.data.get("hide-on-outside-click")
+        );
         switch (hideBehavior) {
             case "after-dismissal":
             case "never":
                 return false;
             case "if-in-viewport":
-                    return this.isInViewport;
+                return this.isInViewport;
             default:
-                    return true;
+                return true;
         }
     }
 
@@ -97,21 +118,27 @@ export abstract class BasePopoverController extends Stacks.StacksController {
     /**
      * Toggles the visibility of the popover
      */
-    toggle(dispatcher: Event|Element|null = null) {
+    toggle(dispatcher: Event | Element | null = null) {
         this.isVisible ? this.hide(dispatcher) : this.show(dispatcher);
     }
 
     /**
      * Shows the popover if not already visible
      */
-    show(dispatcher: Event|Element|null = null) {
-        if (this.isVisible) { return; }
+    show(dispatcher: Event | Element | null = null) {
+        if (this.isVisible) {
+            return;
+        }
 
         const dispatcherElement = this.getDispatcher(dispatcher);
 
-        if (this.triggerEvent("show", {
-            dispatcher: dispatcherElement
-        }).defaultPrevented) { return; }
+        if (
+            this.triggerEvent("show", {
+                dispatcher: dispatcherElement,
+            }).defaultPrevented
+        ) {
+            return;
+        }
 
         if (!this.popper) {
             this.initializePopper();
@@ -128,14 +155,20 @@ export abstract class BasePopoverController extends Stacks.StacksController {
     /**
      * Hides the popover if not already hidden
      */
-    hide(dispatcher: Event|Element|null = null) {
-        if (!this.isVisible) { return; }
+    hide(dispatcher: Event | Element | null = null) {
+        if (!this.isVisible) {
+            return;
+        }
 
         const dispatcherElement = this.getDispatcher(dispatcher);
 
-        if (this.triggerEvent("hide", {
-            dispatcher: dispatcherElement
-        }).defaultPrevented) { return; }
+        if (
+            this.triggerEvent("hide", {
+                dispatcher: dispatcherElement,
+            }).defaultPrevented
+        ) {
+            return;
+        }
 
         this.popoverElement.classList.remove("is-visible");
 
@@ -148,7 +181,10 @@ export abstract class BasePopoverController extends Stacks.StacksController {
         }
 
         // on first interaction, hide-on-outside-click with value "after-dismissal" reverts to the default behavior
-        if (<OutsideClickBehavior>this.data.get("hide-on-outside-click") === "after-dismissal") {
+        if (
+            <OutsideClickBehavior>this.data.get("hide-on-outside-click") ===
+            "after-dismissal"
+        ) {
             this.data.delete("hide-on-outside-click");
         }
 
@@ -158,20 +194,20 @@ export abstract class BasePopoverController extends Stacks.StacksController {
     /**
      * Binds document events for this popover and fires the shown event
      */
-    protected shown(dispatcher: Element|null = null) {
+    protected shown(dispatcher: Element | null = null) {
         this.bindDocumentEvents();
         this.triggerEvent("shown", {
-            dispatcher: dispatcher
+            dispatcher: dispatcher,
         });
     }
 
     /**
      * Unbinds document events for this popover and fires the hidden event
      */
-    protected hidden(dispatcher: Element|null = null) {
+    protected hidden(dispatcher: Element | null = null) {
         this.unbindDocumentEvents();
         this.triggerEvent("hidden", {
-            dispatcher: dispatcher
+            dispatcher: dispatcher,
         });
     }
 
@@ -187,21 +223,21 @@ export abstract class BasePopoverController extends Stacks.StacksController {
      */
     private initializePopper() {
         this.popper = createPopper(this.referenceElement, this.popoverElement, {
-            placement: this.data.get("placement") as Placement || "bottom",
+            placement: (this.data.get("placement") as Placement) || "bottom",
             modifiers: [
                 {
                     name: "offset",
                     options: {
                         offset: [0, 10], // The entire popover should be 10px away from the element
-                    }
+                    },
                 },
                 {
                     name: "arrow",
                     options: {
-                        element: ".s-popover--arrow"
+                        element: ".s-popover--arrow",
                     },
                 },
-            ]
+            ],
         });
     }
 
@@ -215,14 +251,21 @@ export abstract class BasePopoverController extends Stacks.StacksController {
 
         // if there is an alternative reference selector and that element exists, use it (and throw if it isn't found)
         if (referenceSelector) {
-            this.referenceElement = <HTMLElement>this.element.querySelector(referenceSelector);
+            this.referenceElement = <HTMLElement>(
+                this.element.querySelector(referenceSelector)
+            );
 
             if (!this.referenceElement) {
-                throw "Unable to find element by reference selector: " + referenceSelector;
+                throw (
+                    "Unable to find element by reference selector: " +
+                    referenceSelector
+                );
             }
         }
 
-        const popoverId = this.referenceElement.getAttribute(this.popoverSelectorAttribute);
+        const popoverId = this.referenceElement.getAttribute(
+            this.popoverSelectorAttribute
+        );
 
         let popoverElement: HTMLElement | null = null;
 
@@ -230,7 +273,7 @@ export abstract class BasePopoverController extends Stacks.StacksController {
         if (popoverId) {
             popoverElement = document.getElementById(popoverId);
 
-            if (!popoverElement){
+            if (!popoverElement) {
                 throw `[${this.popoverSelectorAttribute}="{POPOVER_ID}"] required`;
             }
         }
@@ -250,14 +293,14 @@ export abstract class BasePopoverController extends Stacks.StacksController {
      * Determines the correct dispatching element from a potential input
      * @param dispatcher The event or element to get the dispatcher from
      */
-    protected getDispatcher(dispatcher: Event|Element|null = null) : Element {
+    protected getDispatcher(
+        dispatcher: Event | Element | null = null
+    ): Element {
         if (dispatcher instanceof Event) {
             return <Element>dispatcher.target;
-        }
-        else if (dispatcher instanceof Element) {
+        } else if (dispatcher instanceof Element) {
             return dispatcher;
-        }
-        else {
+        } else {
             return this.element;
         }
     }
@@ -278,12 +321,12 @@ export class PopoverController extends BasePopoverController {
     protected popoverSelectorAttribute = "aria-controls";
 
     private boundHideOnOutsideClick!: (event: MouseEvent) => void;
-    private boundHideOnEscapePress!:  (event: KeyboardEvent) => void;
+    private boundHideOnEscapePress!: (event: KeyboardEvent) => void;
 
     /**
      * Toggles optional classes and accessibility attributes in addition to BasePopoverController.shown
      */
-    protected override shown(dispatcher: Element|null = null) {
+    protected override shown(dispatcher: Element | null = null) {
         this.toggleOptionalClasses(true);
         this.toggleAccessibilityAttributes(true);
         super.shown(dispatcher);
@@ -292,13 +335,12 @@ export class PopoverController extends BasePopoverController {
     /**
      * Toggles optional classes and accessibility attributes in addition to BasePopoverController.hidden
      */
-    protected override hidden(dispatcher: Element|null = null) {
+    protected override hidden(dispatcher: Element | null = null) {
         this.toggleOptionalClasses(false);
         this.toggleAccessibilityAttributes(false);
         super.hidden(dispatcher);
     }
 
-
     /**
      * Initializes accessibility attributes in addition to BasePopoverController.connect
      */
@@ -312,8 +354,10 @@ export class PopoverController extends BasePopoverController {
      * Binds global events to the document for hiding popovers on user interaction
      */
     protected bindDocumentEvents() {
-        this.boundHideOnOutsideClick = this.boundHideOnOutsideClick || this.hideOnOutsideClick.bind(this);
-        this.boundHideOnEscapePress = this.boundHideOnEscapePress || this.hideOnEscapePress.bind(this);
+        this.boundHideOnOutsideClick =
+            this.boundHideOnOutsideClick || this.hideOnOutsideClick.bind(this);
+        this.boundHideOnEscapePress =
+            this.boundHideOnEscapePress || this.hideOnEscapePress.bind(this);
 
         document.addEventListener("mousedown", this.boundHideOnOutsideClick);
         document.addEventListener("keyup", this.boundHideOnEscapePress);
@@ -335,10 +379,15 @@ export class PopoverController extends BasePopoverController {
         const target = <Node>e.target;
         // check if the document was clicked inside either the reference element or the popover itself
         // note: .contains also returns true if the node itself matches the target element
-        if (this.shouldHideOnOutsideClick && !this.referenceElement.contains(target) && !this.popoverElement.contains(target) && document.body.contains(target)) {
+        if (
+            this.shouldHideOnOutsideClick &&
+            !this.referenceElement.contains(target) &&
+            !this.popoverElement.contains(target) &&
+            document.body.contains(target)
+        ) {
             this.hide(e);
         }
-    };
+    }
 
     /**
      * Forces the popover to hide if the user presses escape while it, one of its childen, or the reference element are focused
@@ -357,7 +406,7 @@ export class PopoverController extends BasePopoverController {
         }
 
         this.hide(e);
-    };
+    }
 
     /**
      * Toggles all classes on the originating element based on the `class-toggle` data
@@ -380,7 +429,8 @@ export class PopoverController extends BasePopoverController {
      * @param {boolean=} show - A boolean indicating whether this is being triggered by a show or hide.
      */
     private toggleAccessibilityAttributes(show?: boolean) {
-        const expandedValue = show?.toString() || this.referenceElement.ariaExpanded || "false";
+        const expandedValue =
+            show?.toString() || this.referenceElement.ariaExpanded || "false";
         this.referenceElement.ariaExpanded = expandedValue;
         this.referenceElement.setAttribute("aria-expanded", expandedValue);
     }
@@ -447,21 +497,26 @@ export interface PopoverOptions {
  *                If the popover does not have a parent element, it will be inserted as a immediately after the reference element.
  * @param options an optional collection of options to use when configuring the popover.
  */
-export function attachPopover(element: Element, popover: Element | string, options?: PopoverOptions)
-    {
+export function attachPopover(
+    element: Element,
+    popover: Element | string,
+    options?: PopoverOptions
+) {
     const { referenceElement, popover: existingPopover } = getPopover(element);
 
     if (existingPopover) {
-        throw `element already has popover with id="${existingPopover.id}"`
+        throw `element already has popover with id="${existingPopover.id}"`;
     }
 
     if (!referenceElement) {
-        throw `element has invalid data-s-popover-reference-selector attribute`
+        throw `element has invalid data-s-popover-reference-selector attribute`;
     }
 
-    if (typeof popover === 'string') {
+    if (typeof popover === "string") {
         // eslint-disable-next-line no-unsanitized/method
-        const elements = document.createRange().createContextualFragment(popover).children;
+        const elements = document
+            .createRange()
+            .createContextualFragment(popover).children;
         if (elements.length !== 1) {
             throw "popover should contain a single element";
         }
@@ -471,7 +526,7 @@ export function attachPopover(element: Element, popover: Element | string, optio
     const existingId = referenceElement.getAttribute("aria-controls");
     let popoverId = popover.id;
 
-    if (!popover.classList.contains('s-popover')) {
+    if (!popover.classList.contains("s-popover")) {
         throw `popover should have the "s-popover" class but had class="${popover.className}"`;
     }
 
@@ -480,7 +535,8 @@ export function attachPopover(element: Element, popover: Element | string, optio
     }
 
     if (!popoverId) {
-        popoverId = "--stacks-s-popover-" + Math.random().toString(36).substring(2, 10);
+        popoverId =
+            "--stacks-s-popover-" + Math.random().toString(36).substring(2, 10);
         popover.id = popoverId;
     }
 
@@ -496,7 +552,10 @@ export function attachPopover(element: Element, popover: Element | string, optio
 
     if (options) {
         if (options.toggleOnClick) {
-            referenceElement.setAttribute("data-action", "click->s-popover#toggle");
+            referenceElement.setAttribute(
+                "data-action",
+                "click->s-popover#toggle"
+            );
         }
         if (options.placement) {
             element.setAttribute("data-s-popover-placement", options.placement);
@@ -513,7 +572,8 @@ export function attachPopover(element: Element, popover: Element | string, optio
  * @returns The popover that was attached to the element.
  */
 export function detachPopover(element: Element) {
-    const { isPopover, controller, referenceElement, popover } = getPopover(element);
+    const { isPopover, controller, referenceElement, popover } =
+        getPopover(element);
 
     // Hide the popover so its events fire.
     controller?.hide();
@@ -534,13 +594,13 @@ export function detachPopover(element: Element) {
 
 interface GetPopoverResult {
     /** indicates whether or not the element has s-popover in its `data-controller` class */
-    isPopover: boolean,
+    isPopover: boolean;
     /** element's existing `PopoverController` or null it it has not been configured yet */
-    controller: PopoverController | null,
+    controller: PopoverController | null;
     /** popover's reference element as would live in `referenceSelector` or null if invalid */
-    referenceElement: Element | null,
+    referenceElement: Element | null;
     /** popover currently associated with the controller, or null if one does not exist in the DOM */
-    popover: HTMLElement | null
+    popover: HTMLElement | null;
 }
 
 /**
@@ -549,11 +609,21 @@ interface GetPopoverResult {
  * @param element An element that may have `data-controller="s-popover"`.
  */
 function getPopover(element: Element): GetPopoverResult {
-    const isPopover = element.getAttribute("data-controller")?.includes("s-popover") || false;
-    const controller = Stacks.application.getControllerForElementAndIdentifier(element, "s-popover") as PopoverController;
-    const referenceSelector = element.getAttribute("data-s-popover-reference-selector");
-    const referenceElement = referenceSelector ? element.querySelector(referenceSelector) : element;
-    const popoverId = referenceElement ? referenceElement.getAttribute("aria-controls") : null;
+    const isPopover =
+        element.getAttribute("data-controller")?.includes("s-popover") || false;
+    const controller = Stacks.application.getControllerForElementAndIdentifier(
+        element,
+        "s-popover"
+    ) as PopoverController;
+    const referenceSelector = element.getAttribute(
+        "data-s-popover-reference-selector"
+    );
+    const referenceElement = referenceSelector
+        ? element.querySelector(referenceSelector)
+        : element;
+    const popoverId = referenceElement
+        ? referenceElement.getAttribute("aria-controls")
+        : null;
     const popover = popoverId ? document.getElementById(popoverId) : null;
     return { isPopover, controller, referenceElement, popover };
 }
@@ -564,12 +634,18 @@ function getPopover(element: Element): GetPopoverResult {
  * @param controllerName The name of the controller to add/remove
  * @param include Whether to add the controllerName value
  */
-function toggleController(el: Element, controllerName: string, include: boolean) {
-    const controllers = new Set(el.getAttribute('data-controller')?.split(/\s+/));
+function toggleController(
+    el: Element,
+    controllerName: string,
+    include: boolean
+) {
+    const controllers = new Set(
+        el.getAttribute("data-controller")?.split(/\s+/)
+    );
     if (include) {
         controllers.add(controllerName);
     } else {
         controllers.delete(controllerName);
     }
-    el.setAttribute('data-controller', Array.from(controllers).join(' '))
+    el.setAttribute("data-controller", Array.from(controllers).join(" "));
 }

package/lib/ts/controllers/s-table.ts

@@ -7,19 +7,29 @@ export class TableController extends Stacks.StacksController {
 
     setCurrentSort(headElem: Element, direction: "asc" | "desc" | "none") {
         if (["asc", "desc", "none"].indexOf(direction) < 0) {
-            throw "direction must be one of asc, desc, or none"
+            throw "direction must be one of asc, desc, or none";
         }
         // eslint-disable-next-line @typescript-eslint/no-this-alias
         const controller = this;
         this.columnTargets.forEach(function (target) {
             const isCurrrent = target === headElem;
 
-            target.classList.toggle("is-sorted", isCurrrent && direction !== "none");
+            target.classList.toggle(
+                "is-sorted",
+                isCurrrent && direction !== "none"
+            );
 
-            target.querySelectorAll(".js-sorting-indicator").forEach(function (icon) {
-                const visible = isCurrrent ? direction : "none";
-                icon.classList.toggle("d-none", !icon.classList.contains("js-sorting-indicator-" + visible));
-            });
+            target
+                .querySelectorAll(".js-sorting-indicator")
+                .forEach(function (icon) {
+                    const visible = isCurrrent ? direction : "none";
+                    icon.classList.toggle(
+                        "d-none",
+                        !icon.classList.contains(
+                            "js-sorting-indicator-" + visible
+                        )
+                    );
+                });
 
             if (!isCurrrent || direction === "none") {
                 controller.removeElementData(target, "sort-direction");
@@ -27,7 +37,7 @@ export class TableController extends Stacks.StacksController {
                 controller.setElementData(target, "sort-direction", direction);
             }
         });
-    };
+    }
 
     sort(evt: Event) {
         // eslint-disable-next-line @typescript-eslint/no-this-alias
@@ -42,7 +52,8 @@ export class TableController extends Stacks.StacksController {
         // the column slot number of the clicked header
         const colno = getCellSlot(colHead);
 
-        if (colno < 0) { // this shouldn't happen if the clicked element is actually a column head
+        if (colno < 0) {
+            // this shouldn't happen if the clicked element is actually a column head
             return;
         }
 
@@ -52,7 +63,8 @@ export class TableController extends Stacks.StacksController {
 
         // the default behavior when clicking a header is to sort by this column in ascending
         // direction, *unless* it is already sorted that way
-        const direction = this.getElementData(colHead, "sort-direction") === "asc" ? -1 : 1;
+        const direction =
+            this.getElementData(colHead, "sort-direction") === "asc" ? -1 : 1;
 
         const rows = Array.from(table.tBodies[0].rows);
 
@@ -82,9 +94,12 @@ export class TableController extends Stacks.StacksController {
             // unless the to-be-sorted-by value is explicitly provided on the element via this attribute,
             // the value we're using is the cell's text, trimmed of any whitespace
             const explicit = controller.getElementData(cell, "sort-val");
-            const d = typeof explicit === "string" ? explicit : cell.textContent!.trim();
+            const d =
+                typeof explicit === "string"
+                    ? explicit
+                    : cell.textContent?.trim() ?? "";
 
-            if ((d !== "") && (`${parseInt(d, 10)}` !== d)) {
+            if (d !== "" && `${parseInt(d, 10)}` !== d) {
                 anyNonInt = true;
             }
             data.push([d, index]);
@@ -94,7 +109,10 @@ export class TableController extends Stacks.StacksController {
         // having the lowest possible value (i.e. sorted to the top if ascending, bottom if descending)
         if (!anyNonInt) {
             data.forEach(function (tuple) {
-                tuple[0] = tuple[0] === "" ? Number.MIN_VALUE : parseInt(tuple[0] as string, 10);
+                tuple[0] =
+                    tuple[0] === ""
+                        ? Number.MIN_VALUE
+                        : parseInt(tuple[0] as string, 10);
             });
         }
 
@@ -117,7 +135,7 @@ export class TableController extends Stacks.StacksController {
         // this is the actual reordering of the table rows
         data.forEach(function (tup) {
             const row = rows[tup[1]];
-            row.parentElement!.removeChild(row);
+            row.parentElement?.removeChild(row);
             if (firstBottomRow) {
                 tbody.insertBefore(row, firstBottomRow);
             } else {
@@ -129,26 +147,35 @@ export class TableController extends Stacks.StacksController {
         // will cause sorting in descending direction
         this.setCurrentSort(colHead, direction === 1 ? "asc" : "desc");
     }
-
 }
 
-function buildIndex(section: HTMLTableSectionElement): HTMLTableCellElement[][] {
+function buildIndex(
+    section: HTMLTableSectionElement
+): HTMLTableCellElement[][] {
     const result = buildIndexOrGetCellSlot(section);
     if (!(result instanceof Array)) {
-        throw "shouldn't happen"
+        throw "shouldn't happen";
     }
     return result;
 }
 
 function getCellSlot(cell: HTMLTableCellElement): number {
-    if (!(cell.parentElement && cell.parentElement.parentElement instanceof HTMLTableSectionElement)) {
-        throw "invalid table"
+    if (
+        !(
+            cell.parentElement &&
+            cell.parentElement.parentElement instanceof HTMLTableSectionElement
+        )
+    ) {
+        throw "invalid table";
     }
-    const result = buildIndexOrGetCellSlot(cell.parentElement.parentElement, cell);
+    const result = buildIndexOrGetCellSlot(
+        cell.parentElement.parentElement,
+        cell
+    );
     if (typeof result !== "number") {
-        throw "shouldn't happen"
+        throw "shouldn't happen";
     }
-    return result
+    return result;
 }
 
 // Just because a <td> is the 4th *child* of its <tr> doesn't mean it belongs to the 4th *column*
@@ -166,9 +193,12 @@ function getCellSlot(cell: HTMLTableCellElement): number {
 //
 // If the second argument is given, it's a <td> or <th> that we're trying to find, and the algorithm
 // stops as soon as it has found it and the function returns its slot number.
-function buildIndexOrGetCellSlot(section: HTMLTableSectionElement, findCell?: HTMLTableCellElement) {
+function buildIndexOrGetCellSlot(
+    section: HTMLTableSectionElement,
+    findCell?: HTMLTableCellElement
+) {
     const index = [];
-    let curRow = section.children[0];
+    let curRow: Element | null = section.children[0];
 
     // the elements of these two arrays are synchronized; the first array contains table cell elements,
     // the second one contains a number that indicates for how many more rows this elements will
@@ -177,13 +207,22 @@ function buildIndexOrGetCellSlot(section: HTMLTableSectionElement, findCell?: HT
     const growingRowsLeft: number[] = [];
 
     // continue while we have actual <tr>'s left *or* we still have rowspan'ed elements that aren't done
-    while (curRow || growingRowsLeft.some(function (e) { return e !== 0; })) {
+    while (
+        curRow ||
+        growingRowsLeft.some(function (e) {
+            return e !== 0;
+        })
+    ) {
         const curIndexRow: HTMLTableCellElement[] = [];
         index.push(curIndexRow);
 
         let curSlot = 0;
         if (curRow) {
-            for (let curCellInd = 0; curCellInd < curRow.children.length; curCellInd++) {
+            for (
+                let curCellInd = 0;
+                curCellInd < curRow.children.length;
+                curCellInd++
+            ) {
                 while (growingRowsLeft[curSlot]) {
                     growingRowsLeft[curSlot]--;
                     curIndexRow[curSlot] = growing[curSlot];
@@ -191,7 +230,7 @@ function buildIndexOrGetCellSlot(section: HTMLTableSectionElement, findCell?: HT
                 }
                 const cell = curRow.children[curCellInd];
                 if (!(cell instanceof HTMLTableCellElement)) {
-                    throw "invalid table"
+                    throw "invalid table";
                 }
                 if (getComputedStyle(cell).display === "none") {
                     continue;
@@ -215,8 +254,10 @@ function buildIndexOrGetCellSlot(section: HTMLTableSectionElement, findCell?: HT
             curSlot++;
         }
         if (curRow) {
-            curRow = curRow.nextElementSibling!;
+            curRow = curRow.nextElementSibling;
         }
     }
-    return findCell ? -1 : index; /* if findCell was given but we end up here, that means it isn't in this section */
+    return findCell
+        ? -1
+        : index; /* if findCell was given but we end up here, that means it isn't in this section */
 }