From 46e43f4bde4a35785b4997b81e86cd19f046b69b Mon Sep 17 00:00:00 2001 From: Minteck Date: Tue, 21 Dec 2021 16:52:28 +0100 Subject: Commit --- src/node_modules/stringz/dist/index.js | 199 +++++++++++++++++++++++++++++++++ 1 file changed, 199 insertions(+) create mode 100644 src/node_modules/stringz/dist/index.js (limited to 'src/node_modules/stringz/dist/index.js') diff --git a/src/node_modules/stringz/dist/index.js b/src/node_modules/stringz/dist/index.js new file mode 100644 index 0000000..e53e862 --- /dev/null +++ b/src/node_modules/stringz/dist/index.js @@ -0,0 +1,199 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +// @ts-ignore +var char_regex_1 = __importDefault(require("char-regex")); +/** + * Converts a string to an array of string chars + * @param {string} str The string to turn into array + * @returns {string[]} + */ +function toArray(str) { + if (typeof str !== 'string') { + throw new Error('A string is expected as input'); + } + return str.match(char_regex_1.default()) || []; +} +exports.toArray = toArray; +/** + * Returns the length of a string + * + * @export + * @param {string} str + * @returns {number} + */ +function length(str) { + // Check for input + if (typeof str !== 'string') { + throw new Error('Input must be a string'); + } + var match = str.match(char_regex_1.default()); + return match === null ? 0 : match.length; +} +exports.length = length; +/** + * Returns a substring by providing start and end position + * + * @export + * @param {string} str + * @param {number} [begin=0] Starting position + * @param {number} end End position + * @returns {string} + */ +function substring(str, begin, end) { + if (begin === void 0) { begin = 0; } + // Check for input + if (typeof str !== 'string') { + throw new Error('Input must be a string'); + } + // Even though negative numbers work here, theyre not in the spec + if (typeof begin !== 'number' || begin < 0) { + begin = 0; + } + if (typeof end === 'number' && end < 0) { + end = 0; + } + var match = str.match(char_regex_1.default()); + if (!match) + return ''; + return match.slice(begin, end).join(''); +} +exports.substring = substring; +/** + * Returns a substring by providing start position and length + * + * @export + * @param {string} str + * @param {number} [begin=0] Starting position + * @param {number} len Desired length + * @returns {string} + */ +function substr(str, begin, len) { + if (begin === void 0) { begin = 0; } + // Check for input + if (typeof str !== 'string') { + throw new Error('Input must be a string'); + } + var strLength = length(str); + // Fix type + if (typeof begin !== 'number') { + begin = parseInt(begin, 10); + } + // Return zero-length string if got oversize number. + if (begin >= strLength) { + return ''; + } + // Calculating postive version of negative value. + if (begin < 0) { + begin += strLength; + } + var end; + if (typeof len === 'undefined') { + end = strLength; + } + else { + // Fix type + if (typeof len !== 'number') { + len = parseInt(len, 10); + } + end = len >= 0 ? len + begin : begin; + } + var match = str.match(char_regex_1.default()); + if (!match) + return ''; + return match.slice(begin, end).join(''); +} +exports.substr = substr; +/** + * Enforces a string to be a certain length by + * adding or removing characters + * + * @export + * @param {string} str + * @param {number} [limit=16] Limit + * @param {string} [padString='#'] The Pad String + * @param {string} [padPosition='right'] The Pad Position + * @returns {string} + */ +function limit(str, limit, padString, padPosition) { + if (limit === void 0) { limit = 16; } + if (padString === void 0) { padString = '#'; } + if (padPosition === void 0) { padPosition = 'right'; } + // Input should be a string, limit should be a number + if (typeof str !== 'string' || typeof limit !== 'number') { + throw new Error('Invalid arguments specified'); + } + // Pad position should be either left or right + if (['left', 'right'].indexOf(padPosition) === -1) { + throw new Error('Pad position should be either left or right'); + } + // Pad string can be anything, we convert it to string + if (typeof padString !== 'string') { + padString = String(padString); + } + // Calculate string length considering astral code points + var strLength = length(str); + if (strLength > limit) { + return substring(str, 0, limit); + } + else if (strLength < limit) { + var padRepeats = padString.repeat(limit - strLength); + return padPosition === 'left' ? padRepeats + str : str + padRepeats; + } + return str; +} +exports.limit = limit; +/** + * Returns the index of the first occurrence of a given string + * + * @export + * @param {string} str + * @param {string} [searchStr] the string to search + * @param {number} [pos] starting position + * @returns {number} + */ +function indexOf(str, searchStr, pos) { + if (pos === void 0) { pos = 0; } + if (typeof str !== 'string') { + throw new Error('Input must be a string'); + } + if (str === '') { + if (searchStr === '') { + return 0; + } + return -1; + } + // fix type + pos = Number(pos); + pos = isNaN(pos) ? 0 : pos; + searchStr = String(searchStr); + var strArr = toArray(str); + if (pos >= strArr.length) { + if (searchStr === '') { + return strArr.length; + } + return -1; + } + if (searchStr === '') { + return pos; + } + var searchArr = toArray(searchStr); + var finded = false; + var index; + for (index = pos; index < strArr.length; index += 1) { + var searchIndex = 0; + while (searchIndex < searchArr.length && + searchArr[searchIndex] === strArr[index + searchIndex]) { + searchIndex += 1; + } + if (searchIndex === searchArr.length && + searchArr[searchIndex - 1] === strArr[index + searchIndex - 1]) { + finded = true; + break; + } + } + return finded ? index : -1; +} +exports.indexOf = indexOf; -- cgit