@shaxpir/duiduidui-models 1.0.0

package/dist/util/Template.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Template = exports.TemplateParser = void 0;
+const HtmlMarkup_1 = require("../models/markup/HtmlMarkup");
+class TemplateParser {
+    static parse(text) {
+        let chunks = [];
+        let lastEndIndex = 0;
+        let match;
+        while ((match = TemplateParser.TAG_PATTERN.exec(text)) !== null) {
+            let tagText = match[0];
+            let index = match.index;
+            if (index > lastEndIndex) {
+                let textBeforeTag = text.substring(lastEndIndex, index);
+                chunks.push(textBeforeTag);
+            }
+            chunks.push(tagText);
+            lastEndIndex = index + tagText.length;
+        }
+        if (lastEndIndex < text.length) {
+            let textAfterTag = text.substring(lastEndIndex);
+            chunks.push(textAfterTag);
+        }
+        return TemplateParser.fromChunks(chunks, null, false);
+    }
+    static fromChunks(chunks, name, negated) {
+        let parts = [];
+        for (let i = 0, len = chunks.length; i < len; i++) {
+            let chunk = chunks[i];
+            if (!chunk.startsWith("{")) {
+                parts.push(new StringLiteratal(chunk));
+            }
+            else if (chunk.startsWith("{{{")) {
+                if (chunk.endsWith("}}}")) {
+                    let name = chunk.substring(3, chunk.length - 3);
+                    if (name.startsWith("/") || name.startsWith("^") || name.startsWith("#")) {
+                        throw new Error("illegal name for triple-braced template-tag: " + chunk);
+                    }
+                    parts.push(new TemplateTag(name, false));
+                }
+                else {
+                    throw new Error("mismatched braces in template-tag: " + chunk);
+                }
+            }
+            else {
+                if (chunk.endsWith("}}}")) {
+                    throw new Error("mismatched braces in template-tag: " + chunk);
+                }
+                else if (chunk.startsWith("{{#") || chunk.startsWith("{{^")) {
+                    let name = chunk.substring(3, chunk.length - 2);
+                    let negated = chunk.startsWith("{{^");
+                    let endIndex = TemplateParser.findEndIndex(chunks, name, i);
+                    if (endIndex - i > 1) {
+                        let subChunks = chunks.slice(i + 1, endIndex);
+                        let template = TemplateParser.fromChunks(subChunks, name, negated);
+                        parts.push(template);
+                    }
+                    i = endIndex;
+                }
+                else if (chunk.startsWith("{{/")) {
+                    throw new Error("unmatched end-tag: " + chunk);
+                }
+                else {
+                    let name = chunk.substring(2, chunk.length - 2);
+                    parts.push(new TemplateTag(name, true));
+                }
+            }
+        }
+        return new Template(parts, name, negated);
+    }
+    static findEndIndex(chunks, name, startIndex) {
+        for (let i = startIndex + 1; i < chunks.length; i++) {
+            let chunk = chunks[i];
+            if (chunk === "{{/" + name + "}}") {
+                return i;
+            }
+        }
+        throw new Error("can't find end-index for chunk: " + chunks[startIndex]);
+    }
+}
+exports.TemplateParser = TemplateParser;
+TemplateParser.TAG_PATTERN = /\{\{.+?\}?\}\}/g;
+class Template {
+    constructor(parts, name, negated) {
+        this.parts = parts;
+        this.name = name;
+        this.negated = negated;
+    }
+    render(params) {
+        let result = "";
+        if (this.name == null ||
+            (params.hasOwnProperty(this.name) && params[this.name] === !this.negated)) {
+            for (let i = 0, len = this.parts.length; i < len; i++) {
+                let part = this.parts[i];
+                result += part.render(params);
+            }
+        }
+        return result;
+    }
+}
+exports.Template = Template;
+class StringLiteratal {
+    constructor(value) {
+        this.value = value;
+    }
+    render(params) {
+        return this.value;
+    }
+}
+class TemplateTag {
+    constructor(name, escapeHtml) {
+        this.name = name;
+        this.escapeHtml = escapeHtml;
+    }
+    render(params) {
+        if (params.hasOwnProperty(this.name)) {
+            let value = params[this.name];
+            if (value !== null) {
+                let text = "" + value;
+                if (this.escapeHtml) {
+                    text = HtmlMarkup_1.HtmlMarkup.escapeText(text);
+                }
+                return text;
+            }
+        }
+        return "";
+    }
+}

