4996849698

Build Type

push

github

Committed by Juanjo Diaz

Commit Message

fix: remove typescript from released module and use types instead

Run Details

273 of 274 branches covered (99.64%)

Branch coverage included in aggregate %.

10 of 11 new or added lines in 8 files covered. (90.91%)

1 existing line in 1 file now uncovered.

695 of 702 relevant lines covered (99.0%)

24594710.16 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

99.19

/packages/plainjs/src/tokenizer.ts

import { charset, escapedSequences } from "./utils/utf-8.js";
import {
  type StringBuilder,
  NonBufferedString,
  BufferedString,
} from "./utils/bufferedString.js";
import TokenType from "./utils/types/tokenType.js";
import type { ParsedTokenInfo } from "./utils/types/parsedTokenInfo.js";

// Tokenizer States
const enum TokenizerStates {
  START,
  ENDED,
  ERROR,
  TRUE1,
  TRUE2,
  TRUE3,
  FALSE1,
  FALSE2,
  FALSE3,
  FALSE4,
  NULL1,
  NULL2,
  NULL3,
  STRING_DEFAULT,
  STRING_AFTER_BACKSLASH,
  STRING_UNICODE_DIGIT_1,
  STRING_UNICODE_DIGIT_2,
  STRING_UNICODE_DIGIT_3,
  STRING_UNICODE_DIGIT_4,
  STRING_INCOMPLETE_CHAR,
  NUMBER_AFTER_INITIAL_MINUS,
  NUMBER_AFTER_INITIAL_ZERO,
  NUMBER_AFTER_INITIAL_NON_ZERO,
  NUMBER_AFTER_FULL_STOP,
  NUMBER_AFTER_DECIMAL,
  NUMBER_AFTER_E,
  NUMBER_AFTER_E_AND_SIGN,
  NUMBER_AFTER_E_AND_DIGIT,
  SEPARATOR,
}

function TokenizerStateToString(tokenizerState: TokenizerStates): string {
  return [
    "START",
    "ENDED",
    "ERROR",
    "TRUE1",
    "TRUE2",
    "TRUE3",
    "FALSE1",
    "FALSE2",
    "FALSE3",
    "FALSE4",
    "NULL1",
    "NULL2",
    "NULL3",
    "STRING_DEFAULT",
    "STRING_AFTER_BACKSLASH",
    "STRING_UNICODE_DIGIT_1",
    "STRING_UNICODE_DIGIT_2",
    "STRING_UNICODE_DIGIT_3",
    "STRING_UNICODE_DIGIT_4",
    "STRING_INCOMPLETE_CHAR",
    "NUMBER_AFTER_INITIAL_MINUS",
    "NUMBER_AFTER_INITIAL_ZERO",
    "NUMBER_AFTER_INITIAL_NON_ZERO",
    "NUMBER_AFTER_FULL_STOP",
    "NUMBER_AFTER_DECIMAL",
    "NUMBER_AFTER_E",
    "NUMBER_AFTER_E_AND_SIGN",
    "NUMBER_AFTER_E_AND_DIGIT",
    "SEPARATOR",
  ][tokenizerState];
}

export interface TokenizerOptions {
  stringBufferSize?: number;
  numberBufferSize?: number;
  separator?: string;
}

const defaultOpts: TokenizerOptions = {
  stringBufferSize: 0,
  numberBufferSize: 0,
  separator: undefined,
};

export class TokenizerError extends Error {
  constructor(message: string) {
    super(message);
    // Typescript is broken. This is a workaround
    Object.setPrototypeOf(this, TokenizerError.prototype);
  }
}

export default class Tokenizer {
  private state = TokenizerStates.START;

  private separator?: string;
  private separatorBytes?: Uint8Array;
  private separatorIndex = 0;
  private bufferedString: StringBuilder;
  private bufferedNumber: StringBuilder;

  private unicode?: string; // unicode escapes
  private highSurrogate?: number;
  private bytes_remaining = 0; // number of bytes remaining in multi byte utf8 char to read after split boundary
  private bytes_in_sequence = 0; // bytes in multi byte utf8 char to read
  private char_split_buffer = new Uint8Array(4); // for rebuilding chars split before boundary is reached
  private encoder = new TextEncoder();
  private offset = -1;

  constructor(opts?: TokenizerOptions) {
    opts = { ...defaultOpts, ...opts };

    this.bufferedString =
      opts.stringBufferSize && opts.stringBufferSize > 4
        ? new BufferedString(opts.stringBufferSize)
        : new NonBufferedString();
    this.bufferedNumber =
      opts.numberBufferSize && opts.numberBufferSize > 0
        ? new BufferedString(opts.numberBufferSize)
        : new NonBufferedString();

    this.separator = opts.separator;
    this.separatorBytes = opts.separator
      ? this.encoder.encode(opts.separator)
      : undefined;
  }

  public get isEnded(): boolean {
    return this.state === TokenizerStates.ENDED;
  }

