@shaxpir/duiduidui-models 1.0.1 → 1.2.0

package/dist/util/Text.js

@@ -1,243 +0,0 @@
-"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

@@ -1,9 +0,0 @@
-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

@@ -1,135 +0,0 @@
-"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

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

package/dist/util/Validate.js

@@ -1,11 +0,0 @@
-"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

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

package/dist/util/Vocabulary.js

@@ -1,35 +0,0 @@
-"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;