fix: make globals static so that they don't pollute downstream librar…

…ies (#42)

Also reorganized top level `let`s into static variables.

.prettierignore

@@ -1,2 +1,3 @@
 # prettier doesn't support decorators on functions :-(
-assembly/char.ts
+assembly/char.ts
+assembly/nfa/types.ts

asconfig.empty.json

@@ -0,0 +1,8 @@
+{
+ "options": {
+ "runtime": "stub",
+ "textFile": "build/empty.wat",
+ "debug": true
+ },
+ "entries": ["assembly/__tests__/empty.ts"]
+}

assembly/__tests__/empty.ts

@@ -0,0 +1 @@
+import * as regex from "..";

assembly/__tests__/empty.wat

@@ -0,0 +1,5 @@
+(module
+ (memory $0 0)
+ (table $0 1 funcref)
+ (export "memory" (memory $0))
+)

assembly/char.ts

@@ -1,3 +1,5 @@
+// @ts-ignore
+@lazy
 export const enum Char {
  None = -1,
  HorizontalTab = 0x09,

assembly/nfa/matcher.ts

@@ -16,10 +16,9 @@ const enum MatcherType {
  CharacterSet,
  CharacterClass,
 }
-
-let _flags: Flags;
-
 export class Matcher {
+ @lazy static _flags: Flags;
+
  constructor(readonly type: MatcherType) {}
 
  matches(code: u32): bool {
@@ -47,20 +46,23 @@ export class Matcher {
  node: CharacterClassNode,
  flags: Flags
  ): CharacterClassMatcher {
- _flags = flags;
+ Matcher._flags = flags;
  const matchers = node.expressions.map<Matcher>((exp) => {
  switch (exp.type) {
  case NodeType.CharacterRange:
  return Matcher.fromCharacterRangeNode(
  exp as CharacterRangeNode,
- _flags
+ Matcher._flags
  );
  case NodeType.Character:
- return Matcher.fromCharacterNode(exp as CharacterNode, _flags);
+ return Matcher.fromCharacterNode(
+ exp as CharacterNode,
+ Matcher._flags
+ );
  case NodeType.CharacterSet:
  return Matcher.fromCharacterClassNode(
  exp as CharacterSetNode,
- _flags
+ Matcher._flags
  );
  default:
  throw new Error("unsupported node type within character set");
@@ -93,9 +95,12 @@ export class CharacterMatcher extends Matcher {
  }
 }
 
-const LOWERCASE_LETTERS = new Range(Char.a, Char.z);
-const UPPERCASE_LETTERS = new Range(Char.A, Char.Z);
-const UPPER_LOWER_OFFSET = Char.a - Char.A;
+// @ts-ignore
+@lazy const LOWERCASE_LETTERS = new Range(Char.a, Char.z);
+// @ts-ignore
+@lazy const UPPERCASE_LETTERS = new Range(Char.A, Char.Z);
+// @ts-ignore
+@lazy const UPPER_LOWER_OFFSET = Char.a - Char.A;
 
 export class CharacterRangeMatcher extends Matcher {
  private ranges: Range[];

assembly/nfa/nfa.ts

@@ -14,21 +14,15 @@ import {
 import { Char } from "../char";
 import { Matcher } from "./matcher";
 import { Flags } from "../regexp";
-
-export enum MatchResult {
- // a match has occurred - which is a signal to consume a character
- Match,
- // a match failed, abort this regex
- Fail,
- // this state doesn't preform a match
- Ignore,
-}
-
-let _stateId: u32 = 0;
+import { MatchResult } from "./types";
 
 /* eslint @typescript-eslint/no-empty-function: ["error", { "allow": ["constructors", "methods"] }] */
 export class State {
- constructor(public transitions: State[] = [], public id: u32 = _stateId++) {}
+ @lazy static _stateId: u32 = 0;
+ constructor(
+ public transitions: State[] = [],
+ public id: u32 = State._stateId++
+ ) {}
 
  matches(input: string, position: u32): MatchResult {
  return MatchResult.Ignore;
@@ -253,3 +247,5 @@ class AutomataFactor {
  }
  }
 }
+
+export { MatchResult } from "./types";

assembly/nfa/types.ts

@@ -0,0 +1,10 @@
+// @ts-ignore
+@lazy
+export enum MatchResult {
+ // a match has occurred - which is a signal to consume a character
+ Match,
+ // a match failed, abort this regex
+ Fail,
+ // this state doesn't preform a match
+ Ignore,
+}

assembly/parser/node.ts

@@ -15,13 +15,12 @@ export const enum NodeType {
  Group,
 }
 
-const emptyNodeArray = new Array<Node>();
-
 export abstract class Node {
+ @lazy static readonly emptyArray: Node[] = new Array<Node>();
  constructor(public type: NodeType) {}
 
  children(): Node[] {
- return emptyNodeArray;
+ return Node.emptyArray;
  }
 
  abstract clone(): Node;
@@ -37,7 +36,7 @@ export class AST extends Node {
  }
 
  children(): Node[] {
- return this.body != null ? [this.body as Node] : emptyNodeArray;
+ return this.body != null ? [this.body as Node] : Node.emptyArray;
  }
 
  clone(): Node {
@@ -210,17 +209,17 @@ export class AlternationNode extends Node {
  }
 }
 
-let _id = 0;
-
 export class GroupNode extends Node {
+ @lazy static _id: i32 = 0;
+
  constructor(
  public expression: Node,
  public capturing: bool,
  public id: i32 = -1
  ) {
  super(NodeType.Group);
  if (id == -1) {
- this.id = _id++;
+ this.id = GroupNode._id++;
  }
  }
 

assembly/parser/walker.ts

@@ -34,10 +34,13 @@ export function walker(ast: AST, visitor: (node: NodeVisitor) => void): void {
  }
 }
 
-// range quantifiers are implemented via 'expansion', which significantly
-// increases the size of the AST. This imposes a hard limit to prevent
-// memory-related issues
-const QUANTIFIER_LIMIT = 1000;
+/**
+ range quantifiers are implemented via 'expansion', which significantly 
+ increases the size of the AST. This imposes a hard limit to prevent 
+ memory-related issues
+*/
+// @ts-ignore
+@lazy const QUANTIFIER_LIMIT = 1000;
 
 function parentAsConcatNode(visitor: NodeVisitor): ConcatenationNode {
  let concatNode: ConcatenationNode | null = null;

assembly/regexp.ts

@@ -69,8 +69,6 @@ export class Match {
  }
 }
 
-let gm = new Array<GroupStartMarkerState>();
-
 export class Flags {
  global: bool = false;
  ignoreCase: bool = false;
@@ -112,6 +110,7 @@ function lastCapturesForGroup(groupMarkers: GroupStartMarkerState[]): string[] {
 }
 
 export class RegExp {
+ @lazy static gm: GroupStartMarkerState[] = new Array<GroupStartMarkerState>();
  lastIndex: i32 = 0;
  private flags: Flags;
  private nfa: Automata;
@@ -136,16 +135,16 @@ export class RegExp {
  this.nfa = Automata.toNFA(ast, flags);
 
  // find all the group marker states
- gm = new Array<GroupStartMarkerState>();
+ RegExp.gm = new Array<GroupStartMarkerState>();
  nfaWalker(this.nfa.start, (state) => {
  if (state instanceof GroupStartMarkerState) {
  const startMarker = state as GroupStartMarkerState;
  if (startMarker.capturing) {
- gm.push(state as GroupStartMarkerState);
+ RegExp.gm.push(state as GroupStartMarkerState);
  }
  }
  });
- this.groupMarkers = gm;
+ this.groupMarkers = RegExp.gm;
 
  this.flags = flags;
  }