  public write(input: Iterable<number> | string): void {
    try {
      let buffer: Uint8Array;
      if (input instanceof Uint8Array) {
        buffer = input;
      } else if (typeof input === "string") {
        buffer = this.encoder.encode(input);
      } else if (
        (typeof input === "object" && "buffer" in input) ||
        Array.isArray(input)
      ) {
        buffer = Uint8Array.from(input);
      } else {
        throw new TypeError(
          "Unexpected type. The `write` function only accepts Arrays, TypedArrays and Strings."
        );
      }

      for (let i = 0; i < buffer.length; i += 1) {
        const n = buffer[i]; // get current byte from buffer
        switch (this.state) {
          case TokenizerStates.START:
            this.offset += 1;

            if (this.separatorBytes && n === this.separatorBytes[0]) {
              if (this.separatorBytes.length === 1) {
                this.state = TokenizerStates.START;
                this.onToken({
                  token: TokenType.SEPARATOR,
                  value: this.separator as string,
                  offset: this.offset + this.separatorBytes.length - 1,
                });
                continue;
              }
              this.state = TokenizerStates.SEPARATOR;
              continue;
            }

            if (
              n === charset.SPACE ||
              n === charset.NEWLINE ||
              n === charset.CARRIAGE_RETURN ||
              n === charset.TAB
            ) {
              // whitespace
              continue;
            }

            if (n === charset.LEFT_CURLY_BRACKET) {
              this.onToken({
                token: TokenType.LEFT_BRACE,
                value: "{",
                offset: this.offset,
              });
              continue;
            }
            if (n === charset.RIGHT_CURLY_BRACKET) {
              this.onToken({
                token: TokenType.RIGHT_BRACE,
                value: "}",
                offset: this.offset,
              });
              continue;
            }
            if (n === charset.LEFT_SQUARE_BRACKET) {
              this.onToken({
                token: TokenType.LEFT_BRACKET,
                value: "[",
                offset: this.offset,
              });
              continue;
            }
            if (n === charset.RIGHT_SQUARE_BRACKET) {
              this.onToken({
                token: TokenType.RIGHT_BRACKET,
                value: "]",
                offset: this.offset,
              });
              continue;
            }
            if (n === charset.COLON) {
              this.onToken({
                token: TokenType.COLON,
                value: ":",
                offset: this.offset,
              });
              continue;
            }
            if (n === charset.COMMA) {
              this.onToken({
                token: TokenType.COMMA,
                value: ",",
                offset: this.offset,
              });
              continue;
            }

            if (n === charset.LATIN_SMALL_LETTER_T) {
              this.state = TokenizerStates.TRUE1;
              continue;
            }

            if (n === charset.LATIN_SMALL_LETTER_F) {
              this.state = TokenizerStates.FALSE1;
              continue;
            }

            if (n === charset.LATIN_SMALL_LETTER_N) {
              this.state = TokenizerStates.NULL1;
              continue;
            }

            if (n === charset.QUOTATION_MARK) {
              this.bufferedString.reset();
              this.state = TokenizerStates.STRING_DEFAULT;
              continue;
            }

            if (n >= charset.DIGIT_ONE && n <= charset.DIGIT_NINE) {
              this.bufferedNumber.reset();
              this.bufferedNumber.appendChar(n);
              this.state = TokenizerStates.NUMBER_AFTER_INITIAL_NON_ZERO;
              continue;
            }

            if (n === charset.DIGIT_ZERO) {
              this.bufferedNumber.reset();
              this.bufferedNumber.appendChar(n);
              this.state = TokenizerStates.NUMBER_AFTER_INITIAL_ZERO;
              continue;
            }

            if (n === charset.HYPHEN_MINUS) {
              this.bufferedNumber.reset();
              this.bufferedNumber.appendChar(n);
              this.state = TokenizerStates.NUMBER_AFTER_INITIAL_MINUS;
              continue;
            }

            break;
          // STRING
          case TokenizerStates.STRING_DEFAULT:
            if (n === charset.QUOTATION_MARK) {
              const string = this.bufferedString.toString();
              this.state = TokenizerStates.START;
              this.onToken({
                token: TokenType.STRING,
                value: string,
                offset: this.offset,
              });
              this.offset += this.bufferedString.byteLength + 1;
              continue;
            }

            if (n === charset.REVERSE_SOLIDUS) {
              this.state = TokenizerStates.STRING_AFTER_BACKSLASH;
              continue;
            }

            if (n >= 128) {
              // Parse multi byte (>=128) chars one at a time
              if (n >= 194 && n <= 223) {
                this.bytes_in_sequence = 2;
              } else if (n <= 239) {
                this.bytes_in_sequence = 3;
              } else {
                this.bytes_in_sequence = 4;
              }

              if (this.bytes_in_sequence <= buffer.length - i) {
                // if bytes needed to complete char fall outside buffer length, we have a boundary split
                this.bufferedString.appendBuf(
                  buffer,
                  i,
                  i + this.bytes_in_sequence
                );
                i += this.bytes_in_sequence - 1;
                continue;
              }

              this.bytes_remaining = i + this.bytes_in_sequence - buffer.length;
              this.char_split_buffer.set(buffer.subarray(i));
              i = buffer.length - 1;
              this.state = TokenizerStates.STRING_INCOMPLETE_CHAR;
              continue;
            }

            if (n >= charset.SPACE) {
              this.bufferedString.appendChar(n);
              continue;
            }

            break;
          case TokenizerStates.STRING_INCOMPLETE_CHAR:
            // check for carry over of a multi byte char split between data chunks
            // & fill temp buffer it with start of this data chunk up to the boundary limit set in the last iteration
            this.char_split_buffer.set(
              buffer.subarray(i, i + this.bytes_remaining),
              this.bytes_in_sequence - this.bytes_remaining
            );
            this.bufferedString.appendBuf(
              this.char_split_buffer,
              0,
              this.bytes_in_sequence
            );
            i = this.bytes_remaining - 1;
            this.state = TokenizerStates.STRING_DEFAULT;
            continue;
          case TokenizerStates.STRING_AFTER_BACKSLASH:
            const controlChar = escapedSequences[n];
            if (controlChar) {
              this.bufferedString.appendChar(controlChar);
              this.state = TokenizerStates.STRING_DEFAULT;
              continue;
            }

            if (n === charset.LATIN_SMALL_LETTER_U) {
              this.unicode = "";
              this.state = TokenizerStates.STRING_UNICODE_DIGIT_1;
              continue;
            }

            break;
          case TokenizerStates.STRING_UNICODE_DIGIT_1:
          case TokenizerStates.STRING_UNICODE_DIGIT_2:
          case TokenizerStates.STRING_UNICODE_DIGIT_3:
            if (
              (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) ||
              (n >= charset.LATIN_CAPITAL_LETTER_A &&
                n <= charset.LATIN_CAPITAL_LETTER_F) ||
              (n >= charset.LATIN_SMALL_LETTER_A &&
                n <= charset.LATIN_SMALL_LETTER_F)
            ) {
              this.unicode += String.fromCharCode(n);
              this.state += 1;
              continue;
            }
            break;
          case TokenizerStates.STRING_UNICODE_DIGIT_4:
            if (
              (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) ||
              (n >= charset.LATIN_CAPITAL_LETTER_A &&
                n <= charset.LATIN_CAPITAL_LETTER_F) ||
              (n >= charset.LATIN_SMALL_LETTER_A &&
                n <= charset.LATIN_SMALL_LETTER_F)
            ) {
              const intVal = parseInt(
                this.unicode + String.fromCharCode(n),
                16
              );
              if (this.highSurrogate === undefined) {
                if (intVal >= 0xd800 && intVal <= 0xdbff) {
                  //<55296,56319> - highSurrogate
                  this.highSurrogate = intVal;
                } else {
                  this.bufferedString.appendBuf(
                    this.encoder.encode(String.fromCharCode(intVal))
                  );
                }
              } else {
                if (intVal >= 0xdc00 && intVal <= 0xdfff) {
                  //<56320,57343> - lowSurrogate
                  this.bufferedString.appendBuf(
                    this.encoder.encode(
                      String.fromCharCode(this.highSurrogate, intVal)
                    )
                  );
                } else {
                  this.bufferedString.appendBuf(
                    this.encoder.encode(String.fromCharCode(this.highSurrogate))
                  );
                }
                this.highSurrogate = undefined;
              }
              this.state = TokenizerStates.STRING_DEFAULT;
              continue;
            }
            break;
          // Number
          case TokenizerStates.NUMBER_AFTER_INITIAL_MINUS:
            if (n === charset.DIGIT_ZERO) {
              this.bufferedNumber.appendChar(n);
              this.state = TokenizerStates.NUMBER_AFTER_INITIAL_ZERO;
              continue;
            }

            if (n >= charset.DIGIT_ONE && n <= charset.DIGIT_NINE) {
              this.bufferedNumber.appendChar(n);
              this.state = TokenizerStates.NUMBER_AFTER_INITIAL_NON_ZERO;
              continue;
            }

            break;
          case TokenizerStates.NUMBER_AFTER_INITIAL_ZERO:
            if (n === charset.FULL_STOP) {
              this.bufferedNumber.appendChar(n);
              this.state = TokenizerStates.NUMBER_AFTER_FULL_STOP;
              continue;
            }

            if (
              n === charset.LATIN_SMALL_LETTER_E ||
              n === charset.LATIN_CAPITAL_LETTER_E
            ) {
              this.bufferedNumber.appendChar(n);
              this.state = TokenizerStates.NUMBER_AFTER_E;
              continue;
            }

            i -= 1;
            this.state = TokenizerStates.START;
            this.emitNumber();
            continue;
          case TokenizerStates.NUMBER_AFTER_INITIAL_NON_ZERO:
            if (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) {
              this.bufferedNumber.appendChar(n);
              continue;
            }

            if (n === charset.FULL_STOP) {
              this.bufferedNumber.appendChar(n);
              this.state = TokenizerStates.NUMBER_AFTER_FULL_STOP;
              continue;
            }

            if (
              n === charset.LATIN_SMALL_LETTER_E ||
              n === charset.LATIN_CAPITAL_LETTER_E
            ) {
              this.bufferedNumber.appendChar(n);
              this.state = TokenizerStates.NUMBER_AFTER_E;
              continue;
            }

            i -= 1;
            this.state = TokenizerStates.START;
            this.emitNumber();
            continue;
          case TokenizerStates.NUMBER_AFTER_FULL_STOP:
            if (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) {
              this.bufferedNumber.appendChar(n);
              this.state = TokenizerStates.NUMBER_AFTER_DECIMAL;
              continue;
            }

            break;
          case TokenizerStates.NUMBER_AFTER_DECIMAL:
            if (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) {
              this.bufferedNumber.appendChar(n);
              continue;
            }

            if (
              n === charset.LATIN_SMALL_LETTER_E ||
              n === charset.LATIN_CAPITAL_LETTER_E
            ) {
              this.bufferedNumber.appendChar(n);
              this.state = TokenizerStates.NUMBER_AFTER_E;
              continue;
            }

            i -= 1;
            this.state = TokenizerStates.START;
            this.emitNumber();
            continue;
          // @ts-ignore fall through case
          case TokenizerStates.NUMBER_AFTER_E:
            if (n === charset.PLUS_SIGN || n === charset.HYPHEN_MINUS) {
              this.bufferedNumber.appendChar(n);
              this.state = TokenizerStates.NUMBER_AFTER_E_AND_SIGN;
              continue;
            }
          // Allow cascading
          case TokenizerStates.NUMBER_AFTER_E_AND_SIGN:
            if (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) {
              this.bufferedNumber.appendChar(n);
              this.state = TokenizerStates.NUMBER_AFTER_E_AND_DIGIT;
              continue;
            }

            break;
          case TokenizerStates.NUMBER_AFTER_E_AND_DIGIT:
            if (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) {
              this.bufferedNumber.appendChar(n);
              continue;
            }

            i -= 1;
            this.state = TokenizerStates.START;
            this.emitNumber();
            continue;
          // TRUE
          case TokenizerStates.TRUE1:
            if (n === charset.LATIN_SMALL_LETTER_R) {
              this.state = TokenizerStates.TRUE2;
              continue;
            }
            break;
          case TokenizerStates.TRUE2:
            if (n === charset.LATIN_SMALL_LETTER_U) {
              this.state = TokenizerStates.TRUE3;
              continue;
            }
            break;
          case TokenizerStates.TRUE3:
            if (n === charset.LATIN_SMALL_LETTER_E) {
              this.state = TokenizerStates.START;
              this.onToken({
                token: TokenType.TRUE,
                value: true,
                offset: this.offset,
              });
              this.offset += 3;
              continue;
            }
            break;
          // FALSE
          case TokenizerStates.FALSE1:
            if (n === charset.LATIN_SMALL_LETTER_A) {
              this.state = TokenizerStates.FALSE2;
              continue;
            }
            break;
          case TokenizerStates.FALSE2:
            if (n === charset.LATIN_SMALL_LETTER_L) {
              this.state = TokenizerStates.FALSE3;
              continue;
            }
            break;
          case TokenizerStates.FALSE3:
            if (n === charset.LATIN_SMALL_LETTER_S) {
              this.state = TokenizerStates.FALSE4;
              continue;
            }
            break;
          case TokenizerStates.FALSE4:
            if (n === charset.LATIN_SMALL_LETTER_E) {
              this.state = TokenizerStates.START;
              this.onToken({
                token: TokenType.FALSE,
                value: false,
                offset: this.offset,
              });
              this.offset += 4;
              continue;
            }
            break;
          // NULL
          case TokenizerStates.NULL1:
            if (n === charset.LATIN_SMALL_LETTER_U) {
              this.state = TokenizerStates.NULL2;
              continue;
            }
            break;
          case TokenizerStates.NULL2:
            if (n === charset.LATIN_SMALL_LETTER_L) {
              this.state = TokenizerStates.NULL3;
              continue;
            }
            break;
          case TokenizerStates.NULL3:
            if (n === charset.LATIN_SMALL_LETTER_L) {
              this.state = TokenizerStates.START;
              this.onToken({
                token: TokenType.NULL,
                value: null,
                offset: this.offset,
              });
              this.offset += 3;
              continue;
            }
            break;
          case TokenizerStates.SEPARATOR:
            this.separatorIndex += 1;
            if (
              !this.separatorBytes ||
              n !== this.separatorBytes[this.separatorIndex]
            ) {
              break;
            }
            if (this.separatorIndex === this.separatorBytes.length - 1) {
              this.state = TokenizerStates.START;
              this.onToken({
                token: TokenType.SEPARATOR,
                value: this.separator as string,
                offset: this.offset + this.separatorIndex,
              });
              this.separatorIndex = 0;
            }
            continue;
          case TokenizerStates.ENDED:
            if (
              n === charset.SPACE ||
              n === charset.NEWLINE ||
              n === charset.CARRIAGE_RETURN ||
              n === charset.TAB
            ) {
              // whitespace
              continue;
            }
        }

        throw new TokenizerError(
          `Unexpected "${String.fromCharCode(
            n
          )}" at position "${i}" in state ${TokenizerStateToString(this.state)}`
        );
      }
      // eslint-disable-next-line @typescript-eslint/no-explicit-any
    } catch (err: any) {
      this.error(err);
    }
  }