package/dist/util/Text.d.ts

@@ -0,0 +1,45 @@
+export declare class Text {
+    private static readonly WORD_START_CHAR_CLASS;
+    private static readonly WORD_MIDDLE_CHAR_CLASS;
+    private static readonly WORD_END_CHAR_CLASS;
+    private static readonly APOSTROPHE_CHAR_CLASS;
+    private static readonly WORD_POST_APOS_CHAR_CLASS;
+    private static readonly WORD_BOUNDARY_BEFORE;
+    private static readonly WORD_BOUNDARY_AFTER;
+    private static readonly WORD_PATTERN;
+    static readonly WORD_REGEX: RegExp;
+    private static readonly NON_WORD_CHARS;
+    static countWords(text: string): number;
+    static tokenizeWords(text: string, keepSeparators: boolean): string[];
+    static getUniqueWords(text: string): string[];
+    static capitalizeWords(text: string): string;
+    static normalizeText(text: string): string;
+    static normalizeDashes(text: string): string;
+    static makeCurlyQuotes(text: string): string;
+    static normalizeApostrophes(text: string): string;
+    static removeDashes(text: string): string;
+    static removeApostrophes(text: string): string;
+    static removePosessive(text: string): string;
+    static removePlural(word: string): string;
+    static removeSuffixes(word: string, suffixes: string[]): string;
+    static stripNonWordChars(text: string): string;
+    static endsWithAnySuffix(text: string, suffixes: string[]): boolean;
+    static endsWithWordChar(text: string): boolean;
+    static isWordChar(c: string): boolean;
+    static isAllWordChars(text: string): boolean;
+    static hasAnyWordChars(text: string): boolean;
+    static isPunctuation(c: string): boolean;
+    static isAllPunctuation(text: string): boolean;
+    static hasAnyPunctuation(text: string): boolean;
+    static isWhitspace(c: string): boolean;
+    static isAllWhitspace(text: string): boolean;
+    static hasAnyWhitspace(text: string): boolean;
+    static isDigit(c: string): boolean;
+    static isAllDigits(text: string): boolean;
+    static hasAnyDigits(text: string): boolean;
+    static isCapitalLetter(c: string): boolean;
+    static isAllCapitalLetters(text: string): boolean;
+    static hasAnyCapitalLetters(text: string): boolean;
+    private static allCharsMatch;
+    private static anyCharsMatch;
+}

package/dist/util/Text.js

