@khanacademy/perseus-linter 0.2.4 → 0.3.0

package/dist/tree-transformer.js.flow

@@ -0,0 +1,253 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+/**
+ * TreeTransformer is a class for traversing and transforming trees.  Create a
+ * TreeTransformer by passing the root node of the tree to the
+ * constructor. Then traverse that tree by calling the traverse() method. The
+ * argument to traverse() is a callback function that will be called once for
+ * each node in the tree. This is a post-order depth-first traversal: the
+ * callback is not called on the a way down, but on the way back up. That is,
+ * the children of a node are traversed before the node itself is.
+ *
+ * The traversal callback function is passed three arguments, the node being
+ * traversed, a TraversalState object, and the concatentated text content of
+ * the node and all of its descendants. The TraversalState object is the most
+ * most interesting argument: it has methods for querying the ancestors and
+ * siblings of the node, and for deleting or replacing the node. These
+ * transformation methods are why this class is a tree transformer and not
+ * just a tree traverser.
+ *
+ * A typical tree traversal looks like this:
+ *
+ *   new TreeTransformer(root).traverse((node, state, content) => {
+ *       let parent = state.parent();
+ *       let previous = state.previousSibling();
+ *       // etc.
+ *   });
+ *
+ * The traverse() method descends through nodes and arrays of nodes and calls
+ * the traverse callback on each node on the way back up to the root of the
+ * tree. (Note that it only calls the callback on the nodes themselves, not
+ * any arrays that contain nodes.) A node is loosely defined as any object
+ * with a string-valued `type` property. Objects that do not have a type
+ * property are assumed to not be part of the tree and are not traversed. When
+ * traversing an array, all elements of the array are examined, and any that
+ * are nodes or arrays are recursively traversed. When traversing a node, all
+ * properties of the object are examined and any node or array values are
+ * recursively traversed.  In typical parse trees, the children of a node are
+ * in a `children` or `content` array, but this class is designed to handle
+ * more general trees.  The Perseus markdown parser, for example, produces
+ * nodes of type "table" that have children in the `header` and `cells`
+ * properties.
+ *
+ * CAUTION: the traverse() method does not make any attempt to detect
+ * cycles. If you call it on a cyclic graph instead of a tree, it will cause
+ * infinite recursion (or, more likely, a stack overflow).
+ *
+ * TODO(davidflanagan): it probably wouldn't be hard to detect cycles: when
+ * pushing a new node onto the containers stack we could just check that it
+ * isn't already there.
+ *
+ * If a node has a text-valued `content` property, it is taken to be the
+ * plain-text content of the node. The traverse() method concatenates these
+ * content strings and passes them to the traversal callback for each
+ * node. This means that the callback has access the full text content of its
+ * node and all of the nodes descendants.
+ *
+ * See the TraversalState class for more information on what information and
+ * methods are available to the traversal callback.
+ */
+export type TreeNode = {|
+  type: string,
+|};
+export type TraversalCallback = (
+  node: TreeNode,
+  state: TraversalState,
+  content: string
+) => void;
+declare export default class TreeTransformer {
+  root: TreeNode;
+  constructor(root: TreeNode): this;
+  static isNode(n: any): boolean;
+  static isTextNode(n: any): boolean;
+  traverse(f: TraversalCallback): void;
+  _traverse(
+    n: TreeNode | Array<TreeNode>,
+    state: TraversalState,
+    f: TraversalCallback
+  ): string;
+}
+/**
+ * This class represents the state of a tree traversal. An instance is created
+ * by the traverse() method of the TreeTransformer class to maintain the state
+ * for that traversal, and the instance is passed to the traversal callback
+ * function for each node that is traversed. This class is not intended to be
+ * instantiated directly, but is exported so that its type can be used for
+ * Flow annotaions.
+ */
+declare export class TraversalState {
+  root: TreeNode;
+  _currentNode: TreeNode | null | void;
+  _containers: Stack<TreeNode | Array<TreeNode>>;
+  _indexes: Stack<string | number>;
+  _ancestors: Stack<TreeNode>;
+  constructor(root: TreeNode): this;
+
+  /**
+   * Return the current node in the traversal. Any time the traversal
+   * callback is called, this method will return the name value as the
+   * first argument to the callback.
+   */
+  currentNode(): TreeNode;
+
+  /**
+   * Return the parent of the current node, if there is one, or null.
+   */
+  parent(): TreeNode | null | void;
+
+  /**
+   * Return an array of ancestor nodes. The first element of this array is
+   * the same as this.parent() and the last element is the root node. If we
+   * are currently at the root node, the the returned array will be empty.
+   * This method makes a copy of the internal state, so modifications to the
+   * returned array have no effect on the traversal.
+   */
+  ancestors(): $ReadOnlyArray<TreeNode>;
+
+  /**
+   * Return the next sibling of this node, if it has one, or null otherwise.
+   */
+  nextSibling(): TreeNode | null | void;
+
+  /**
+   * Return the previous sibling of this node, if it has one, or null
+   * otherwise.
+   */
+  previousSibling(): TreeNode | null | void;
+
+  /**
+   * Remove the next sibling node (if there is one) from the tree.  Returns
+   * the removed sibling or null. This method makes it easy to traverse a
+   * tree and concatenate adjacent text nodes into a single node.
+   */
+  removeNextSibling(): TreeNode | null | void;
+
+  /**
+   * Replace the current node in the tree with the specified nodes.  If no
+   * nodes are passed, this is a node deletion. If one node (or array) is
+   * passed, this is a 1-for-1 replacement. If more than one node is passed
+   * then this is a combination of deletion and insertion.  The new node or
+   * nodes will not be traversed, so this method can safely be used to
+   * reparent the current node node beneath a new parent.
+   *
+   * This method throws an error if you attempt to replace the root node of
+   * the tree.
+   */
+  replace(...replacements: $ReadOnlyArray<TreeNode>): void;
+
+  /**
+   * Returns true if the current node has a previous sibling and false
+   * otherwise. If this method returns false, then previousSibling() will
+   * return null, and goToPreviousSibling() will throw an error.
+   */
+  hasPreviousSibling(): boolean;
+
+  /**
+   * Modify this traversal state object to have the state it would have had
+   * when visiting the previous sibling. Note that you may want to use
+   * clone() to make a copy before modifying the state object like this.
+   * This mutator method is not typically used during ordinary tree
+   * traversals, but is used by the Selector class for matching multi-node
+   * selectors.
+   */
+  goToPreviousSibling(): void;
+
+  /**
+   * Returns true if the current node has an ancestor and false otherwise.
+   * If this method returns false, then the parent() method will return
+   * null and goToParent() will throw an error
+   */
+  hasParent(): boolean;
+
+  /**
+   * Modify this object to look like it will look when we (later) visit the
+   * parent node of this node. You should not modify the instance passed to
+   * the tree traversal callback. Instead, make a copy with the clone()
+   * method and modify that.  This mutator method is not typically used
+   * during ordinary tree traversals, but is used by the Selector class for
+   * matching multi-node selectors that involve parent and ancestor
+   * selectors.
+   */
+  goToParent(): void;
+
+  /**
+   * Return a new TraversalState object that is a copy of this one.
+   * This method is useful in conjunction with the mutating methods
+   * goToParent() and goToPreviousSibling().
+   */
+  clone(): TraversalState;
+
+  /**
+   * Returns true if this TraversalState object is equal to that
+   * TraversalState object, or false otherwise. This method exists
+   * primarily for use by our unit tests.
+   */
+  equals(that: TraversalState): boolean;
+}
+/**
+ * This class is an internal utility that just treats an array as a stack
+ * and gives us a top() method so we don't have to write expressions like
+ * `ancestors[ancestors.length-1]`. The values() method automatically
+ * copies the internal array so we don't have to worry about client code
+ * modifying our internal stacks. The use of this Stack abstraction makes
+ * the TraversalState class simpler in a number of places.
+ */
+declare class Stack<T> {
+  stack: Array<T>;
+  constructor(array?: $ReadOnlyArray<T> | null): this;
+
+  /**
+   * Push a value onto the stack.
+   */
+  push(v: T): void;
+
+  /**
+   * Pop a value off of the stack.
+   */
+  pop(): T;
+
+  /**
+   * Return the top value of the stack without popping it.
+   */
+  top(): T;
+
+  /**
+   * Return a copy of the stack as an array
+   */
+  values(): $ReadOnlyArray<T>;
+
+  /**
+   * Return the number of elements in the stack
+   */
+  size(): number;
+
+  /**
+   * Return a string representation of the stack
+   */
+  toString(): string;
+
+  /**
+   * Return a shallow copy of the stack
+   */
+  clone(): Stack<T>;
+
+  /**
+   * Compare this stack to another and return true if the contents of
+   * the two arrays are the same.
+   */
+  equals(that: Stack<T>): boolean;
+}