  private emitNumber(): void {
    this.onToken({
      token: TokenType.NUMBER,
      value: this.parseNumber(this.bufferedNumber.toString()),
      offset: this.offset,
    });
    this.offset += this.bufferedNumber.byteLength - 1;
  }

  protected parseNumber(numberStr: string): number {
    return Number(numberStr);
  }

  public error(err: Error): void {
    if (this.state !== TokenizerStates.ENDED) {
      this.state = TokenizerStates.ERROR;
    }

    this.onError(err);
  }

  public end(): void {
    switch (this.state) {
      case TokenizerStates.NUMBER_AFTER_INITIAL_ZERO:
      case TokenizerStates.NUMBER_AFTER_INITIAL_NON_ZERO:
      case TokenizerStates.NUMBER_AFTER_DECIMAL:
      case TokenizerStates.NUMBER_AFTER_E_AND_DIGIT:
        this.state = TokenizerStates.ENDED;
        this.emitNumber();
        this.onEnd();
        break;
      case TokenizerStates.START:
      case TokenizerStates.ERROR:
      case TokenizerStates.SEPARATOR:
        this.state = TokenizerStates.ENDED;
        this.onEnd();
        break;
      default:
        this.error(
          new TokenizerError(
            `Tokenizer ended in the middle of a token (state: ${TokenizerStateToString(
              this.state
            )}). Either not all the data was received or the data was invalid.`
          )
        );
    }
  }

