@travetto/transformer 3.0.0-rc.0 → 3.0.0-rc.10

package/src/resolver/coerce.ts

@@ -0,0 +1,103 @@
+const REGEX_PAT = /[\/](.*)[\/](i|g|m|s)?/;
+
+export class CoerceUtil {
+  /**
+   * Is a value a plain JS object, created using {}
+   */
+  static #isPlainObject(obj: unknown): obj is Record<string, unknown> {
+    return typeof obj === 'object' // separate from primitives
+      && obj !== undefined
+      && obj !== null         // is obvious
+      && obj.constructor === Object // separate instances (Array, DOM, ...)
+      && Object.prototype.toString.call(obj) === '[object Object]'; // separate build-in like Math
+  }
+
+  /**
+   * Create regex from string, including flags
+   */
+  static #toRegex(input: string | RegExp): RegExp {
+    if (input instanceof RegExp) {
+      return input;
+    } else if (REGEX_PAT.test(input)) {
+      const [, pat, mod] = input.match(REGEX_PAT) ?? [];
+      return new RegExp(pat, mod);
+    } else {
+      return new RegExp(input);
+    }
+  }
+
+  /**
+   * Coerce an input of any type to the class provided
+   * @param input Input value
+   * @param type Class to coerce to (String, Boolean, Number, Date, RegEx, Object)
+   * @param strict Should a failure to coerce throw an error?
+   */
+  static coerce(input: unknown, type: typeof String, strict?: boolean): string;
+  static coerce(input: unknown, type: typeof Number, strict?: boolean): number;
+  static coerce(input: unknown, type: typeof Boolean, strict?: boolean): boolean;
+  static coerce(input: unknown, type: typeof Date, strict?: boolean): Date;
+  static coerce(input: unknown, type: typeof RegExp, strict?: boolean): RegExp;
+  static coerce(input: unknown, type: Function, strict = true): unknown {
+    // Do nothing
+    if (input === null || input === undefined) {
+      return input;
+    } else if (!strict && type !== String && input === '') {
+      return undefined; // treat empty string as undefined for non-strings in non-strict mode
+    } else if (type && input instanceof type) {
+      return input;
+    }
+
+    switch (type) {
+      case Date: {
+        const res = typeof input === 'number' || /^[-]?\d+$/.test(`${input}`) ?
+          // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+          new Date(parseInt(input as string, 10)) : new Date(input as Date);
+        if (strict && Number.isNaN(res.getTime())) {
+          throw new Error(`Invalid date value: ${input}`);
+        }
+        return res;
+      }
+      case Number: {
+        const res = `${input}`.includes('.') ? parseFloat(`${input}`) : parseInt(`${input}`, 10);
+        if (strict && Number.isNaN(res)) {
+          throw new Error(`Invalid numeric value: ${input}`);
+        }
+        return res;
+      }
+      case Boolean: {
+        const match = `${input}`.match(/^((?<TRUE>true|yes|1|on)|false|no|off|0)$/i);
+        if (strict && !match) {
+          throw new Error(`Invalid boolean value: ${input}`);
+        }
+        return !!match?.groups?.TRUE;
+      }
+      case RegExp: {
+        if (typeof input === 'string') {
+          try {
+            return this.#toRegex(input);
+          } catch {
+            if (strict) {
+              throw new Error(`Invalid regex: ${input}`);
+            } else {
+              return;
+            }
+          }
+        } else if (strict) {
+          throw new Error('Invalid regex type');
+        } else {
+          return;
+        }
+      }
+      case Object: {
+        if (!strict || this.#isPlainObject(input)) {
+          return input;
+        } else {
+          throw new Error('Invalid object type');
+        }
+      }
+      case undefined:
+      case String: return `${input}`;
+    }
+    throw new Error(`Unknown type ${type.name}`);
+  }
+}

package/src/resolver/service.ts

@@ -1,9 +1,9 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
-import { AnyType, Checker } from './types';
+import type { AnyType, Checker } from './types';
 import { TypeCategorize, TypeBuilder } from './builder';
 import { VisitCache } from './cache';