@@ -0,0 +1,243 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Text = void 0;
+const pluralize = __importStar(require("pluralize"));
+class Text {
+    static countWords(text) {
+        let wordCount = 0;
+        if (text.length && text.length > 0) {
+            let match;
+            while ((match = Text.WORD_REGEX.exec(text)) !== null) {
+                wordCount++;
+            }
+        }
+        return wordCount;
+    }
+    static tokenizeWords(text, keepSeparators) {
+        let chunks = [];
+        let prevMatchEnd = 0;
+        if (text.length && text.length > 0) {
+            let match;
+            while ((match = Text.WORD_REGEX.exec(text)) !== null) {
+                let matchText = match[0];
+                let matchStart = match.index;
+                let matchEnd = matchStart + matchText.length;
+                if (keepSeparators && matchStart - prevMatchEnd > 0) {
+                    let prevText = text.substring(prevMatchEnd, matchStart);
+                    chunks.push(prevText);
+                }
+                chunks.push(matchText);
+                prevMatchEnd = matchEnd;
+            }
+        }
+        if (keepSeparators && prevMatchEnd < text.length) {
+            let textAfterFinalWord = text.substring(prevMatchEnd);
+            chunks.push(textAfterFinalWord);
+        }
+        return chunks;
+    }
+    static getUniqueWords(text) {
+        let words = [];
+        let map = {};
+        let match;
+        while ((match = Text.WORD_REGEX.exec(text)) !== null) {
+            let word = match[0];
+            if (!map.hasOwnProperty(word)) {
+                map[word] = true;
+                words.push(word);
+            }
+        }
+        return words;
+    }
+    static capitalizeWords(text) {
+        return text.toLowerCase().replace(/\b[a-z]/g, function (letter) {
+            return letter.toUpperCase();
+        });
+    }
+    static normalizeText(text) {
+        text = Text.normalizeDashes(text);
+        text = Text.normalizeApostrophes(text);
+        return text;
+    }
+    static normalizeDashes(text) {
+        return text.replace(/[\u2010-\u2015]/g, "-");
+    }
+    static makeCurlyQuotes(text) {
+        text = text.replace(/(^|\s+)"/gmu, "$1“");
+        text = text.replace(/"(\\s+|$)/gmu, "”$1");
+        text = text.replace(/"$/gmu, "”");
+        text = text.replace(/(\p{L})"([.,:;?!)])/gmu, "$1”$2");
+        text = text.replace(/(^|\s+)'/gmu, "$1‘");
+        text = text.replace(/'/gmu, "’");
+        return text;
+    }
+    static normalizeApostrophes(text) {
+        return text.replace(/[\u2018\u2019]/g, "'");
+    }
+    static removeDashes(text) {
+        return text.replace(/[\-\u2010-\u2015]/g, "");
+    }
+    static removeApostrophes(text) {
+        return text.replace(/['\u2018\u2019]/g, "");
+    }
+    static removePosessive(text) {
+        return Text.normalizeApostrophes(text).replace(/'s?$/, "");
+    }
+    static removePlural(word) {
+        return pluralize.singular(word);
+    }
+    static removeSuffixes(word, suffixes) {
+        for (let i = 0, len = suffixes.length; i < len; i++) {
+            let suffix = suffixes[i];
+            // We will only remove suffixes from root words having three or more letters.
+            if (word.length > suffix.length + 3) {
+                // The suffix must occur at the end
+                let suffixStart = word.indexOf(suffix);
+                if (suffixStart === word.length - suffix.length) {
+                    // Remove the actual suffix.
+                    word = word.substring(0, suffixStart);
+                    // If the word ends in a duble-consonant, remove the last char too.
+                    let lastLetter = word.charAt(word.length - 1);
+                    let prevLastLetter = word.charAt(word.length - 2);
+                    if (lastLetter === prevLastLetter) {
+                        word = word.substring(0, word.length - 1);
+                    }
+                }
+            }
+        }
+        return word;
+    }
+    static stripNonWordChars(text) {
+        return text.replace(Text.NON_WORD_CHARS, "");
+    }
+    static endsWithAnySuffix(text, suffixes) {
+        for (let i = 0, len = suffixes.length; i < len; i++) {
+            let suffix = suffixes[i];
+            if (text.lastIndexOf(suffix) === text.length - suffix.length) {
+                return true;
+            }
+        }
+        return false;
+    }
+    static endsWithWordChar(text) {
+        const lastChar = text.charAt(text.length - 1);
+        return text.length > 0 && !Text.isPunctuation(lastChar) && Text.isWordChar(lastChar);
+    }
+    static isWordChar(c) {
+        return c.length === 1 &&
+            (c >= 'a' && c <= 'z') ||
+            (c >= 'A' && c <= 'Z') ||
+            (c >= '0' && c <= '9') ||
+            "-'‘’ÀÈÌÒÙàèìòùÁÉÍÓÚÝáéíóúýÂÊÎÔÛâêîôûÃÑÕãñõÄËÏÖÜäëïöüçÇßØøÅåÆæÞþÐðĀĒĪŌŪȲǢāēīōūȳǣ".indexOf(c) >= 0;
+    }
+    static isAllWordChars(text) {
+        return Text.allCharsMatch(text, Text.isWordChar);
+    }
+    static hasAnyWordChars(text) {
+        return Text.anyCharsMatch(text, Text.isWordChar);
+    }
+    static isPunctuation(c) {
+        return c.length === 1 && ".,'?!-:;|\\\"<>/[]{}()_+=@#$%^&*".indexOf(c) >= 0;
+    }
+    static isAllPunctuation(text) {
+        return Text.allCharsMatch(text, Text.isPunctuation);
+    }
+    static hasAnyPunctuation(text) {
+        return Text.anyCharsMatch(text, Text.isPunctuation);
+    }
+    static isWhitspace(c) {
+        return c.length === 1 && " \t\r\n".indexOf(c) >= 0;
+    }
+    static isAllWhitspace(text) {
+        return Text.allCharsMatch(text, Text.isWhitspace);
+    }
+    static hasAnyWhitspace(text) {
+        return Text.anyCharsMatch(text, Text.isWhitspace);
+    }
+    static isDigit(c) {
+        return c.length === 1 && c >= '0' && c <= '9';
+    }
+    static isAllDigits(text) {
+        return Text.allCharsMatch(text, Text.isDigit);
+    }
+    static hasAnyDigits(text) {
+        return Text.anyCharsMatch(text, Text.isDigit);
+    }
+    static isCapitalLetter(c) {
+        return c.length === 1 && (c >= 'A' && c <= 'Z') || "ÀÈÌÒÙÁÉÍÓÚÝÂÊÎÔÛÃÑÕÄËÏÖÜÇßØÅÆÞÐĀĒĪŌŪȲǢ".indexOf(c) >= 0;
+    }
+    static isAllCapitalLetters(text) {
+        return Text.allCharsMatch(text, Text.isCapitalLetter);
+    }
+    static hasAnyCapitalLetters(text) {
+        return Text.anyCharsMatch(text, Text.isCapitalLetter);
+    }
+    static allCharsMatch(text, predicate) {
+        if (text.length > 0) {
+            for (let i = 0, len = text.length; i < len; i++) {
+                let c = text.charAt(i);
+                if (!predicate(c)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+    static anyCharsMatch(text, predicate) {
+        for (let i = 0, len = text.length; i < len; i++) {
+            let c = text.charAt(i);
+            if (predicate(c)) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+exports.Text = Text;
+Text.WORD_START_CHAR_CLASS = "[a-zA-Z0-9B̌b̌F̌f̌ĞğJ̌M̌m̌ńọP̌p̌Q̌q̌V̌v̌W̌w̌X̌x̌Y̌y̌ßÀàÁáÂâÃãÄäÅåÆæÇçÈèÉéÊêÊ̌ê̌ËëÌìÍíÎîÏïİi̇ıÐðÑñÒòÓóÔôÕõÖöØøÙùÚúÛûÜüÝýÞþĀāČčČ̣č̣ĎďĒēĚěĪīĽľŁłŇňŌōŘřŘ̩ř̩ŞşŠšŤťŪūŻżŽžǍǎǏǐǑǒǓǔǙǚǢǣǦǧǨǩǮǯǰȘșȞȟȲȳṦṧẾếỄễỌọ́]";
+Text.WORD_MIDDLE_CHAR_CLASS = "[a-zA-Z0-9B̌b̌F̌f̌ĞğJ̌M̌m̌ńọP̌p̌Q̌q̌V̌v̌W̌w̌X̌x̌Y̌y̌ßÀàÁáÂâÃãÄäÅåÆæÇçÈèÉéÊêÊ̌ê̌ËëÌìÍíÎîÏïİi̇ıÐðÑñÒòÓóÔôÕõÖöØøÙùÚúÛûÜüÝýÞþĀāČčČ̣č̣ĎďĒēĚěĪīĽľŁłŇňŌōŘřŘ̩ř̩ŞşŠšŤťŪūŻżŽžǍǎǏǐǑǒǓǔǙǚǢǣǦǧǨǩǮǯǰȘșȞȟȲȳṦṧẾếỄễỌọ́\\.\\-]";
+Text.WORD_END_CHAR_CLASS = "[a-zA-Z0-9B̌b̌F̌f̌ĞğJ̌M̌m̌ńọP̌p̌Q̌q̌V̌v̌W̌w̌X̌x̌Y̌y̌ßÀàÁáÂâÃãÄäÅåÆæÇçÈèÉéÊêÊ̌ê̌ËëÌìÍíÎîÏïİi̇ıÐðÑñÒòÓóÔôÕõÖöØøÙùÚúÛûÜüÝýÞþĀāČčČ̣č̣ĎďĒēĚěĪīĽľŁłŇňŌōŘřŘ̩ř̩ŞşŠšŤťŪūŻżŽžǍǎǏǐǑǒǓǔǙǚǢǣǦǧǨǩǮǯǰȘșȞȟȲȳṦṧẾếỄễỌọ́]";
+Text.APOSTROPHE_CHAR_CLASS = "[\u0027\u2018\u2019]";
+Text.WORD_POST_APOS_CHAR_CLASS = "[a-zA-ZB̌b̌F̌Ğğf̌J̌M̌m̌ńọP̌p̌Q̌q̌V̌v̌W̌w̌X̌x̌Y̌y̌ßÀàÁáÂâÃãÄäÅåÆæÇçÈèÉéÊêÊ̌ê̌ËëÌìÍíÎîÏïİi̇ıÐðÑñÒòÓóÔôÕõÖöØøÙùÚúÛûÜüÝýÞþĀāČčČ̣č̣ĎďĒēĚěĪīĽľŁłŇňŌōŘřŘ̩ř̩ŞşŠšŤťŪūŻżŽžǍǎǏǐǑǒǓǔǙǚǢǣǦǧǨǩǮǯǰȘșȞȟȲȳṦṧẾếỄễỌọ́]";
+// Since we need to match on unicode text, we can't use the normal \b word boundary assertion,
+// because it only matches on ASCII word boundaries. Instead, we use our own word boundary
+// assertions that match on unicode word boundaries, based on negative lookbehind and lookahead.
+Text.WORD_BOUNDARY_BEFORE = "(?<![\\p{Letter}\\p{Number}])";
+Text.WORD_BOUNDARY_AFTER = "(?![\\p{Letter}\\p{Number}])";
+Text.WORD_PATTERN = Text.WORD_BOUNDARY_BEFORE +
+    Text.WORD_START_CHAR_CLASS +
+    "(?:" +
+    Text.WORD_MIDDLE_CHAR_CLASS + "*" +
+    Text.WORD_END_CHAR_CLASS +
+    ")?" +
+    "(?:" +
+    Text.APOSTROPHE_CHAR_CLASS +
+    Text.WORD_POST_APOS_CHAR_CLASS + "+" +
+    ")*" +
+    Text.WORD_BOUNDARY_AFTER;
+Text.WORD_REGEX = new RegExp(Text.WORD_PATTERN, "gu");
+Text.NON_WORD_CHARS = /[^a-zA-Z0-9B̌b̌F̌f̌ĞğJ̌M̌m̌ńọP̌p̌Q̌q̌V̌v̌W̌w̌X̌x̌Y̌y̌ßÀàÁáÂâÃãÄäÅåÆæÇçÈèÉéÊêÊ̌ê̌ËëÌìÍíÎîÏïİi̇ıÐðÑñÒòÓóÔôÕõÖöØøÙùÚúÛûÜüÝýÞþĀāČčČ̣č̣ĎďĒēĚěĪīĽľŁłŇňŌōŘřŘ̩ř̩ŞşŠšŤťŪūŻżŽžǍǎǏǐǑǒǓǔǙǚǢǣǦǧǨǩǮǯǰȘșȞȟȲȳṦṧẾếỄễỌọ́]/g;

package/dist/util/Tuples.d.ts

@@ -0,0 +1,9 @@
+import { JsonPath, PathVal } from "../models/markup/Operation";
+export declare class Tuples {
+    static of(value: any): PathVal[];
+    static stringifyPath(prefix: string, path: JsonPath): string;
+    private static collectFromArray;
+    private static collectFromObject;
+    private static collectTuplesAtPath;
+    private static sort;
+}

package/dist/util/Tuples.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tuples = void 0;
+const Struct_1 = require("./Struct");
+class Tuples {
+    static of(value) {
+        let tuples = [];
+        if (Array.isArray(value)) {
+            Tuples.collectFromArray(tuples, [], value);
+        }
+        else if (value !== null) {
+            const type = typeof (value);
+            if (type === "object") {
+                Tuples.collectFromObject(tuples, [], value);
+            }
+        }
+        return Tuples.sort(tuples);
+    }
+    static stringifyPath(prefix, path) {
+        if (prefix == null || prefix.trim() == "") {
+            prefix = "$";
+        }
+        if (!prefix.startsWith("$")) {
+            prefix = "$" + prefix;
+        }
+        let str = prefix;
+        for (let i = 0; i < path.length; i++) {
+            let pathItem = path[i];
+            if (typeof (pathItem) === 'string') {
+                str += '.' + pathItem;
+            }
+            else {
+                str += '[' + pathItem + ']';
+            }
+        }
+        return str;
+    }
+    static collectFromArray(tuples, path, array) {
+        for (let i = 0; i < array.length; i++) {
+            path.push(i);
+            let item = array[i];
+            Tuples.collectTuplesAtPath(tuples, path, item);
+            path.pop();
+        }
+    }
+    static collectFromObject(tuples, path, object) {
+        const keys = Object.keys(object);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            if (object.hasOwnProperty(key)) {
+                path.push(key);
+                let item = object[key];
+                Tuples.collectTuplesAtPath(tuples, path, item);
+                path.pop();
+            }
+        }
+    }
+    static collectTuplesAtPath(tuples, path, item) {
+        if (Struct_1.Struct.equals(item, {}) || Struct_1.Struct.equals(item, [])) {
+            tuples.push({ path: Struct_1.Struct.clone(path), val: item });
+        }
+        else if (Array.isArray(item)) {
+            Tuples.collectFromArray(tuples, path, item);
+        }
+        else {
+            const type = typeof (item);
+            if (item === null ||
+                type === "string" ||
+                type === "number" ||
+                type === "boolean") {
+                tuples.push({ path: Struct_1.Struct.clone(path), val: item });
+            }
+            else if (type === "function" || type == "symbol" || type == "bigint" || type === "undefined") {
+                throw new Error(`can't create tuple from '${type}' item at path: ${JSON.stringify(path)}`);
+            }
+            else {
+                Tuples.collectFromObject(tuples, path, item);
+            }
+        }
+    }
+    static sort(tuples) {
+        // NOTE: tuples are sorted ONLY according to their PATH. The val is never considered. This is
+        // because we assume there can never be two identical paths anyhow, in a valid JSON tuple array.
+        tuples.sort((a, b) => {
+            const aPath = a.path;
+            const bPath = b.path;
+            const aPathLength = aPath.length;
+            const bPathLength = bPath.length;
+            let length = Math.min(aPathLength, bPathLength);
+            for (let i = 0; i < length; i++) {
+                const aPathElement = aPath[i];
+                const bPathElement = bPath[i];
+                const aPathElementType = typeof (aPathElement);
+                const bPathElementType = typeof (bPathElement);
+                let comparison = 0;
+                if (aPathElementType === "string" && bPathElementType === "string") {
+                    const aString = aPathElement;
+                    const bString = bPathElement;
+                    comparison = aString.localeCompare(bString);
+                }
+                else if (aPathElementType === "number" && bPathElementType === "number") {
+                    const aNumber = aPathElement;
+                    const bNumber = bPathElement;
+                    if (aNumber < bNumber) {
+                        comparison = -1;
+                    }
+                    else if (aNumber > bNumber) {
+                        comparison = 1;
+                    }
+                }
+                else if (aPathElementType === "string" && bPathElementType === "number") {
+                    comparison = -1;
+                }
+                else if (aPathElementType === "number" && bPathElementType === "string") {
+                    comparison = 1;
+                }
+                if (comparison !== 0) {
+                    return comparison;
+                }
+            }
+            if (aPathLength < bPathLength) {
+                return -1;
+            }
+            else if (aPathLength > bPathLength) {
+                return 1;
+            }
+            else {
+                // If we never do want to incorporate value comparisons into sort order, this is where we'd do it.
+                return 0;
+            }
+        });
+        return tuples;
+    }
+}
+exports.Tuples = Tuples;

package/dist/util/Validate.d.ts

@@ -0,0 +1,4 @@
+export declare class Validate {
+    private static EMAIL_PATTERN;
+    static email(text: string): boolean;
+}

package/dist/util/Validate.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Validate = void 0;
+class Validate {
+    static email(text) {
+        return Validate.EMAIL_PATTERN.test(text);
+    }
+}
+exports.Validate = Validate;
+// COPIED FROM HERE: http://emailregex.com
+Validate.EMAIL_PATTERN = /^(([^<>()\[\]\\.,;:\s@"]+(\.[^<>()\[\]\\.,;:\s@"]+)*)|(".+"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;

package/dist/util/Vocabulary.d.ts

@@ -0,0 +1,3 @@
+export declare class Vocabulary {
+    static calculateSizePercentile(wordCount: number, uniqueCount: number): number;
+}

package/dist/util/Vocabulary.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vocabulary = void 0;
+class Vocabulary {
+    static calculateSizePercentile(wordCount, uniqueCount) {
+        // This function returns a percentile value (between 0.01 and 0.99) telling us the relative
+        // size of this vocabulary (the unique word count), based on the expected size of the vocabulary
+        // for a body of prose with the designated total word count. We start by creating three different
+        // parametric estimates (lo, mid, hi) representing the 10th percentile, 50th percentile, and 90th
+        // percentile. Then we use the actual unique word count to interpolate between these values. The
+        // coefficients in these formulae were generated by performing a power-law regression over 9570
+        // works of fiction, having various different lengths and vocabulary sizes, and then adjusting
+        // the values to satisfy the 10th, 50th, and 90th percentile counts. Finally, although this
+        // parametric model is more accurate in estimating actual vocabulary sizes, it's also handy
+        // to remember this convenient shorthand: "vocabulary size scales proportionally to the square
+        // root of the total word count".
+        let coefficient = 9.3676;
+        let loEstimate = coefficient * Math.pow(wordCount, 0.5701);
+        let midEstimate = coefficient * Math.pow(wordCount, 0.5884);
+        let hiEstimate = coefficient * Math.pow(wordCount, 0.6070);
+        if (uniqueCount < loEstimate - ((midEstimate - loEstimate) / 4)) {
+            return 0.01;
+        }
+        else if (uniqueCount > hiEstimate + ((hiEstimate - midEstimate) / 4)) {
+            return 0.99;
+        }
+        else if (uniqueCount < midEstimate) {
+            return 0.1 + (0.4 * (uniqueCount - loEstimate) / (midEstimate - loEstimate));
+        }
+        else {
+            return 0.9 - (0.4 * (hiEstimate - uniqueCount) / (hiEstimate - midEstimate));
+        }
+    }
+}
+exports.Vocabulary = Vocabulary;

package/dist/util/index.d.ts

@@ -0,0 +1,16 @@
+export * from './Async';
+export * from './Base62';
+export * from './BinarySearch';
+export * from './CachingHasher';
+export * from './Color';
+export * from './Dispatch';
+export * from './EditDistance';
+export * from './Encryption';
+export * from './NumberFormat';
+export * from './Logging';
+export * from './Struct';
+export * from './Template';
+export * from './Text';
+export * from './Tuples';
+export * from './Validate';
+export * from './Vocabulary';

package/dist/util/index.js

@@ -0,0 +1,33 @@
+"use strict";
+// created from 'create-ts-index'
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./Async"), exports);
+__exportStar(require("./Base62"), exports);
+__exportStar(require("./BinarySearch"), exports);
+__exportStar(require("./CachingHasher"), exports);
+__exportStar(require("./Color"), exports);
+__exportStar(require("./Dispatch"), exports);
+__exportStar(require("./EditDistance"), exports);
+__exportStar(require("./Encryption"), exports);
+__exportStar(require("./NumberFormat"), exports);
+__exportStar(require("./Logging"), exports);
+__exportStar(require("./Struct"), exports);
+__exportStar(require("./Template"), exports);
+__exportStar(require("./Text"), exports);
+__exportStar(require("./Tuples"), exports);
+__exportStar(require("./Validate"), exports);
+__exportStar(require("./Vocabulary"), exports);