diff --git a/voca/index.d.ts b/voca/index.d.ts
new file mode 100644
index 0000000000..7a7fa6e6c5
--- /dev/null
+++ b/voca/index.d.ts
@@ -0,0 +1,304 @@
+// Type definitions for Voca 1.2
+// Project: https://vocajs.com/
+// Definitions by: Pine Mizune <https://github.com/pine>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+declare var v: v.VocaStatic;
+
+export = v;
+export as namespace v;
+
+declare namespace v {
+    type CountPredicate = (character: string, index: number, str: string) => boolean;
+    type ReplacementFunction = (match?: string, ...groups: string[]) => string;
+
+    interface WordWrapOptions {
+        width?: number;
+        newLine?: string;
+        indent?: string;
+        cut?: boolean;
+    }
+
+    interface VocaStatic {
+        // Case
+        camelCase(subject?: string): string;
+        capitalize(subject?: string, restToLower?: boolean): string;
+        decapitalize(subject?: string): string;
+        kebabCase(subject?: string): string;
+        lowerCase(subject?: string): string;
+        snakeCase(subject?: string): string;
+        titleCase(subject?: string, ignoreWords?: string[]): string;
+        upperCase(subject?: string): string;
+
+        // Chain
+        (subject: any): Chain;
+        chain<T>(subject: T): ExplicitChain<T>;
+
+        // Chop
+        charAt(subject?: string, position?: number): string;
+        codePointAt(subject?: string, position?: number): string;
+        first(subject?: string, length?: number): string;
+        graphemeAt(subject?: string, position?: number): string;
+        last(subject?: string, length?: number): string;
+        prune(subject?: string, length?: number, end?: string): string;
+        slice(subject?: string, start?: number, end?: number): string;
+        substr(subject?: string, start?: number, length?: number): string;
+        substring(subject?: string, start?: number, end?: number): string;
+        truncate(subject?: string, length?: number, end?: string): string;
+
+        // Count
+        count(subject?: string): number;
+        countGraphemes(subject?: string): number;
+        countSubstrings(subject?: string, substring?: string): number;
+        countWhere(subject?: string, predicate?: CountPredicate, context?: any): number;
+        countWords(subject?: string, pattern?: string|RegExp, flags?: string): number;
+
+        // Escape
+        escapeHtml(subject?: string): string;
+        escapeRegExp(subject?: string): string;
+        unescapeHtml(subject?: string): string;
+
+        // Format
+        sprintf(format?: string, ...replacements: any[]): string;
+        vprintf(format?: string, ...replacements: any[]): string;
+
+        // Index
+        indexOf(subject?: string, search?: string, fromIndex?: number): number;
+        lastIndexOf(subject?: string, search?: string, fromIndex?: number): number;
+        search(subject?: string, pattern?: string|RegExp, fromIndex?: number): number;
+
+        // Manipulate
+        insert(subject?: string, toInsert?: string, position?: number): string;
+        latinise(subject?: string): string;
+        pad(subject?: string, length?: number, pad?: string): string;
+        padLeft(subject?: string, length?: number, pad?: string): string;
+        padRight(subject?: string, length?: number, pad?: string): string;
+        repeat(subject?: string, times?: number): string;
+        replace(subject?: string, pattern?: string|RegExp, replacement?: string|ReplacementFunction): string;
+        replaceAll(subject?: string, pattern?: string|RegExp, replacement?: string|ReplacementFunction): string;
+        reverse(subject?: string): string;
+        reverseGrapheme(subject?: string): string;
+        slugify(subject?: string): string;
+        splice(subject?: string, start?: number, deleteCount?: number, toAdd?: string): string;
+        trim(subject?: string, whitespace?: string): string;
+        trimLeft(subject?: string, whitespace?: string): string;
+        trimRight(subject?: string, whitespace?: string): string;
+        wordWrap(subject?: string, options?: WordWrapOptions): string;
+
+        // Query
+        endsWith(subject?: string, end?: string, position?: number): boolean;
+        includes(subject?: string, search?: string, position?: number): boolean;
+        isAlpha(subject?: string): boolean;
+        isAlphaDigit(subject?: string): boolean;
+        isBlank(subject?: string): boolean;
+        isDigit(subject?: string): boolean;
+        isEmpty(subject?: string): boolean;
+        isLowerCase(subject?: string): boolean;
+        isNumeric(subject?: string): boolean;
+        isString(subject?: any): boolean;
+        isUpperCase(subject?: string): boolean;
+        matches(subject?: string, pattern?: string|RegExp, flags?: string): boolean;
+        startsWith(subject?: string, start?: string, position?: number): boolean;
+
+        // Split
+        chars(subject?: string): string[];
+        codePoints(subject?: string): number[];
+        graphemes(subject?: string): string[];
+        split(subject?: string, separator?: string|RegExp, limit?: number): string[];
+        words(subject?: string, pattern?: string|RegExp, flag?: string): string[];
+
+        // Strip
+        stripBom(subject?: string): string;
+        stripTags(subject?: string, allowbleTags?: string|string[], replacement?: string): string;
+
+        // Util
+        noConflict(): VocaStatic;
+        version: string;
+    }
+
+    interface Chain {
+        // Case
+        camelCase(): Chain;
+        capitalize(restToLoweropt?: boolean): Chain;
+        decapitalize(): Chain;
+        kebabCase(): Chain;
+        lowerCase(): Chain;
+        snakeCase(): Chain;
+        titleCase(ignoreWordsopt?: string[]): Chain;
+        upperCase(): Chain;
+
+        // Chain
+        value(): string;
+        chain(): ExplicitChain<string>;
+
+        // Chop
+        charAt(position?: number): Chain;
+        codePointAt(position?: number): Chain;
+        first(length?: number): Chain;
+        graphemeAt(position?: number): Chain;
+        last(length?: number): Chain;
+        prune(length?: number, end?: string): Chain;
+        slice(start?: number, end?: number): Chain;
+        substr(start?: number, length?: number): Chain;
+        substring(start?: number, end?: number): Chain;
+        truncate(length?: number, end?: string): Chain;
+
+        // Count
+        count(): number;
+        countGraphemes(): number;
+        countSubstrings(substring?: string): number;
+        countWhere(predicate?: CountPredicate, context?: any): number;
+        countWords(pattern?: string|RegExp, flags?: string): number;
+
+        // Escape
+        escapeHtml(): Chain;
+        escapeRegExp(): Chain;
+        unescapeHtml(): Chain;
+
+        // Format
+        sprintf(...replacements: any[]): Chain;
+        vprintf(...replacements: any[]): Chain;
+
+        // Index
+        indexOf(search?: string, fromIndex?: number): number;
+        lastIndexOf(search?: string, fromIndex?: number): number;
+        search(pattern?: string|RegExp, fromIndex?: number): number;
+
+        // Multipulate
+        insert(toInsert?: string, position?: number): Chain;
+        latinise(): Chain;
+        pad(length?: number, pad?: string): Chain;
+        padLeft(length?: number, pad?: string): Chain;
+        padRight(length?: number, pad?: string): Chain;
+        repeat(times?: number): Chain;
+        replace(pattern?: string|RegExp, replacement?: string|ReplacementFunction): Chain;
+        replaceAll(pattern?: string|RegExp, replacement?: string|ReplacementFunction): Chain;
+        reverse(): Chain;
+        reverseGrapheme(): Chain;
+        slugify(): Chain;
+        splice(start?: number, deleteCount?: number, toAdd?: string): Chain;
+        trim(whitespace?: string): Chain;
+        trimLeft(whitespace?: string): Chain;
+        trimRight(whitespace?: string): Chain;
+        wordWrap(options?: WordWrapOptions): Chain;
+
+        // Query
+        endsWith(end?: string, position?: number): boolean;
+        includes(search?: string, position?: number): boolean;
+        isAlpha(): boolean;
+        isAlphaDigit(): boolean;
+        isBlank(): boolean;
+        isDigit(): boolean;
+        isEmpty(): boolean;
+        isLowerCase(): boolean;
+        isNumeric(): boolean;
+        isString(): boolean;
+        isUpperCase(): boolean;
+        matches(pattern?: string|RegExp, flags?: string): boolean;
+        startsWith(start?: string, position?: number): boolean;
+
+        // Split
+        chars(): string[];
+        codePoints(): number[];
+        graphemes(): string[];
+        split(separator?: string|RegExp, limit?: number): string[];
+        words(pattern?: string|RegExp, flag?: string): string[];
+
+        // Strip
+        stripBom(): Chain;
+        stripTags(allowbleTags?: string|string[], replacement?: string): Chain;
+    }
+
+    interface ExplicitChain<T> {
+        // Case
+        camelCase(): ExplicitChain<string>;
+        capitalize(restToLoweropt?: boolean): ExplicitChain<string>;
+        decapitalize(): ExplicitChain<string>;
+        kebabCase(): ExplicitChain<string>;
+        lowerCase(): ExplicitChain<string>;
+        snakeCase(): ExplicitChain<string>;
+        titleCase(ignoreWordsopt?: string[]): ExplicitChain<string>;
+        upperCase(): ExplicitChain<string>;
+
+        // Chain
+        value(): T;
+        thru<U>(changer: (subjects: T) => U): ExplicitChain<U>;
+
+        // Chop
+        charAt(position?: number): ExplicitChain<string>;
+        codePointAt(position?: number): ExplicitChain<string>;
+        first(length?: number): ExplicitChain<string>;
+        graphemeAt(position?: number): ExplicitChain<string>;
+        last(length?: number): ExplicitChain<string>;
+        prune(length?: number, end?: string): ExplicitChain<string>;
+        slice(start?: number, end?: number): ExplicitChain<string>;
+        substr(start?: number, length?: number): ExplicitChain<string>;
+        substring(start?: number, end?: number): ExplicitChain<string>;
+        truncate(length?: number, end?: string): ExplicitChain<string>;
+
+        // Count
+        count(): ExplicitChain<number>;
+        countGraphemes(): ExplicitChain<number>;
+        countSubstrings(substring?: string): ExplicitChain<number>;
+        countWhere(predicate?: CountPredicate, context?: any): ExplicitChain<number>;
+        countWords(pattern?: string|RegExp, flags?: string): ExplicitChain<number>;
+
+        // Escape
+        escapeHtml(): ExplicitChain<string>;
+        escapeRegExp(): ExplicitChain<string>;
+        unescapeHtml(): ExplicitChain<string>;
+
+        // Format
+        sprintf(...replacements: any[]): ExplicitChain<string>;
+        vprintf(...replacements: any[]): ExplicitChain<string>;
+
+        // Index
+        indexOf(search?: string, fromIndex?: number): ExplicitChain<number>;
+        lastIndexOf(search?: string, fromIndex?: number): ExplicitChain<number>;
+        search(pattern?: string|RegExp, fromIndex?: number): ExplicitChain<number>;
+
+        // Multipulate
+        insert(toInsert?: string, position?: number): ExplicitChain<string>;
+        latinise(): ExplicitChain<string>;
+        pad(length?: number, pad?: string): ExplicitChain<string>;
+        padLeft(length?: number, pad?: string): ExplicitChain<string>;
+        padRight(length?: number, pad?: string): ExplicitChain<string>;
+        repeat(times?: number): ExplicitChain<string>;
+        replace(pattern?: string|RegExp, replacement?: string|ReplacementFunction): ExplicitChain<string>;
+        replaceAll(pattern?: string|RegExp, replacement?: string|ReplacementFunction): ExplicitChain<string>;
+        reverse(): ExplicitChain<string>;
+        reverseGrapheme(): ExplicitChain<string>;
+        slugify(): ExplicitChain<string>;
+        splice(start?: number, deleteCount?: number, toAdd?: string): ExplicitChain<string>;
+        trim(whitespace?: string): ExplicitChain<string>;
+        trimLeft(whitespace?: string): ExplicitChain<string>;
+        trimRight(whitespace?: string): ExplicitChain<string>;
+        wordWrap(options?: WordWrapOptions): ExplicitChain<string>;
+
+        // Query
+        endsWith(end?: string, position?: number): ExplicitChain<boolean>;
+        includes(search?: string, position?: number): ExplicitChain<boolean>;
+        isAlpha(): ExplicitChain<boolean>;
+        isAlphaDigit(): ExplicitChain<boolean>;
+        isBlank(): ExplicitChain<boolean>;
+        isDigit(): ExplicitChain<boolean>;
+        isEmpty(): ExplicitChain<boolean>;
+        isLowerCase(): ExplicitChain<boolean>;
+        isNumeric(): ExplicitChain<boolean>;
+        isString(): ExplicitChain<boolean>;
+        isUpperCase(): ExplicitChain<boolean>;
+        matches(pattern?: string|RegExp, flags?: string): ExplicitChain<boolean>;
+        startsWith(start?: string, position?: number): ExplicitChain<boolean>;
+
+        // Split
+        chars(): ExplicitChain<string[]>;
+        codePoints(): ExplicitChain<number[]>;
+        graphemes(): ExplicitChain<string[]>;
+        split(separator?: string|RegExp, limit?: number): ExplicitChain<string[]>;
+        words(pattern?: string|RegExp, flag?: string): ExplicitChain<string[]>;
+
+        // Strip
+        stripBom(): ExplicitChain<string>;
+        stripTags(allowbleTags?: string|string[], replacement?: string): ExplicitChain<string>;
+    }
+}
diff --git a/voca/tsconfig.json b/voca/tsconfig.json
new file mode 100644
index 0000000000..e7cd2ff035
--- /dev/null
+++ b/voca/tsconfig.json
@@ -0,0 +1,23 @@
+
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "voca-tests.ts"
+    ]
+}
diff --git a/voca/tslint.json b/voca/tslint.json
new file mode 100644
index 0000000000..377cc837d4
--- /dev/null
+++ b/voca/tslint.json
@@ -0,0 +1 @@
+{ "extends": "../tslint.json" }
diff --git a/voca/voca-tests.ts b/voca/voca-tests.ts
new file mode 100644
index 0000000000..3fb9d100c3
--- /dev/null
+++ b/voca/voca-tests.ts
@@ -0,0 +1,331 @@
+import v = require('voca');
+
+var str: string;
+var num: number
+var bool: boolean;
+var strAry: string[];
+var numAry: number[];
+
+// Case
+str = v.camelCase();
+str = v.camelCase('bird flight');
+str = v('bird flight').camelCase().value();
+str = v.chain('bird flight').camelCase().value();
+
+str = v.capitalize();
+str = v.capitalize('apple');
+str = v.capitalize('aPPle', true);
+str = v('apple').capitalize().value();
+str = v('apple').capitalize(true).value();
+str = v.chain('apple').capitalize(true).value();
+
+str = v.decapitalize('Sun');
+str = v.kebabCase('goodbye blue sky');
+str = v.lowerCase('Green');
+str = v.snakeCase('learning to fly');
+str = v.titleCase('learning to fly');
+str = v.titleCase('another brick in the wall', ['in', 'the']);
+str = v.upperCase('school');
+
+// Chain
+strAry = v('Back to School')
+    .lowerCase()
+    .words();
+str = v(" Back to School ")
+    .trim()
+    .truncate(7)
+    .value();
+
+strAry = v
+    .chain('Back to School')
+    .lowerCase()
+    .words()
+    .value();
+
+strAry = v('Back to School')
+     .chain()
+     .lowerCase()
+     .words()
+     .value();
+str = v(" Back to School ")
+    .chain()
+    .trim()
+    .truncate(7)
+    .value();
+
+str = v
+    .chain('sun is shining')
+    .words()
+    .thru((words: string[]) => {
+        return words[0];
+    })
+    .value();
+
+str = v
+    .chain('Hello world')
+    .replace('Hello', 'Hi')
+    .lowerCase()
+    .slugify()
+    .value();
+str = v(' Space travel ')
+    .trim()
+    .truncate(8)
+    .value();
+
+// Chop
+str = v.charAt('helicopter', 0);
+str = v('helicopter').charAt(0).value();
+str = v.chain('helicopter').charAt(0).value();
+
+str = v.codePointAt('rain', 1);
+str = v.first('helicopter');
+str = v.first('vehicle', 2);
+str = v.graphemeAt('\uD835\uDC00\uD835\uDC01', 0);
+str = v.last('helicopter');
+str = v.last('vehicle', 2);
+str = v.prune('Once upon a time', 7);
+str = v.prune('Good day, Little Red Riding Hood', 16, ' (more)');
+str = v.slice('miami', 1);
+str = v.slice('florida', 1, 4);
+str = v.substr('infinite loop', 9);
+str = v.substr('dreams', 2, 2);
+str = v.substring('beach', 1);
+str = v.substring('ocean', 1, 3);
+str = v.truncate('Once upon a time', 7);
+str = v.truncate('Good day, Little Red Riding Hood', 14, ' (...)');
+
+// Count
+num = v.count();
+num = v.count('rain');
+num = v('rain').count();
+num = v.chain('rain').count().value();
+
+num = v.countGraphemes('cafe\u0301');
+num = v.countSubstrings('bad boys, bad boys whatcha gonna do?', 'boys');
+num = v.countWhere('hola!', v.isAlpha);
+num = v.countWhere('2022', (character: string, index: number, str: string) => {
+    return character === '2';
+});
+num = v.countWords('gravity can cross dimensions');
+
+// Escape
+str = v.escapeHtml();
+str = v.escapeHtml('<p>wonderful world</p>');
+str = v('<p>wonderful world</p>').escapeHtml().value();
+str = v.chain('<p>wonderful world</p>').escapeHtml().value();
+
+str = v.escapeRegExp();
+str = v.escapeRegExp('(hours)[minutes]{seconds}');
+str = v('(hours)[minutes]{seconds}').escapeRegExp().value();
+str = v.chain('(hours)[minutes]{seconds}').escapeRegExp().value();
+
+str = v.unescapeHtml();
+str = v.unescapeHtml('&lt;p&gt;wonderful world&lt;/p&gt;');
+str = v('&lt;p&gt;wonderful world&lt;/p&gt;').unescapeHtml().value();
+str = v.chain('&lt;p&gt;wonderful world&lt;/p&gt;').unescapeHtml().value();
+
+// Format
+str = v.sprintf();
+str = v.sprintf('%s, %s!', 'Hello', 'World');
+str = v.sprintf('%s costs $%d', 'coffee', 2);
+str = v.sprintf('%1$s %2$s %1$s %2$s, watcha gonna %3$s', 'bad', 'boys', 'do')
+str = v.sprintf('% 6s', 'bird');
+str = v.sprintf('%d %i %+d', 15, -2, 25);
+str = v.sprintf("%06d", 15);
+str = v.sprintf('%.2e %g', 100.5, 0.455);
+str = v('%s, %s!').sprintf('Hello', 'World').value();
+str = v.chain('%s, %s!').sprintf('Hello', 'World').value();
+
+str = v.vprintf();
+str = v.vprintf('%s', ['Welcome'])
+str = v.vprintf('%s has %d apples', ['Alexandra', 3]);
+str = v('%s').vprintf(['Welcome']).value();
+str = v.chain('%s').vprintf(['Welcome']).value();
+
+// Index
+num = v.indexOf();
+num = v.indexOf('morning');
+num = v.indexOf('morning', 'n');
+num = v('morning').indexOf('n');
+num = v.chain('morning').indexOf('n').value();
+
+num = v.lastIndexOf();
+num = v.lastIndexOf('morning');
+num = v.lastIndexOf('morning', 'n');
+num = v('morning').lastIndexOf('n');
+num = v.chain('morning').lastIndexOf('n').value();
+
+num = v.search('morning', /rn/);
+num = v.search('evening', '/\d/');
+
+// Manipulate
+str = v.insert();
+str = v.insert('ct');
+str = v.insert('ct', 'a');
+str = v.insert('ct', 'a', 1);
+str = v('ct').insert('a', 1).value();
+str = v.chain('ct').insert('a', 1).value();
+
+str = v.latinise();
+str = v.latinise('cafe\u0301');
+
+str = v.pad();
+str = v.pad('dog');
+str = v.pad('dog', 5);
+str = v.pad('bird', 6, '-');
+
+str = v.padLeft();
+str = v.padLeft('dog');
+str = v.padLeft('dog', 5);
+str = v.padLeft('bird', 6, '-');
+
+str = v.padRight();
+str = v.padRight('dog');
+str = v.padRight('dog', 5);
+str = v.padRight('bird', 6, '-');
+
+str = v.repeat();
+str = v.repeat('w');
+str = v.repeat('w', 3);
+
+str = v.replace();
+str = v.replace('swan', 'wa', 'u');
+str = v.replace('domestic duck', /domestic\s/, '');
+str = v.replace('nice duck', /(nice)(duck)/, (match: string, nice: string, duck: string) => {
+    return 'the ' + duck + ' is ' + nice;
+});
+
+str = v.replaceAll();
+str = v.replaceAll('good morning', 'o', '*');
+str = v.replaceAll('evening', /n/, 's');
+
+str = v.reverse();
+str = v.reverse('winter');
+
+str = v.reverseGrapheme();
+str = v.reverseGrapheme('summer');
+
+str = v.slugify();
+str = v.slugify('Italian cappuccino drink');
+
+str = v.splice();
+str = v.splice('new year');
+str = v.splice('new year', 0);
+str = v.splice('new year', 0, 4);
+str = v.splice('new year', 0, 3, 'happy');
+
+str = v.trim();
+str = v.trim(' Mother nature ');
+str = v.trim('--Earth--', '-');
+
+str = v.trimLeft();
+str = v.trimLeft('  Starship Troopers');
+str = v.trimLeft('***Mobile Infantry', '*');
+
+str = v.trimRight();
+str = v.trimRight('the fire rises   ');
+str = v.trimRight('do you feel in charge?!!!', '!');
+
+str = v.wordWrap();
+str = v.wordWrap('Hello world');
+str = v.wordWrap('Hello world', {
+    width: 5
+});
+str = v.wordWrap('Hello world', {
+    width: 5,
+    newLine: '<br/>',
+    indent: '__'
+});
+str = v.wordWrap('Wonderful world', {
+    width: 5,
+    cut: true
+});
+
+// Query
+bool = v.endsWith();
+bool = v.endsWith('red alert');
+bool = v.endsWith('red alert', 'alert');
+bool = v.endsWith('Murphy', 'ph', 5);
+bool = v('Murphy').endsWith('ph', 5);
+bool = v.chain('Murphy').endsWith('ph', 5).value();
+
+bool = v.includes();
+bool = v.includes('starship');
+bool = v.includes('starship', 'star');
+bool = v.includes('galaxy', 'g', 1);
+bool = v('galaxy').includes('g', 1);
+bool = v.chain('galaxy').includes('g', 1).value();
+
+bool = v.isAlpha();
+bool = v.isAlpha('bart');
+
+bool = v.isAlphaDigit();
+bool = v.isAlphaDigit('year2020');
+
+bool = v.isBlank();
+bool = v.isBlank('');
+
+bool = v.isDigit();
+bool = v.isDigit('35');
+
+bool = v.isEmpty();
+bool = v.isEmpty('');
+
+bool = v.isLowerCase();
+bool = v.isLowerCase('motorcycle');
+
+bool = v.isNumeric();
+bool = v.isNumeric('350');
+
+bool = v.isString();
+bool = v.isString('vacation');
+bool = v.isString(560);
+bool = v('vacation').isString();
+bool = v(560).isString();
+bool = v.chain('vacation').isString().value();
+bool = v.chain(560).isString().value();
+
+bool = v.isUpperCase();
+bool = v.isUpperCase('ACDC');
+
+bool = v.matches();
+bool = v.matches('pluto');
+bool = v.matches('pluto', /plu.{2}/);
+bool = v.matches('sun', 'S', 'i');
+bool = v.matches('apollo 11', '\\d{3}');
+
+bool = v.startsWith();
+bool = v.startsWith('say hello to my little friend');
+bool = v.startsWith('say hello to my little friend', 'say hello');
+bool = v.startsWith('tony', 'on', 1);
+bool = v.startsWith('the world is yours', 'world');
+
+// Split
+strAry = v.chars();
+strAry = v.chars('cloud');
+
+numAry = v.codePoints();
+numAry = v.codePoints('rain');
+
+strAry = v.graphemes();
+strAry = v.graphemes('\uD835\uDC00\uD835\uDC01');
+
+strAry = v.split('rage against the dying of the light', ' ');
+strAry = v.split('the dying of the light', /\s/, 3);
+
+strAry = v.words();
+strAry = v.words('gravity can cross dimensions');
+strAry = v.words('Earth gravity', /[^\s]+/g);
+
+// Strip
+str = v.stripBom();
+str = v.stripBom('\uFEFFsummertime sadness');
+
+str = v.stripTags();
+str = v.stripTags('<span><a href="#">Summer</a> is nice</span>');
+str = v.stripTags('<span><i>Winter</i> is <b>cold</b></span>', ['b', 'i']);
+str = v.stripTags('Sun<br/>set', '', '-');
+
+// Util
+var voca: v.VocaStatic = v.noConflict();
+var version: String = v.version;