package/dist/types.d.ts

@@ -0,0 +1,6 @@
+export type LinterContextProps = {
+    contentType: string;
+    highlightLint: boolean;
+    paths: ReadonlyArray<string>;
+    stack: ReadonlyArray<string>;
+};

package/dist/types.js.flow

@@ -0,0 +1,12 @@
+/**
+ * Flowtype definitions for data
+ * Generated by Flowgen from a Typescript Definition
+ * Flowgen v1.21.0
+ * @flow
+ */
+export type LinterContextProps = {|
+  contentType: string,
+  highlightLint: boolean,
+  paths: $ReadOnlyArray<string>,
+  stack: $ReadOnlyArray<string>,
+|};

package/package.json

@@ -3,7 +3,7 @@
     "description": "Linter engine for Perseus",
     "author": "Khan Academy",
     "license": "MIT",
-    "version": "0.2.4",
+    "version": "0.3.0",
     "publishConfig": {
         "access": "public"
     },
@@ -16,15 +16,15 @@
     },
     "module": "dist/es/index.js",
     "main": "dist/index.js",
-    "source": "src/index.js",
+    "source": "src/index.ts",
     "scripts": {
         "test": "bash -c 'yarn --silent --cwd \"../..\" test ${@:0} $($([[ ${@: -1} = -* ]] || [[ ${@: -1} = bash ]]) && echo $PWD)'"
     },
     "dependencies": {
-        "@khanacademy/perseus-error": "^0.1.4"
+        "@khanacademy/perseus-error": "^0.2.0"
     },
     "devDependencies": {
-        "@khanacademy/pure-markdown": "^0.1.4",
+        "@khanacademy/pure-markdown": "^0.2.0",
         "prop-types": "^15.6.1"
     },
     "peerDependencies": {

package/src/__tests__/{matcher_test.js → matcher.test.ts}

@@ -1,12 +1,11 @@
-// @flow
 /* These tests exercise the Selector.match() method and also test that we
  * can integrate ../../perseus-markdown.js with ../tree-transform.js and
  * ../selector.js
  */
 import * as PureMarkdown from "@khanacademy/pure-markdown";
 
-import Selector from "../selector.js";
-import TreeTransformer from "../tree-transformer.js";
+import Selector from "../selector";
+import TreeTransformer from "../tree-transformer";
 
 describe("PerseusLinter selector matching:", () => {
     const markdown = `
@@ -33,14 +32,14 @@ C
         const tt = new TreeTransformer(tree);
         tt.traverse((n, state, content) => {
             // The wildcard selector should match at every node
-            // $FlowFixMe[incompatible-use]
+            // @ts-expect-error [FEI-5003] - TS2533 - Object is possibly 'null' or 'undefined'.
             expect(selector.match(state)[0]).toEqual(n);
         });
     });
 
     it("type-based matching works", () => {
         const tree = parseTree();
-        const selectors = {};
+        const selectors: Record<string, any> = {};
         const tt = new TreeTransformer(tree);
 
         // Traverse the tree once and create a selector for every type
@@ -83,14 +82,13 @@ C
         tt.traverse((n, state, content) => {
             const match = selector.match(state);
             const parent = state.parent();
-            // $FlowFixMe[incompatible-use]
-            // $FlowFixMe[incompatible-type]
+            // @ts-expect-error [FEI-5003] - TS2533 - Object is possibly 'null' or 'undefined'.
             if (n.type === "text" && parent.type === "paragraph") {
                 expect(Array.isArray(match)).toBeTruthy();
                 expect(match).toHaveLength(2);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2533 - Object is possibly 'null' or 'undefined'.
                 expect(match[0]).toEqual(parent);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2533 - Object is possibly 'null' or 'undefined'.
                 expect(match[1]).toEqual(n);
                 matchedText += content;
                 numMatches++;
@@ -118,16 +116,18 @@ C
             const grandparent = ancestors.pop();
             if (
                 n.type === "text" &&
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 parent.type === "em" &&
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 grandparent.type === "paragraph"
             ) {
                 expect(Array.isArray(match)).toBeTruthy();
                 expect(match).toHaveLength(3);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2533 - Object is possibly 'null' or 'undefined'.
                 expect(match[0]).toEqual(grandparent);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2533 - Object is possibly 'null' or 'undefined'.
                 expect(match[1]).toEqual(parent);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2533 - Object is possibly 'null' or 'undefined'.
                 expect(match[2]).toEqual(n);
                 matchedText += content;
                 numMatches++;
@@ -152,11 +152,11 @@ C
             if (match !== null) {
                 expect(Array.isArray(match)).toBeTruthy();
                 expect(match).toHaveLength(2);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[0].type).toEqual("paragraph");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1].type).toEqual("text");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1]).toEqual(n);
                 matchedText += content;
                 numMatches++;
@@ -179,13 +179,13 @@ C
             if (match !== null) {
                 expect(Array.isArray(match)).toBeTruthy();
                 expect(match).toHaveLength(3);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[0].type).toEqual("paragraph");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1].type).toEqual("em");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[2].type).toEqual("text");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[2]).toEqual(n);
                 matchedText += content;
                 numMatches++;
@@ -208,13 +208,13 @@ C
             if (match !== null) {
                 expect(Array.isArray(match)).toBeTruthy();
                 expect(match).toHaveLength(2);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[0].type).toEqual("heading");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[0]).toEqual(state.previousSibling());
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1].type).toEqual("paragraph");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1]).toEqual(n);
                 matchedText += content;
                 numMatches++;
@@ -237,15 +237,15 @@ C
             if (match !== null) {
                 expect(Array.isArray(match)).toBeTruthy();
                 expect(match).toHaveLength(3);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[0].type).toEqual("heading");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1].type).toEqual("paragraph");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1]).toEqual(state.previousSibling());
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[2].type).toEqual("paragraph");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[2]).toEqual(n);
                 matchedText += content;
                 numMatches++;
@@ -268,11 +268,11 @@ C
             if (match !== null) {
                 expect(Array.isArray(match)).toBeTruthy();
                 expect(match).toHaveLength(2);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[0].type).toEqual("heading");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1].type).toEqual("paragraph");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1]).toEqual(n);
                 matchedText += content;
                 numMatches++;
@@ -295,13 +295,13 @@ C
             if (match !== null) {
                 expect(Array.isArray(match)).toBeTruthy();
                 expect(match).toHaveLength(3);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[0].type).toEqual("heading");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1].type).toEqual("paragraph");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[2].type).toEqual("paragraph");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[2]).toEqual(n);
                 matchedText += content;
                 numMatches++;
@@ -324,15 +324,15 @@ C
             if (match !== null) {
                 expect(Array.isArray(match)).toBeTruthy();
                 expect(match).toHaveLength(3);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[0].type).toEqual("list");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1].type).toEqual("paragraph");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1]).toEqual(state.parent());
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[2].type).toEqual("em");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[2]).toEqual(n);
                 matchedText += content;
                 numMatches++;
@@ -355,15 +355,15 @@ C
             if (match !== null) {
                 expect(Array.isArray(match)).toBeTruthy();
                 expect(match).toHaveLength(3);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[0].type).toEqual("list");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1].type).toEqual("paragraph");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1]).toEqual(state.parent());
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[2].type).toEqual("em");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[2]).toEqual(n);
                 matchedText += content;
                 numMatches++;
@@ -386,17 +386,17 @@ C
             if (match !== null) {
                 expect(Array.isArray(match)).toBeTruthy();
                 expect(match).toHaveLength(3);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[0].type).toEqual("paragraph");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[0]).toEqual(state.parent());
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1].type).toEqual("em");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1]).toEqual(state.previousSibling());
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[2].type).toEqual("text");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[2]).toEqual(n);
                 matchedText += content;
                 numMatches++;
@@ -419,17 +419,17 @@ C
             if (match !== null) {
                 expect(Array.isArray(match)).toBeTruthy();
                 expect(match).toHaveLength(3);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[0].type).toEqual("paragraph");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[0]).toEqual(state.parent());
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1].type).toEqual("em");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[1]).toEqual(state.previousSibling());
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[2].type).toEqual("text");
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[2]).toEqual(n);
                 matchedText += content;
                 numMatches++;
@@ -452,7 +452,7 @@ C
             if (match !== null) {
                 expect(Array.isArray(match)).toBeTruthy();
                 expect(match).toHaveLength(1);
-                // $FlowFixMe[incompatible-use]
+                // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                 expect(match[0]).toEqual(n);
                 expect(
                     n.type === "paragraph" || n.type === "list",
@@ -479,11 +479,11 @@ C
                 expect(Array.isArray(match)).toBeTruthy();
                 if (n.type === "heading") {
                     expect(match).toHaveLength(1);
-                    // $FlowFixMe[incompatible-use]
+                    // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                     expect(match[0]).toEqual(n);
                 } else {
                     expect(match).toHaveLength(2);
-                    // $FlowFixMe[incompatible-use]
+                    // @ts-expect-error [FEI-5003] - TS2532 - Object is possibly 'undefined'.
                     expect(match[1]).toEqual(n);
                     expect(n.type).toEqual("text");
                 }

package/src/__tests__/{rule_test.js → rule.test.ts}

@@ -1,8 +1,7 @@
-// @flow
 import * as PureMarkdown from "@khanacademy/pure-markdown";
 
-import Rule from "../rule.js";
-import TreeTransformer from "../tree-transformer.js";
+import Rule from "../rule";
+import TreeTransformer from "../tree-transformer";
 
 describe("PerseusLinter lint Rules class", () => {
     const markdown = `
@@ -59,7 +58,7 @@ the previous heading was level ${previousHeading.level}`;
         },
     ];
 
-    let rules = [];
+    let rules: Array<never> | Array<Rule | any> = [];
 
     function parseTree() {
         return PureMarkdown.parse(markdown);
@@ -74,7 +73,16 @@ the previous heading was level ${previousHeading.level}`;
     it("check() method", () => {
         const tree = parseTree();
         const tt = new TreeTransformer(tree);
-        const warnings = [];
+        const warnings: Array<
+            | any
+            | {
+                  end: number;
+                  message: string;
+                  rule: string;
+                  severity?: number;
+                  start: number;
+              }
+        > = [];
 
         tt.traverse((node, state, content) => {
             rules.forEach((r) => {