-import { DocUtil } from '../util';
+import { DocUtil } from '../util/doc';
 
 /**
  * Type resolver

package/src/resolver/types.ts

@@ -1,4 +1,4 @@
-import type * as ts from 'typescript';
+import type ts from 'typescript';
 
 /**
  * Base type for a simplistic type structure
@@ -37,7 +37,7 @@ export interface ExternalType extends Type<'external'> {
   /**
    *  Location the type came from, for class references
    */
-  source: string;
+  importName: string;
   /**
    * Type arguments
    */
@@ -55,7 +55,7 @@ export interface ShapeType extends Type<'shape'> {
   /**
    *  Location the type came from, for class references
    */
-  source: string;
+  importName: string;
   /**
    * Does not include methods, used for shapes not concrete types
    */

package/src/state.ts

@@ -1,18 +1,20 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
-import { SystemUtil } from '@travetto/boot/src/internal/system';
-import { ModuleUtil } from '@travetto/boot/src/internal/module-util';
-import { Util } from '@travetto/base';
+import { path } from '@travetto/manifest';
 
 import { ExternalType, AnyType } from './resolver/types';
-import { State, DecoratorMeta, Transformer, TransformerId } from './types/visitor';
+import { State, DecoratorMeta, Transformer, ModuleNameⲐ } from './types/visitor';
 import { TypeResolver } from './resolver/service';
 import { ImportManager } from './importer';
+import { Import } from './types/shared';
+
 import { DocUtil } from './util/doc';
 import { DecoratorUtil } from './util/decorator';
 import { DeclarationUtil } from './util/declaration';
-import { CoreUtil, LiteralUtil } from './util';
-import { Import } from './types/shared';
+import { CoreUtil } from './util/core';
+import { LiteralUtil } from './util/literal';
+import { SystemUtil } from './util/system';
+import { TransformerIndex } from './manifest-index';
 
 function hasOriginal(n: unknown): n is { original: ts.Node } {
   // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
@@ -28,20 +30,22 @@ function hasEscapedName(n: unknown): n is { name: { escapedText: string } } {
  * Transformer runtime state
  */
 export class TransformerState implements State {
-  static SYNTHETIC_EXT = 'ᚕsyn';
+  static SYNTHETIC_EXT = 'Ⲑsyn';
 
   #resolver: TypeResolver;
   #imports: ImportManager;
+  #fileIdent: ts.Identifier;
   #syntheticIdentifiers = new Map<string, ts.Identifier>();
   #decorators = new Map<string, ts.PropertyAccessExpression>();
-
   added = new Map<number, ts.Statement[]>();
-  module: string;
+  importName: string;
+  file: string;
 
   constructor(public source: ts.SourceFile, public factory: ts.NodeFactory, checker: ts.TypeChecker) {
     this.#imports = new ImportManager(source, factory);
     this.#resolver = new TypeResolver(checker);
-    this.module = ModuleUtil.normalizePath(this.source.fileName);
+    this.file = path.toPosix(this.source.fileName);
+    this.importName = TransformerIndex.getImportName(this.file, true);
   }
 
   /**
@@ -62,8 +66,8 @@ export class TransformerState implements State {
   /**
    * Import a given file
    */
-  importFile(file: string): Import {
-    return this.#imports.importFile(file);
+  importFile(file: string, name?: string): Import {
+    return this.#imports.importFile(file, name);
   }
 
   /**
@@ -81,7 +85,9 @@ export class TransformerState implements State {
   resolveExternalType(node: ts.Node): ExternalType {
     const resolved = this.resolveType(node);
     if (resolved.key !== 'external') {
-      throw new Error(`Unable to import non-external type: ${node.getText()} ${resolved.key}: ${node.getSourceFile().fileName}`);
+      const file = node.getSourceFile().fileName;
+      const src = TransformerIndex.getImportName(file);
+      throw new Error(`Unable to import non-external type: ${node.getText()} ${resolved.key}: ${src}`);
     }
     return resolved;
   }
@@ -141,32 +147,33 @@ export class TransformerState implements State {
   /**
    * Read a decorator's metadata
    */
-  getDecoratorMeta(dec: ts.Decorator): DecoratorMeta {
+  getDecoratorMeta(dec: ts.Decorator): DecoratorMeta | undefined {
     const ident = DecoratorUtil.getDecoratorIdent(dec);
     const decl = DeclarationUtil.getPrimaryDeclarationNode(
       this.#resolver.getType(ident)
     );
-
-    return {
-      dec,
-      ident,
-      file: decl?.getSourceFile().fileName,
-      module: decl ? ModuleUtil.normalizePath(decl.getSourceFile().fileName) : undefined, // All #decorators will be absolute
-      targets: DocUtil.readAugments(this.#resolver.getType(ident)),
-      name: ident ?
-        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-        ident.escapedText! as string :
-        undefined
-    };
+    const src = decl?.getSourceFile().fileName;
+    const mod = src ? TransformerIndex.getImportName(src, true) : undefined;
+    const file = TransformerIndex.getFromImport(mod ?? '')?.outputFile;
+    const targets = DocUtil.readAugments(this.#resolver.getType(ident));
+    const module = file ? mod : undefined;
+    const name = ident ?
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      ident.escapedText! as string :
+      undefined;
+
+    if (ident && name) {
+      return { dec, ident, file, module, targets, name };
+    }
   }
 
   /**
    * Get list of all #decorators for a node
    */
   getDecoratorList(node: ts.Node): DecoratorMeta[] {
-    return (node.decorators ?? [])
+    return ts.canHaveDecorators(node) ? (ts.getDecorators(node) ?? [])
       .map(dec => this.getDecoratorMeta(dec))
-      .filter(x => !!x.ident);
+      .filter((x): x is DecoratorMeta => !!x) : [];
   }
 
   /**
@@ -181,44 +188,40 @@ export class TransformerState implements State {
    * @param stmt
    * @param before
    */
-  addStatement(stmt: ts.Statement, before?: ts.Node): void {
+  addStatements(added: ts.Statement[], before?: ts.Node | number): void {
     const stmts = this.source.statements.slice(0);
-    let idx = stmts.length;
-    let n = before;
-    if (hasOriginal(n)) {
-      n = n.original;
-    }
-    while (n && !ts.isSourceFile(n.parent)) {
-      n = n.parent;
-    }
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    const nStmt: ts.Statement = n as ts.Statement;
-    if (n && ts.isSourceFile(n.parent) && stmts.indexOf(nStmt) >= 0) {
-      idx = stmts.indexOf(nStmt) - 1;
+    let idx = stmts.length + 1000;
+
+    if (before && typeof before !== 'number') {
+      let n = before;
+      if (hasOriginal(n)) {
+        n = n.original;
+      }
+      while (n && !ts.isSourceFile(n.parent) && n !== n.parent) {
+        n = n.parent;
+      }
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const nStmt: ts.Statement = n as ts.Statement;
+      if (n && ts.isSourceFile(n.parent) && stmts.indexOf(nStmt) >= 0) {
+        idx = stmts.indexOf(nStmt) - 1;
+      }
+    } else if (before !== undefined) {
+      idx = before;
     }
     if (!this.added.has(idx)) {
       this.added.set(idx, []);
     }
-    this.added.get(idx)!.push(stmt);
+    this.added.get(idx)!.push(...added);
   }
 
   /**
    * Finalize the source file for emission
    */
   finalize(ret: ts.SourceFile): ts.SourceFile {
-    ret = this.#imports.finalize(ret);
+    ret = this.#imports.finalize(ret, this.#resolver.getChecker());
     return ret;
   }
 
-  /**
-   * Get Filename as ᚕsrc
-   */
-  getFilenameAsSrc(): ts.CallExpression {
-    const ident = this.factory.createIdentifier('ᚕsrc');
-    ident.getSourceFile = (): ts.SourceFile => this.source;
-    return this.factory.createCallExpression(ident, [], [this.createIdentifier('__filename')]);
-  }
-
   /**
    * From literal
    */
@@ -243,7 +246,7 @@ export class TransformerState implements State {
   /**
    * Create property access
    */
-  createAccess(first: string | ts.Expression, second: string | ts.Identifier, ...items: (string | ts.Identifier)[]): ts.PropertyAccessExpression {
+  createAccess(first: string | ts.Expression, second: string | ts.Identifier, ...items: (string | number | ts.Identifier)[]): ts.Expression {
     return CoreUtil.createAccess(this.factory, first, second, ...items);
   }
 
@@ -262,6 +265,22 @@ export class TransformerState implements State {
     return this.factory.createIdentifier(typeof name === 'string' ? name : name.getText());
   }
 
+  /**
+   * Get filename identifier, regardless of module system
+   */
+  getFilenameIdentifier(): ts.Expression {
+    if (this.#fileIdent === undefined) {
+      this.#fileIdent = this.createIdentifier('ᚕf');
+      const decl = this.factory.createVariableDeclaration(this.#fileIdent, undefined, undefined,
+        this.fromLiteral(TransformerIndex.getImportName(this.source.fileName) ?? this.source.fileName)
+      );
+      this.addStatements([
+        this.factory.createVariableStatement([], this.factory.createVariableDeclarationList([decl]))
+      ], -1);
+    }
+    return this.#fileIdent;
+  }
+
   /**
    * Find decorator, relative to registered key
    * @param state
@@ -269,10 +288,11 @@ export class TransformerState implements State {
    * @param name
    * @param module
    */
-  findDecorator(cls: Transformer, node: ts.Node, name: string, module?: string): ts.Decorator | undefined {
-    const target = `${cls[TransformerId]}/${name}`;
-    return this.getDecoratorList(node)
-      .find(x => x.targets?.includes(target) && (!module || x.name === name && x.module === module))?.dec;
+  findDecorator(mod: string | Transformer, node: ts.Node, name: string, module?: string): ts.Decorator | undefined {
+    mod = typeof mod === 'string' ? mod : mod[ModuleNameⲐ]!;
+    const target = `${mod}:${name}`;
+    const list = this.getDecoratorList(node);
+    return list.find(x => x.targets?.includes(target) && (!module || x.name === name && x.module === module))?.dec;
   }
 
   /**
@@ -291,7 +311,7 @@ export class TransformerState implements State {
       }
     } catch {
       // Determine type unique ident
-      unique = Util.uuid(type.name ? 5 : 10);
+      unique = SystemUtil.uuid(type.name ? 5 : 10);
     }
     // Otherwise read name with uuid
     let name = type.name && !type.name.startsWith('_') ? type.name : '';

package/src/types/shared.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript';
+import type ts from 'typescript';
 
 /**
  * Param documentation

package/src/types/visitor.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
 /**
  * Decorator metadata
@@ -14,7 +14,7 @@ export type DecoratorMeta = {
 
 export type State = {
   source: ts.SourceFile;
-  module: string;
+  importName: string;
   added: Map<number, ts.Statement[]>;
   getDecoratorList(node: ts.Node): DecoratorMeta[];
   finalize(src: ts.SourceFile): ts.SourceFile;
@@ -22,12 +22,14 @@ export type State = {
 
 export type TransformPhase = 'before' | 'after';
 
-export type TransformerType = 'class' | 'method' | 'property' | 'getter' | 'setter' | 'parameter' | 'static-method' | 'call' | 'function';
+export type TransformerType =
+  'class' | 'method' | 'property' | 'getter' | 'setter' | 'parameter' |
+  'static-method' | 'call' | 'function' | 'file';
 
-export const TransformerId = Symbol.for('@trv:transformer/id');
+export const ModuleNameⲐ = Symbol.for('@travetto/transformer:id');
 
 export type Transformer = {
-  [TransformerId]: string;
+  [ModuleNameⲐ]?: string;
   name: string;
 };
 

package/src/util/core.ts

@@ -1,9 +1,10 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
 /**
  * Core utilities util
  */
 export class CoreUtil {
+
   /**
    * See if inbound node has an original property
    */
@@ -51,7 +52,6 @@ export class CoreUtil {
    */
   static createStaticField(factory: ts.NodeFactory, name: string, val: ts.Expression): ts.PropertyDeclaration {
     return factory.createPropertyDeclaration(
-      undefined,
       [factory.createToken(ts.SyntaxKind.StaticKeyword)],
       name, undefined, undefined, val
     );
@@ -88,13 +88,15 @@ export class CoreUtil {
     factory: ts.NodeFactory,
     first: string | ts.Expression,
     second: string | ts.Identifier,
-    ...items: (string | ts.Identifier)[]
-  ): ts.PropertyAccessExpression {
+    ...items: (string | number | ts.Identifier)[]
+  ): ts.Expression {
     if (typeof first === 'string') {
       first = factory.createIdentifier(first);
     }
-    return items.reduce(
-      (acc, p) => factory.createPropertyAccessExpression(acc, p),
+    return items.reduce<ts.Expression>(
+      (acc, p) => typeof p === 'number' ?
+        factory.createElementAccessExpression(acc, p) :
+        factory.createPropertyAccessExpression(acc, p),
       factory.createPropertyAccessExpression(first, second)
     );
   }

package/src/util/declaration.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 import { CoreUtil } from './core';
 
 /**
@@ -57,8 +57,8 @@ export class DeclarationUtil {
    * Resolve the `ts.ObjectFlags`
    */
   static getObjectFlags(type: ts.Type): ts.ObjectFlags {
-    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
-    return (ts as unknown as { getObjectFlags(t: ts.Type): ts.ObjectFlags }).getObjectFlags(type);
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions, no-bitwise
+    return (ts as unknown as { getObjectFlags(t: ts.Type): ts.ObjectFlags }).getObjectFlags(type) & ~(ts.NodeFlags.ThisNodeOrAnySubNodesHasError);
   }
 
   /**

package/src/util/decorator.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 import { CoreUtil } from './core';
 
 /**
@@ -24,11 +24,14 @@ export class DecoratorUtil {
   /**
    * Replace or add a decorator to a list of decorators
    */
-  static spliceDecorators(node: ts.Node, target: ts.Decorator | undefined, replacements: ts.Decorator[], idx = -1): ts.Decorator[] {
+  static spliceDecorators(node: ts.Node, target: ts.Decorator | undefined, replacements: ts.Decorator[], idx = -1): ts.ModifierLike[] {
+    if (!ts.canHaveDecorators(node)) {
+      return [];
+    }
     if (idx < 0 && target) {
-      idx = node.decorators?.indexOf(target) ?? -1;
+      idx = node.modifiers?.indexOf(target) ?? -1;
     }
-    const out = (node.decorators ?? []).filter(x => x !== target);
+    const out = (node.modifiers ?? []).filter(x => x !== target);
     if (idx < 0) {
       out.push(...replacements);
     } else {

package/src/util/doc.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
 import { DeclDocumentation } from '../types/shared';
 import { CoreUtil } from './core';

package/src/util/import.ts

@@ -1,7 +1,6 @@
-import * as ts from 'typescript';
-import { resolve as pathResolve } from 'path';
+import ts from 'typescript';
 
-import { PathUtil } from '@travetto/boot';
+import { PackageUtil, path } from '@travetto/manifest';
 
 import { Import } from '../types/shared';
 
@@ -13,9 +12,17 @@ export class ImportUtil {
    * useful for handling failed imports, but still transpiling
    */
   static optionalResolve(file: string, base?: string): string {
-    file = base ? pathResolve(base, file) : file;
+    if (base?.endsWith('.ts')) {
+      base = path.dirname(base);
+    }
+    if (base && file.startsWith('.')) {
+      return path.resolve(base, file);
+      // TODO: Replace with manifest reverse lookup
+    } else if (file.startsWith('@')) {
+      return path.resolve('node_modules', file);
+    }
     try {
-      return require.resolve(file);
+      return PackageUtil.resolveImport(file);
     } catch {
       return file;
     }
@@ -25,23 +32,23 @@ export class ImportUtil {
    * Collect all imports for a source file, as a hash map
    */
   static collectImports(src: ts.SourceFile): Map<string, Import> {
-    const pth = require.resolve(src.fileName);
-    const base = PathUtil.toUnix(pth);
+    // TODO: Replace with manifest reverse lookup
+    const base = path.toPosix(src.fileName);
 
     const imports = new Map<string, Import>();
 
     for (const stmt of src.statements) {
       if (ts.isImportDeclaration(stmt) && ts.isStringLiteral(stmt.moduleSpecifier)) {
-        const path = this.optionalResolve(stmt.moduleSpecifier.text, base);
+        const resolved = this.optionalResolve(stmt.moduleSpecifier.text, base);
 
         if (stmt.importClause) {
           if (stmt.importClause.namedBindings) {
             const bindings = stmt.importClause.namedBindings;
             if (ts.isNamespaceImport(bindings)) {
-              imports.set(bindings.name.text, { path, ident: bindings.name, stmt });
+              imports.set(bindings.name.text, { path: resolved, ident: bindings.name, stmt });
             } else if (ts.isNamedImports(bindings)) {
               for (const n of bindings.elements) {
-                imports.set(n.name.text, { path, ident: n.name, stmt });
+                imports.set(n.name.text, { path: resolved, ident: n.name, stmt });
               }
             }
           }

package/src/util/literal.ts

@@ -1,4 +1,4 @@
-import * as ts from 'typescript';
+import ts from 'typescript';
 
 /**
  * Utilities for dealing with literals
@@ -48,7 +48,8 @@ export class LiteralUtil {
       // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
       const ov = val as object;
       const pairs: ts.PropertyAssignment[] = [];
-      for (const k of Object.keys(ov)) {
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      for (const k of Object.keys(ov) as (keyof typeof ov)[]) {
         if (ov[k] !== undefined) {
           pairs.push(
             factory.createPropertyAssignment(k, this.fromLiteral(factory, ov[k]))

package/src/util/log.ts

@@ -1,5 +1,3 @@
-import { Util } from '@travetto/base';
-
 const exclude = new Set([
   'parent', 'checker', 'end', 'pos', 'id', 'source', 'sourceFile', 'getSourceFile',
   'statements', 'stringIndexInfo', 'numberIndexInfo', 'instantiations', 'thisType',
@@ -22,7 +20,7 @@ export class LogUtil {
    * Clean up `ts.Node` contents for logging
    */
   static collapseNode(x: unknown, cache: Set<unknown> = new Set()): unknown {
-    if (!x || Util.isPrimitive(x)) {
+    if (!x || !(typeof x === 'object' || typeof x === 'function')) {
       return x;
     }
 
@@ -39,7 +37,7 @@ export class LogUtil {
       const ox = x as object;
       const out: Record<string, unknown> = {};
       for (const key of Object.keys(ox)) {
-        if (Util.isFunction(ox[key]) || exclude.has(key) || ox[key] === undefined) {
+        if (Object.getPrototypeOf(ox[key]) === Function.prototype || exclude.has(key) || ox[key] === undefined) {
           continue;
         }
         try {

package/src/util/system.ts

@@ -0,0 +1,31 @@
+import crypto from 'crypto';
+
+export class SystemUtil {
+
+  /**
+   * Generate a random UUID
+   * @param len The length of the uuid to generate
+   */
+  static uuid(len: number = 32): string {
+    const bytes = crypto.randomBytes(Math.ceil(len / 2));
+    // eslint-disable-next-line no-bitwise
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    // eslint-disable-next-line no-bitwise
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    return bytes.toString('hex').substring(0, len);
+  }
+
+  /**
+   * Naive hashing
+   */
+  static naiveHash(text: string): number {
+    let hash = 5381;
+
+    for (let i = 0; i < text.length; i++) {
+      // eslint-disable-next-line no-bitwise
+      hash = (hash * 33) ^ text.charCodeAt(i);
+    }
+
+    return Math.abs(hash);
+  }
+}