  // eslint-disable-next-line @typescript-eslint/no-unused-vars
  public onToken(parsedToken: ParsedTokenInfo): void {
    // Override me
    throw new TokenizerError(
      'Can\'t emit tokens before the "onToken" callback has been set up.'
    );
  }

  public onError(err: Error): void {
    // Override me
    throw err;
  }

  public onEnd(): void {
    // Override me
  }
}

1	import { charset, escapedSequences } from "./utils/utf-8.js";	28✔
2	import {	28✔
3	type StringBuilder,
4	NonBufferedString,
5	BufferedString,
6	} from "./utils/bufferedString.js";
7	import TokenType from "./utils/types/tokenType.js";	28✔
8	import type { ParsedTokenInfo } from "./utils/types/parsedTokenInfo.js";
9
10	// Tokenizer States
11	const enum TokenizerStates {	28✔
12	START,	28✔
13	ENDED,	28✔
14	ERROR,	28✔
15	TRUE1,	28✔
16	TRUE2,	28✔
17	TRUE3,	28✔
18	FALSE1,	28✔
19	FALSE2,	28✔
20	FALSE3,	28✔
21	FALSE4,	28✔
22	NULL1,	28✔
23	NULL2,	28✔
24	NULL3,	28✔
25	STRING_DEFAULT,	28✔
26	STRING_AFTER_BACKSLASH,	28✔
27	STRING_UNICODE_DIGIT_1,	28✔
28	STRING_UNICODE_DIGIT_2,	28✔
29	STRING_UNICODE_DIGIT_3,	28✔
30	STRING_UNICODE_DIGIT_4,	28✔
31	STRING_INCOMPLETE_CHAR,	28✔
32	NUMBER_AFTER_INITIAL_MINUS,	28✔
33	NUMBER_AFTER_INITIAL_ZERO,	28✔
34	NUMBER_AFTER_INITIAL_NON_ZERO,	28✔
35	NUMBER_AFTER_FULL_STOP,	28✔
36	NUMBER_AFTER_DECIMAL,	28✔
37	NUMBER_AFTER_E,	28✔
38	NUMBER_AFTER_E_AND_SIGN,	28✔
39	NUMBER_AFTER_E_AND_DIGIT,	28✔
40	SEPARATOR,	28✔
41	}
42
43	function TokenizerStateToString(tokenizerState: TokenizerStates): string {
44	return [	80✔
45	"START",
46	"ENDED",
47	"ERROR",
48	"TRUE1",
49	"TRUE2",
50	"TRUE3",
51	"FALSE1",
52	"FALSE2",
53	"FALSE3",
54	"FALSE4",
55	"NULL1",
56	"NULL2",
57	"NULL3",
58	"STRING_DEFAULT",
59	"STRING_AFTER_BACKSLASH",
60	"STRING_UNICODE_DIGIT_1",
61	"STRING_UNICODE_DIGIT_2",
62	"STRING_UNICODE_DIGIT_3",
63	"STRING_UNICODE_DIGIT_4",
64	"STRING_INCOMPLETE_CHAR",
65	"NUMBER_AFTER_INITIAL_MINUS",
66	"NUMBER_AFTER_INITIAL_ZERO",
67	"NUMBER_AFTER_INITIAL_NON_ZERO",
68	"NUMBER_AFTER_FULL_STOP",
69	"NUMBER_AFTER_DECIMAL",
70	"NUMBER_AFTER_E",
71	"NUMBER_AFTER_E_AND_SIGN",
72	"NUMBER_AFTER_E_AND_DIGIT",
73	"SEPARATOR",
74	][tokenizerState];
75	}
76
77	export interface TokenizerOptions {
78	stringBufferSize?: number;
79	numberBufferSize?: number;
80	separator?: string;
81	}
82
83	const defaultOpts: TokenizerOptions = {	28✔
84	stringBufferSize: 0,
85	numberBufferSize: 0,
86	separator: undefined,
87	};
88
89	export class TokenizerError extends Error {	28✔
90	constructor(message: string) {
91	super(message);	82✔
92	// Typescript is broken. This is a workaround
93	Object.setPrototypeOf(this, TokenizerError.prototype);	82✔
94	}
95	}
96
97	export default class Tokenizer {	28✔
98	private state = TokenizerStates.START;	788✔
99
100	private separator?: string;
101	private separatorBytes?: Uint8Array;
102	private separatorIndex = 0;	788✔
103	private bufferedString: StringBuilder;
104	private bufferedNumber: StringBuilder;
105
106	private unicode?: string; // unicode escapes
107	private highSurrogate?: number;
108	private bytes_remaining = 0; // number of bytes remaining in multi byte utf8 char to read after split boundary	788✔
109	private bytes_in_sequence = 0; // bytes in multi byte utf8 char to read	788✔
110	private char_split_buffer = new Uint8Array(4); // for rebuilding chars split before boundary is reached	788✔
111	private encoder = new TextEncoder();	788✔
112	private offset = -1;	788✔
113
114	constructor(opts?: TokenizerOptions) {
115	opts = { ...defaultOpts, ...opts };	788✔
116
117	this.bufferedString =	788✔
118	opts.stringBufferSize && opts.stringBufferSize > 4	1,652✔
119	? new BufferedString(opts.stringBufferSize)
120	: new NonBufferedString();
121	this.bufferedNumber =	788✔
122	opts.numberBufferSize && opts.numberBufferSize > 0	1,762✔
123	? new BufferedString(opts.numberBufferSize)
124	: new NonBufferedString();
125
126	this.separator = opts.separator;	788✔
127	this.separatorBytes = opts.separator	788✔
128	? this.encoder.encode(opts.separator)
129	: undefined;
130	}
131
132	public get isEnded(): boolean {
133	return this.state === TokenizerStates.ENDED;	318✔
134	}
135
136	public write(input: Iterable<number> \| string): void {
137	try {	2,460,908✔
138	let buffer: Uint8Array;
139	if (input instanceof Uint8Array) {	2,460,908✔
140	buffer = input;	2,457,738✔
141	} else if (typeof input === "string") {	3,170✔
142	buffer = this.encoder.encode(input);	3,160✔
143	} else if (	10✔
144	(typeof input === "object" && "buffer" in input) \|\|	22✔
145	Array.isArray(input)
146	) {
147	buffer = Uint8Array.from(input);	6✔
148	} else {
149	throw new TypeError(	4✔
150	"Unexpected type. The `write` function only accepts Arrays, TypedArrays and Strings."
151	);
152	}
153
154	for (let i = 0; i < buffer.length; i += 1) {	2,460,904✔
155	const n = buffer[i]; // get current byte from buffer	1,678,567,366✔
156	switch (this.state) {	1,678,567,366✔
157	case TokenizerStates.START:
158	this.offset += 1;	2,470,420✔
159
160	if (this.separatorBytes && n === this.separatorBytes[0]) {	2,470,420✔
161	if (this.separatorBytes.length === 1) {	52✔
162	this.state = TokenizerStates.START;	14✔
163	this.onToken({	14✔
164	token: TokenType.SEPARATOR,
165	value: this.separator as string,
166	offset: this.offset + this.separatorBytes.length - 1,
167	});
168	continue;	14✔
169	}
170	this.state = TokenizerStates.SEPARATOR;	38✔
171	continue;	38✔
172	}
173
174	if (	2,470,368✔
175	n === charset.SPACE \|\|	9,861,280✔
176	n === charset.NEWLINE \|\|
177	n === charset.CARRIAGE_RETURN \|\|
178	n === charset.TAB
179	) {
180	// whitespace
181	continue;	7,442✔
182	}
183
184	if (n === charset.LEFT_CURLY_BRACKET) {	2,462,926✔
185	this.onToken({	214✔
186	token: TokenType.LEFT_BRACE,
187	value: "{",
188	offset: this.offset,
189	});
190	continue;	214✔
191	}
192	if (n === charset.RIGHT_CURLY_BRACKET) {	2,462,712✔
193	this.onToken({	194✔
194	token: TokenType.RIGHT_BRACE,
195	value: "}",
196	offset: this.offset,
197	});
198	continue;	190✔
199	}
200	if (n === charset.LEFT_SQUARE_BRACKET) {	2,462,518✔
201	this.onToken({	404✔
202	token: TokenType.LEFT_BRACKET,
203	value: "[",
204	offset: this.offset,
205	});
206	continue;	404✔
207	}
208	if (n === charset.RIGHT_SQUARE_BRACKET) {	2,462,114✔
209	this.onToken({	396✔
210	token: TokenType.RIGHT_BRACKET,
211	value: "]",
212	offset: this.offset,
213	});
214	continue;	392✔
215	}
216	if (n === charset.COLON) {	2,461,718✔
217	this.onToken({	410,264✔
218	token: TokenType.COLON,
219	value: ":",
220	offset: this.offset,
221	});
222	continue;	410,264✔
223	}
224	if (n === charset.COMMA) {	2,051,454✔
225	this.onToken({	820,218✔
226	token: TokenType.COMMA,
227	value: ",",
228	offset: this.offset,
229	});
230	continue;	820,212✔
231	}
232
233	if (n === charset.LATIN_SMALL_LETTER_T) {	1,231,236✔
234	this.state = TokenizerStates.TRUE1;	82✔
235	continue;	82✔
236	}
237
238	if (n === charset.LATIN_SMALL_LETTER_F) {	1,231,154✔
239	this.state = TokenizerStates.FALSE1;	40✔
240	continue;	40✔
241	}
242
243	if (n === charset.LATIN_SMALL_LETTER_N) {	1,231,114✔
244	this.state = TokenizerStates.NULL1;	22✔
245	continue;	22✔
246	}
247
248	if (n === charset.QUOTATION_MARK) {	1,231,092✔
249	this.bufferedString.reset();	1,229,752✔
250	this.state = TokenizerStates.STRING_DEFAULT;	1,229,752✔
251	continue;	1,229,752✔
252	}
253
254	if (n >= charset.DIGIT_ONE && n <= charset.DIGIT_NINE) {	1,340✔
255	this.bufferedNumber.reset();	866✔
256	this.bufferedNumber.appendChar(n);	866✔
257	this.state = TokenizerStates.NUMBER_AFTER_INITIAL_NON_ZERO;	866✔
258	continue;	866✔
259	}
260
261	if (n === charset.DIGIT_ZERO) {	474✔
262	this.bufferedNumber.reset();	206✔
263	this.bufferedNumber.appendChar(n);	206✔
264	this.state = TokenizerStates.NUMBER_AFTER_INITIAL_ZERO;	206✔
265	continue;	206✔
266	}
267
268	if (n === charset.HYPHEN_MINUS) {	268✔
269	this.bufferedNumber.reset();	250✔
270	this.bufferedNumber.appendChar(n);	250✔
271	this.state = TokenizerStates.NUMBER_AFTER_INITIAL_MINUS;	250✔
272	continue;	250✔
273	}
274
275	break;	18✔
276	// STRING
277	case TokenizerStates.STRING_DEFAULT:
278	if (n === charset.QUOTATION_MARK) {	1,256,660,942✔
279	const string = this.bufferedString.toString();	1,229,746✔
280	this.state = TokenizerStates.START;	1,229,746✔
281	this.onToken({	1,229,746✔
282	token: TokenType.STRING,
283	value: string,
284	offset: this.offset,
285	});
286	this.offset += this.bufferedString.byteLength + 1;	1,229,740✔
287	continue;	1,229,740✔
288	}
289
290	if (n === charset.REVERSE_SOLIDUS) {	1,255,431,196✔
291	this.state = TokenizerStates.STRING_AFTER_BACKSLASH;	128✔
292	continue;	128✔
293	}
294
295	if (n >= 128) {	1,255,431,068✔
296	// Parse multi byte (>=128) chars one at a time
297	if (n >= 194 && n <= 223) {	208✔
298	this.bytes_in_sequence = 2;	62✔
299	} else if (n <= 239) {	146✔
300	this.bytes_in_sequence = 3;	92✔
301	} else {
302	this.bytes_in_sequence = 4;	54✔
303	}
304
305	if (this.bytes_in_sequence <= buffer.length - i) {	208✔
306	// if bytes needed to complete char fall outside buffer length, we have a boundary split
307	this.bufferedString.appendBuf(	172✔
308	buffer,
309	i,
310	i + this.bytes_in_sequence
311	);
312	i += this.bytes_in_sequence - 1;	172✔
313	continue;	172✔
314	}
315
316	this.bytes_remaining = i + this.bytes_in_sequence - buffer.length;	36✔
317	this.char_split_buffer.set(buffer.subarray(i));	36✔
318	i = buffer.length - 1;	36✔
319	this.state = TokenizerStates.STRING_INCOMPLETE_CHAR;	36✔
320	continue;	36✔
321	}
322
323	if (n >= charset.SPACE) {	1,255,430,860✔
324	this.bufferedString.appendChar(n);	1,255,430,860✔
325	continue;	1,255,430,860✔
326	}
327
328	break;	×
329	case TokenizerStates.STRING_INCOMPLETE_CHAR:
330	// check for carry over of a multi byte char split between data chunks
331	// & fill temp buffer it with start of this data chunk up to the boundary limit set in the last iteration
332	this.char_split_buffer.set(	36✔
333	buffer.subarray(i, i + this.bytes_remaining),
334	this.bytes_in_sequence - this.bytes_remaining
335	);
336	this.bufferedString.appendBuf(	36✔
337	this.char_split_buffer,
338	0,
339	this.bytes_in_sequence
340	);
341	i = this.bytes_remaining - 1;	36✔
342	this.state = TokenizerStates.STRING_DEFAULT;	36✔
343	continue;	36✔
344	case TokenizerStates.STRING_AFTER_BACKSLASH:
345	const controlChar = escapedSequences[n];	128✔
346	if (controlChar) {	128✔
347	this.bufferedString.appendChar(controlChar);	56✔
348	this.state = TokenizerStates.STRING_DEFAULT;	56✔
349	continue;	56✔
350	}
351
352	if (n === charset.LATIN_SMALL_LETTER_U) {	72✔
353	this.unicode = "";	72✔
354	this.state = TokenizerStates.STRING_UNICODE_DIGIT_1;	72✔
355	continue;	72✔
356	}
357
358	break;	×
359	case TokenizerStates.STRING_UNICODE_DIGIT_1:
360	case TokenizerStates.STRING_UNICODE_DIGIT_2:
361	case TokenizerStates.STRING_UNICODE_DIGIT_3:
362	if (	216✔
363	(n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) \|\|	672✔
364	(n >= charset.LATIN_CAPITAL_LETTER_A &&
365	n <= charset.LATIN_CAPITAL_LETTER_F) \|\|
366	(n >= charset.LATIN_SMALL_LETTER_A &&
367	n <= charset.LATIN_SMALL_LETTER_F)
368	) {
369	this.unicode += String.fromCharCode(n);	216✔
370	this.state += 1;	216✔
371	continue;	216✔
372	}
373	break;	×
374	case TokenizerStates.STRING_UNICODE_DIGIT_4:
375	if (	72✔
376	(n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) \|\|	288✔
377	(n >= charset.LATIN_CAPITAL_LETTER_A &&
378	n <= charset.LATIN_CAPITAL_LETTER_F) \|\|
379	(n >= charset.LATIN_SMALL_LETTER_A &&
380	n <= charset.LATIN_SMALL_LETTER_F)
381	) {
382	const intVal = parseInt(	72✔
383	this.unicode + String.fromCharCode(n),
384	16
385	);
386	if (this.highSurrogate === undefined) {	72✔
387	if (intVal >= 0xd800 && intVal <= 0xdbff) {	60✔
388	//<55296,56319> - highSurrogate
389	this.highSurrogate = intVal;	12✔
390	} else {
391	this.bufferedString.appendBuf(	48✔
392	this.encoder.encode(String.fromCharCode(intVal))
393	);
394	}
395	} else {
396	if (intVal >= 0xdc00 && intVal <= 0xdfff) {	12✔
397	//<56320,57343> - lowSurrogate
398	this.bufferedString.appendBuf(	8✔
399	this.encoder.encode(
400	String.fromCharCode(this.highSurrogate, intVal)
401	)
402	);
403	} else {
404	this.bufferedString.appendBuf(	4✔
405	this.encoder.encode(String.fromCharCode(this.highSurrogate))
406	);
407	}
408	this.highSurrogate = undefined;	12✔
409	}
410	this.state = TokenizerStates.STRING_DEFAULT;	72✔
411	continue;	72✔
412	}
NEW 413	break;	×
414	// Number
415	case TokenizerStates.NUMBER_AFTER_INITIAL_MINUS:
416	if (n === charset.DIGIT_ZERO) {	250✔
417	this.bufferedNumber.appendChar(n);	96✔
418	this.state = TokenizerStates.NUMBER_AFTER_INITIAL_ZERO;	96✔
419	continue;	96✔
420	}
421
422	if (n >= charset.DIGIT_ONE && n <= charset.DIGIT_NINE) {	154✔
423	this.bufferedNumber.appendChar(n);	150✔
424	this.state = TokenizerStates.NUMBER_AFTER_INITIAL_NON_ZERO;	150✔
425	continue;	150✔
426	}
427
428	break;	4✔
429	case TokenizerStates.NUMBER_AFTER_INITIAL_ZERO:
430	if (n === charset.FULL_STOP) {	284✔
431	this.bufferedNumber.appendChar(n);	198✔
432	this.state = TokenizerStates.NUMBER_AFTER_FULL_STOP;	198✔
433	continue;	198✔
434	}
435
436	if (	86✔
437	n === charset.LATIN_SMALL_LETTER_E \|\|	116✔
438	n === charset.LATIN_CAPITAL_LETTER_E
439	) {
440	this.bufferedNumber.appendChar(n);	56✔
441	this.state = TokenizerStates.NUMBER_AFTER_E;	56✔
442	continue;	56✔
443	}
444
445	i -= 1;	30✔
446	this.state = TokenizerStates.START;	30✔
447	this.emitNumber();	30✔
448	continue;	30✔
449	case TokenizerStates.NUMBER_AFTER_INITIAL_NON_ZERO:
450	if (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) {	1,824✔
451	this.bufferedNumber.appendChar(n);	840✔
452	continue;	840✔
453	}
454
455	if (n === charset.FULL_STOP) {	984✔
456	this.bufferedNumber.appendChar(n);	304✔
457	this.state = TokenizerStates.NUMBER_AFTER_FULL_STOP;	304✔
458	continue;	304✔
459	}
460
461	if (	680✔
462	n === charset.LATIN_SMALL_LETTER_E \|\|	1,300✔
463	n === charset.LATIN_CAPITAL_LETTER_E
464	) {
465	this.bufferedNumber.appendChar(n);	60✔
466	this.state = TokenizerStates.NUMBER_AFTER_E;	60✔
467	continue;	60✔
468	}
469
470	i -= 1;	620✔
471	this.state = TokenizerStates.START;	620✔
472	this.emitNumber();	620✔
473	continue;	620✔
474	case TokenizerStates.NUMBER_AFTER_FULL_STOP:
475	if (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) {	500✔
476	this.bufferedNumber.appendChar(n);	494✔
477	this.state = TokenizerStates.NUMBER_AFTER_DECIMAL;	494✔
478	continue;	494✔
479	}
480
481	break;	6✔
482	case TokenizerStates.NUMBER_AFTER_DECIMAL:
483	if (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) {	419,431,384✔
484	this.bufferedNumber.appendChar(n);	419,430,928✔
485	continue;	419,430,928✔
486	}
487
488	if (	456✔
489	n === charset.LATIN_SMALL_LETTER_E \|\|	776✔
490	n === charset.LATIN_CAPITAL_LETTER_E
491	) {
492	this.bufferedNumber.appendChar(n);	232✔
493	this.state = TokenizerStates.NUMBER_AFTER_E;	232✔
494	continue;	232✔
495	}
496
497	i -= 1;	224✔
498	this.state = TokenizerStates.START;	224✔
499	this.emitNumber();	224✔
500	continue;	224✔
501	// @ts-ignore fall through case
502	case TokenizerStates.NUMBER_AFTER_E:
503	if (n === charset.PLUS_SIGN \|\| n === charset.HYPHEN_MINUS) {	346✔
504	this.bufferedNumber.appendChar(n);	214✔
505	this.state = TokenizerStates.NUMBER_AFTER_E_AND_SIGN;	214✔
506	continue;	214✔
507	}
508	// Allow cascading
509	case TokenizerStates.NUMBER_AFTER_E_AND_SIGN:
510	if (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) {	344✔
511	this.bufferedNumber.appendChar(n);	342✔
512	this.state = TokenizerStates.NUMBER_AFTER_E_AND_DIGIT;	342✔
513	continue;	342✔
514	}
515
516	break;	2✔
517	case TokenizerStates.NUMBER_AFTER_E_AND_DIGIT:
518	if (n >= charset.DIGIT_ZERO && n <= charset.DIGIT_NINE) {	156✔
519	this.bufferedNumber.appendChar(n);	114✔
520	continue;	114✔
521	}
522
523	i -= 1;	42✔
524	this.state = TokenizerStates.START;	42✔
525	this.emitNumber();	42✔
526	continue;	42✔
527	// TRUE
528	case TokenizerStates.TRUE1:
529	if (n === charset.LATIN_SMALL_LETTER_R) {	82✔
530	this.state = TokenizerStates.TRUE2;	78✔
531	continue;	78✔
532	}
533	break;	4✔
534	case TokenizerStates.TRUE2:
535	if (n === charset.LATIN_SMALL_LETTER_U) {	78✔
536	this.state = TokenizerStates.TRUE3;	76✔
537	continue;	76✔
538	}
539	break;	2✔
540	case TokenizerStates.TRUE3:
541	if (n === charset.LATIN_SMALL_LETTER_E) {	74✔
542	this.state = TokenizerStates.START;	72✔
543	this.onToken({	72✔
544	token: TokenType.TRUE,
545	value: true,
546	offset: this.offset,
547	});
548	this.offset += 3;	72✔
549	continue;	72✔
550	}
551	break;	2✔
552	// FALSE
553	case TokenizerStates.FALSE1:
554	if (n === charset.LATIN_SMALL_LETTER_A) {	40✔
555	this.state = TokenizerStates.FALSE2;	38✔
556	continue;	38✔
557	}
558	break;	2✔
559	case TokenizerStates.FALSE2:
560	if (n === charset.LATIN_SMALL_LETTER_L) {	38✔
561	this.state = TokenizerStates.FALSE3;	36✔
562	continue;	36✔
563	}
564	break;	2✔
565	case TokenizerStates.FALSE3:
566	if (n === charset.LATIN_SMALL_LETTER_S) {	36✔
567	this.state = TokenizerStates.FALSE4;	34✔
568	continue;	34✔
569	}
570	break;	2✔
571	case TokenizerStates.FALSE4:
572	if (n === charset.LATIN_SMALL_LETTER_E) {	34✔
573	this.state = TokenizerStates.START;	32✔
574	this.onToken({	32✔
575	token: TokenType.FALSE,
576	value: false,
577	offset: this.offset,
578	});
579	this.offset += 4;	32✔
580	continue;	32✔
581	}
582	break;	2✔
583	// NULL
584	case TokenizerStates.NULL1:
585	if (n === charset.LATIN_SMALL_LETTER_U) {	22✔
586	this.state = TokenizerStates.NULL2;	20✔
587	continue;	20✔
588	}
589	break;	2✔
590	case TokenizerStates.NULL2:
591	if (n === charset.LATIN_SMALL_LETTER_L) {	20✔
592	this.state = TokenizerStates.NULL3;	18✔
593	continue;	18✔
594	}
595	break;	2✔
596	case TokenizerStates.NULL3:
597	if (n === charset.LATIN_SMALL_LETTER_L) {	18✔
598	this.state = TokenizerStates.START;	16✔
599	this.onToken({	16✔
600	token: TokenType.NULL,
601	value: null,
602	offset: this.offset,
603	});
604	this.offset += 3;	16✔
605	continue;	16✔
606	}
607	break;	2✔
608	case TokenizerStates.SEPARATOR:
609	this.separatorIndex += 1;	136✔
610	if (	136✔
611	!this.separatorBytes \|\|	272✔
612	n !== this.separatorBytes[this.separatorIndex]
613	) {
614	break;	2✔
615	}
616	if (this.separatorIndex === this.separatorBytes.length - 1) {	134✔
617	this.state = TokenizerStates.START;	36✔
618	this.onToken({	36✔
619	token: TokenType.SEPARATOR,
620	value: this.separator as string,
621	offset: this.offset + this.separatorIndex,
622	});
623	this.separatorIndex = 0;	36✔
624	}
625	continue;	134✔
626	case TokenizerStates.ENDED:
627	if (	18✔
628	n === charset.SPACE \|\|	60✔
629	n === charset.NEWLINE \|\|
630	n === charset.CARRIAGE_RETURN \|\|
631	n === charset.TAB
632	) {
633	// whitespace
634	continue;	6✔
635	}
636	}
637
638	throw new TokenizerError(	66✔
639	`Unexpected "${String.fromCharCode(
640	n
641	)}" at position "${i}" in state ${TokenizerStateToString(this.state)}`
642	);
643	}
644	// eslint-disable-next-line @typescript-eslint/no-explicit-any
645	} catch (err: any) {
646	this.error(err);	90✔
647	}
648	}
649
650	private emitNumber(): void {
651	this.onToken({	936✔
652	token: TokenType.NUMBER,
653	value: this.parseNumber(this.bufferedNumber.toString()),
654	offset: this.offset,
655	});
656	this.offset += this.bufferedNumber.byteLength - 1;	936✔
657	}
658
659	protected parseNumber(numberStr: string): number {
660	return Number(numberStr);	936✔
661	}
662
663	public error(err: Error): void {
664	if (this.state !== TokenizerStates.ENDED) {	132✔
665	this.state = TokenizerStates.ERROR;	110✔
666	}
667
668	this.onError(err);	132✔
669	}
670
671	public end(): void {
672	switch (this.state) {	320✔
673	case TokenizerStates.NUMBER_AFTER_INITIAL_ZERO:
674	case TokenizerStates.NUMBER_AFTER_INITIAL_NON_ZERO:
675	case TokenizerStates.NUMBER_AFTER_DECIMAL:
676	case TokenizerStates.NUMBER_AFTER_E_AND_DIGIT:
677	this.state = TokenizerStates.ENDED;	20✔
678	this.emitNumber();	20✔
679	this.onEnd();	20✔
680	break;	20✔
681	case TokenizerStates.START:
682	case TokenizerStates.ERROR:
683	case TokenizerStates.SEPARATOR:
684	this.state = TokenizerStates.ENDED;	286✔
685	this.onEnd();	286✔
686	break;	276✔
687	default:
688	this.error(	14✔
689	new TokenizerError(
690	`Tokenizer ended in the middle of a token (state: ${TokenizerStateToString(
691	this.state
692	)}). Either not all the data was received or the data was invalid.`
693	)
694	);
695	}
696	}
697
698	// eslint-disable-next-line @typescript-eslint/no-unused-vars
699	public onToken(parsedToken: ParsedTokenInfo): void {
700	// Override me
701	throw new TokenizerError(	2✔
702	'Can\'t emit tokens before the "onToken" callback has been set up.'
703	);
704	}
705
706	public onError(err: Error): void {
707	// Override me
708	throw err;	124✔
709	}
710
711	public onEnd(): void {
712	// Override me
713	}
714	}

juanjoDiaz / streamparser-json / 4996849698

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous