typia 6.0.6 → 6.1.0

package/lib/index.mjs

@@ -1,4 +1,752 @@
-import RandExp from "randexp";
+function getDefaultExportFromCjs(x) {
+    return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+
+var lib$1 = {
+    exports: {}
+};
+
+var util$1 = {};
+
+var types$4 = {
+    ROOT: 0,
+    GROUP: 1,
+    POSITION: 2,
+    SET: 3,
+    RANGE: 4,
+    REPETITION: 5,
+    REFERENCE: 6,
+    CHAR: 7
+};
+
+var sets$1 = {};
+
+const types$3 = types$4;
+
+const INTS = () => [ {
+    type: types$3.RANGE,
+    from: 48,
+    to: 57
+} ];
+
+const WORDS = () => [ {
+    type: types$3.CHAR,
+    value: 95
+}, {
+    type: types$3.RANGE,
+    from: 97,
+    to: 122
+}, {
+    type: types$3.RANGE,
+    from: 65,
+    to: 90
+} ].concat(INTS());
+
+const WHITESPACE = () => [ {
+    type: types$3.CHAR,
+    value: 9
+}, {
+    type: types$3.CHAR,
+    value: 10
+}, {
+    type: types$3.CHAR,
+    value: 11
+}, {
+    type: types$3.CHAR,
+    value: 12
+}, {
+    type: types$3.CHAR,
+    value: 13
+}, {
+    type: types$3.CHAR,
+    value: 32
+}, {
+    type: types$3.CHAR,
+    value: 160
+}, {
+    type: types$3.CHAR,
+    value: 5760
+}, {
+    type: types$3.RANGE,
+    from: 8192,
+    to: 8202
+}, {
+    type: types$3.CHAR,
+    value: 8232
+}, {
+    type: types$3.CHAR,
+    value: 8233
+}, {
+    type: types$3.CHAR,
+    value: 8239
+}, {
+    type: types$3.CHAR,
+    value: 8287
+}, {
+    type: types$3.CHAR,
+    value: 12288
+}, {
+    type: types$3.CHAR,
+    value: 65279
+} ];
+
+const NOTANYCHAR = () => [ {
+    type: types$3.CHAR,
+    value: 10
+}, {
+    type: types$3.CHAR,
+    value: 13
+}, {
+    type: types$3.CHAR,
+    value: 8232
+}, {
+    type: types$3.CHAR,
+    value: 8233
+} ];
+
+sets$1.words = () => ({
+    type: types$3.SET,
+    set: WORDS(),
+    not: false
+});
+
+sets$1.notWords = () => ({
+    type: types$3.SET,
+    set: WORDS(),
+    not: true
+});
+
+sets$1.ints = () => ({
+    type: types$3.SET,
+    set: INTS(),
+    not: false
+});
+
+sets$1.notInts = () => ({
+    type: types$3.SET,
+    set: INTS(),
+    not: true
+});
+
+sets$1.whitespace = () => ({
+    type: types$3.SET,
+    set: WHITESPACE(),
+    not: false
+});
+
+sets$1.notWhitespace = () => ({
+    type: types$3.SET,
+    set: WHITESPACE(),
+    not: true
+});
+
+sets$1.anyChar = () => ({
+    type: types$3.SET,
+    set: NOTANYCHAR(),
+    not: true
+});
+
+(function(exports) {
+    const types = types$4;
+    const sets = sets$1;
+    const CTRL = "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^ ?";
+    const SLSH = {
+        0: 0,
+        t: 9,
+        n: 10,
+        v: 11,
+        f: 12,
+        r: 13
+    };
+    exports.strToChars = function(str) {
+        var chars_regex = /(\[\\b\])|(\\)?\\(?:u([A-F0-9]{4})|x([A-F0-9]{2})|(0?[0-7]{2})|c([@A-Z[\\\]^?])|([0tnvfr]))/g;
+        str = str.replace(chars_regex, (function(s, b, lbs, a16, b16, c8, dctrl, eslsh) {
+            if (lbs) {
+                return s;
+            }
+            var code = b ? 8 : a16 ? parseInt(a16, 16) : b16 ? parseInt(b16, 16) : c8 ? parseInt(c8, 8) : dctrl ? CTRL.indexOf(dctrl) : SLSH[eslsh];
+            var c = String.fromCharCode(code);
+            if (/[[\]{}^$.|?*+()]/.test(c)) {
+                c = "\\" + c;
+            }
+            return c;
+        }));
+        return str;
+    };
+    exports.tokenizeClass = (str, regexpStr) => {
+        var tokens = [];
+        var regexp = /\\(?:(w)|(d)|(s)|(W)|(D)|(S))|((?:(?:\\)(.)|([^\]\\]))-(?:\\)?([^\]]))|(\])|(?:\\)?([^])/g;
+        var rs, c;
+        while ((rs = regexp.exec(str)) != null) {
+            if (rs[1]) {
+                tokens.push(sets.words());
+            } else if (rs[2]) {
+                tokens.push(sets.ints());
+            } else if (rs[3]) {
+                tokens.push(sets.whitespace());
+            } else if (rs[4]) {
+                tokens.push(sets.notWords());
+            } else if (rs[5]) {
+                tokens.push(sets.notInts());
+            } else if (rs[6]) {
+                tokens.push(sets.notWhitespace());
+            } else if (rs[7]) {
+                tokens.push({
+                    type: types.RANGE,
+                    from: (rs[8] || rs[9]).charCodeAt(0),
+                    to: rs[10].charCodeAt(0)
+                });
+            } else if (c = rs[12]) {
+                tokens.push({
+                    type: types.CHAR,
+                    value: c.charCodeAt(0)
+                });
+            } else {
+                return [ tokens, regexp.lastIndex ];
+            }
+        }
+        exports.error(regexpStr, "Unterminated character class");
+    };
+    exports.error = (regexp, msg) => {
+        throw new SyntaxError("Invalid regular expression: /" + regexp + "/: " + msg);
+    };
+})(util$1);
+
+var positions$1 = {};
+
+const types$2 = types$4;
+
+positions$1.wordBoundary = () => ({
+    type: types$2.POSITION,
+    value: "b"
+});
+
+positions$1.nonWordBoundary = () => ({
+    type: types$2.POSITION,
+    value: "B"
+});
+
+positions$1.begin = () => ({
+    type: types$2.POSITION,
+    value: "^"
+});
+
+positions$1.end = () => ({
+    type: types$2.POSITION,
+    value: "$"
+});
+
+const util = util$1;
+
+const types$1 = types$4;
+
+const sets = sets$1;
+
+const positions = positions$1;
+
+lib$1.exports = regexpStr => {
+    var i = 0, l, c, start = {
+        type: types$1.ROOT,
+        stack: []
+    }, lastGroup = start, last = start.stack, groupStack = [];
+    var repeatErr = i => {
+        util.error(regexpStr, `Nothing to repeat at column ${i - 1}`);
+    };
+    var str = util.strToChars(regexpStr);
+    l = str.length;
+    while (i < l) {
+        c = str[i++];
+        switch (c) {
+          case "\\":
+            c = str[i++];
+            switch (c) {
+              case "b":
+                last.push(positions.wordBoundary());
+                break;
+
+              case "B":
+                last.push(positions.nonWordBoundary());
+                break;
+
+              case "w":
+                last.push(sets.words());
+                break;
+
+              case "W":
+                last.push(sets.notWords());
+                break;
+
+              case "d":
+                last.push(sets.ints());
+                break;
+
+              case "D":
+                last.push(sets.notInts());
+                break;
+
+              case "s":
+                last.push(sets.whitespace());
+                break;
+
+              case "S":
+                last.push(sets.notWhitespace());
+                break;
+
+              default:
+                if (/\d/.test(c)) {
+                    last.push({
+                        type: types$1.REFERENCE,
+                        value: parseInt(c, 10)
+                    });
+                } else {
+                    last.push({
+                        type: types$1.CHAR,
+                        value: c.charCodeAt(0)
+                    });
+                }
+            }
+            break;
+
+          case "^":
+            last.push(positions.begin());
+            break;
+
+          case "$":
+            last.push(positions.end());
+            break;
+
+          case "[":
+            var not;
+            if (str[i] === "^") {
+                not = true;
+                i++;
+            } else {
+                not = false;
+            }
+            var classTokens = util.tokenizeClass(str.slice(i), regexpStr);
+            i += classTokens[1];
+            last.push({
+                type: types$1.SET,
+                set: classTokens[0],
+                not
+            });
+            break;
+
+          case ".":
+            last.push(sets.anyChar());
+            break;
+
+          case "(":
+            var group = {
+                type: types$1.GROUP,
+                stack: [],
+                remember: true
+            };
+            c = str[i];
+            if (c === "?") {
+                c = str[i + 1];
+                i += 2;
+                if (c === "=") {
+                    group.followedBy = true;
+                } else if (c === "!") {
+                    group.notFollowedBy = true;
+                } else if (c !== ":") {
+                    util.error(regexpStr, `Invalid group, character '${c}'` + ` after '?' at column ${i - 1}`);
+                }
+                group.remember = false;
+            }
+            last.push(group);
+            groupStack.push(lastGroup);
+            lastGroup = group;
+            last = group.stack;
+            break;
+
+          case ")":
+            if (groupStack.length === 0) {
+                util.error(regexpStr, `Unmatched ) at column ${i - 1}`);
+            }
+            lastGroup = groupStack.pop();
+            last = lastGroup.options ? lastGroup.options[lastGroup.options.length - 1] : lastGroup.stack;
+            break;
+
+          case "|":
+            if (!lastGroup.options) {
+                lastGroup.options = [ lastGroup.stack ];
+                delete lastGroup.stack;
+            }
+            var stack = [];
+            lastGroup.options.push(stack);
+            last = stack;
+            break;
+
+          case "{":
+            var rs = /^(\d+)(,(\d+)?)?\}/.exec(str.slice(i)), min, max;
+            if (rs !== null) {
+                if (last.length === 0) {
+                    repeatErr(i);
+                }
+                min = parseInt(rs[1], 10);
+                max = rs[2] ? rs[3] ? parseInt(rs[3], 10) : Infinity : min;
+                i += rs[0].length;
+                last.push({
+                    type: types$1.REPETITION,
+                    min,
+                    max,
+                    value: last.pop()
+                });
+            } else {
+                last.push({
+                    type: types$1.CHAR,
+                    value: 123
+                });
+            }
+            break;
+
+          case "?":
+            if (last.length === 0) {
+                repeatErr(i);
+            }
+            last.push({
+                type: types$1.REPETITION,
+                min: 0,
+                max: 1,
+                value: last.pop()
+            });
+            break;
+
+          case "+":
+            if (last.length === 0) {
+                repeatErr(i);
+            }
+            last.push({
+                type: types$1.REPETITION,
+                min: 1,
+                max: Infinity,
+                value: last.pop()
+            });
+            break;
+
+          case "*":
+            if (last.length === 0) {
+                repeatErr(i);
+            }
+            last.push({
+                type: types$1.REPETITION,
+                min: 0,
+                max: Infinity,
+                value: last.pop()
+            });
+            break;
+
+          default:
+            last.push({
+                type: types$1.CHAR,
+                value: c.charCodeAt(0)
+            });
+        }
+    }
+    if (groupStack.length !== 0) {
+        util.error(regexpStr, "Unterminated group");
+    }
+    return start;
+};
+
+lib$1.exports.types = types$1;
+
+var libExports = lib$1.exports;
+
+class SubRange {
+    constructor(low, high) {
+        this.low = low;
+        this.high = high;
+        this.length = 1 + high - low;
+    }
+    overlaps(range) {
+        return !(this.high < range.low || this.low > range.high);
+    }
+    touches(range) {
+        return !(this.high + 1 < range.low || this.low - 1 > range.high);
+    }
+    add(range) {
+        return new SubRange(Math.min(this.low, range.low), Math.max(this.high, range.high));
+    }
+    subtract(range) {
+        if (range.low <= this.low && range.high >= this.high) {
+            return [];
+        } else if (range.low > this.low && range.high < this.high) {
+            return [ new SubRange(this.low, range.low - 1), new SubRange(range.high + 1, this.high) ];
+        } else if (range.low <= this.low) {
+            return [ new SubRange(range.high + 1, this.high) ];
+        } else {
+            return [ new SubRange(this.low, range.low - 1) ];
+        }
+    }
+    toString() {
+        return this.low == this.high ? this.low.toString() : this.low + "-" + this.high;
+    }
+}
+
+let DRange$1 = class DRange {
+    constructor(a, b) {
+        this.ranges = [];
+        this.length = 0;
+        if (a != null) this.add(a, b);
+    }
+    _update_length() {
+        this.length = this.ranges.reduce(((previous, range) => previous + range.length), 0);
+    }
+    add(a, b) {
+        var _add = subrange => {
+            var i = 0;
+            while (i < this.ranges.length && !subrange.touches(this.ranges[i])) {
+                i++;
+            }
+            var newRanges = this.ranges.slice(0, i);
+            while (i < this.ranges.length && subrange.touches(this.ranges[i])) {
+                subrange = subrange.add(this.ranges[i]);
+                i++;
+            }
+            newRanges.push(subrange);
+            this.ranges = newRanges.concat(this.ranges.slice(i));
+            this._update_length();
+        };
+        if (a instanceof DRange) {
+            a.ranges.forEach(_add);
+        } else {
+            if (b == null) b = a;
+            _add(new SubRange(a, b));
+        }
+        return this;
+    }
+    subtract(a, b) {
+        var _subtract = subrange => {
+            var i = 0;
+            while (i < this.ranges.length && !subrange.overlaps(this.ranges[i])) {
+                i++;
+            }
+            var newRanges = this.ranges.slice(0, i);
+            while (i < this.ranges.length && subrange.overlaps(this.ranges[i])) {
+                newRanges = newRanges.concat(this.ranges[i].subtract(subrange));
+                i++;
+            }
+            this.ranges = newRanges.concat(this.ranges.slice(i));
+            this._update_length();
+        };
+        if (a instanceof DRange) {
+            a.ranges.forEach(_subtract);
+        } else {
+            if (b == null) b = a;
+            _subtract(new SubRange(a, b));
+        }
+        return this;
+    }
+    intersect(a, b) {
+        var newRanges = [];
+        var _intersect = subrange => {
+            var i = 0;
+            while (i < this.ranges.length && !subrange.overlaps(this.ranges[i])) {
+                i++;
+            }
+            while (i < this.ranges.length && subrange.overlaps(this.ranges[i])) {
+                var low = Math.max(this.ranges[i].low, subrange.low);
+                var high = Math.min(this.ranges[i].high, subrange.high);
+                newRanges.push(new SubRange(low, high));
+                i++;
+            }
+        };
+        if (a instanceof DRange) {
+            a.ranges.forEach(_intersect);
+        } else {
+            if (b == null) b = a;
+            _intersect(new SubRange(a, b));
+        }
+        this.ranges = newRanges;
+        this._update_length();
+        return this;
+    }
+    index(index) {
+        var i = 0;
+        while (i < this.ranges.length && this.ranges[i].length <= index) {
+            index -= this.ranges[i].length;
+            i++;
+        }
+        return this.ranges[i].low + index;
+    }
+    toString() {
+        return "[ " + this.ranges.join(", ") + " ]";
+    }
+    clone() {
+        return new DRange(this);
+    }
+    numbers() {
+        return this.ranges.reduce(((result, subrange) => {
+            var i = subrange.low;
+            while (i <= subrange.high) {
+                result.push(i);
+                i++;
+            }
+            return result;
+        }), []);
+    }
+    subranges() {
+        return this.ranges.map((subrange => ({
+            low: subrange.low,
+            high: subrange.high,
+            length: 1 + subrange.high - subrange.low
+        })));
+    }
+};
+
+var lib = DRange$1;
+
+const ret = libExports;
+
+const DRange = lib;
+
+const types = ret.types;
+
+var randexp = class RandExp {
+    constructor(regexp, m) {
+        this._setDefaults(regexp);
+        if (regexp instanceof RegExp) {
+            this.ignoreCase = regexp.ignoreCase;
+            this.multiline = regexp.multiline;
+            regexp = regexp.source;
+        } else if (typeof regexp === "string") {
+            this.ignoreCase = m && m.indexOf("i") !== -1;
+            this.multiline = m && m.indexOf("m") !== -1;
+        } else {
+            throw new Error("Expected a regexp or string");
+        }
+        this.tokens = ret(regexp);
+    }
+    _setDefaults(regexp) {
+        this.max = regexp.max != null ? regexp.max : RandExp.prototype.max != null ? RandExp.prototype.max : 100;
+        this.defaultRange = regexp.defaultRange ? regexp.defaultRange : this.defaultRange.clone();
+        if (regexp.randInt) {
+            this.randInt = regexp.randInt;
+        }
+    }
+    gen() {
+        return this._gen(this.tokens, []);
+    }
+    _gen(token, groups) {
+        var stack, str, n, i, l;
+        switch (token.type) {
+          case types.ROOT:
+          case types.GROUP:
+            if (token.followedBy || token.notFollowedBy) {
+                return "";
+            }
+            if (token.remember && token.groupNumber === undefined) {
+                token.groupNumber = groups.push(null) - 1;
+            }
+            stack = token.options ? this._randSelect(token.options) : token.stack;
+            str = "";
+            for (i = 0, l = stack.length; i < l; i++) {
+                str += this._gen(stack[i], groups);
+            }
+            if (token.remember) {
+                groups[token.groupNumber] = str;
+            }
+            return str;
+
+          case types.POSITION:
+            return "";
+
+          case types.SET:
+            var expandedSet = this._expand(token);
+            if (!expandedSet.length) {
+                return "";
+            }
+            return String.fromCharCode(this._randSelect(expandedSet));
+
+          case types.REPETITION:
+            n = this.randInt(token.min, token.max === Infinity ? token.min + this.max : token.max);
+            str = "";
+            for (i = 0; i < n; i++) {
+                str += this._gen(token.value, groups);
+            }
+            return str;
+
+          case types.REFERENCE:
+            return groups[token.value - 1] || "";
+
+          case types.CHAR:
+            var code = this.ignoreCase && this._randBool() ? this._toOtherCase(token.value) : token.value;
+            return String.fromCharCode(code);
+        }
+    }
+    _toOtherCase(code) {
+        return code + (97 <= code && code <= 122 ? -32 : 65 <= code && code <= 90 ? 32 : 0);
+    }
+    _randBool() {
+        return !this.randInt(0, 1);
+    }
+    _randSelect(arr) {
+        if (arr instanceof DRange) {
+            return arr.index(this.randInt(0, arr.length - 1));
+        }
+        return arr[this.randInt(0, arr.length - 1)];
+    }
+    _expand(token) {
+        if (token.type === ret.types.CHAR) {
+            return new DRange(token.value);
+        } else if (token.type === ret.types.RANGE) {
+            return new DRange(token.from, token.to);
+        } else {
+            let drange = new DRange;
+            for (let i = 0; i < token.set.length; i++) {
+                let subrange = this._expand(token.set[i]);
+                drange.add(subrange);
+                if (this.ignoreCase) {
+                    for (let j = 0; j < subrange.length; j++) {
+                        let code = subrange.index(j);
+                        let otherCaseCode = this._toOtherCase(code);
+                        if (code !== otherCaseCode) {
+                            drange.add(otherCaseCode);
+                        }
+                    }
+                }
+            }
+            if (token.not) {
+                return this.defaultRange.clone().subtract(drange);
+            } else {
+                return this.defaultRange.clone().intersect(drange);
+            }
+        }
+    }
+    randInt(a, b) {
+        return a + Math.floor(Math.random() * (1 + b - a));
+    }
+    get defaultRange() {
+        return this._range = this._range || new DRange(32, 126);
+    }
+    set defaultRange(range) {
+        this._range = range;
+    }
+    static randexp(regexp, m) {
+        var randexp;
+        if (typeof regexp === "string") {
+            regexp = new RegExp(regexp, m);
+        }
+        if (regexp._randexp === undefined) {
+            randexp = new RandExp(regexp, m);
+            regexp._randexp = randexp;
+        } else {
+            randexp = regexp._randexp;
+            randexp._setDefaults(regexp);
+        }
+        return randexp.gen();
+    }
+    static sugar() {
+        RegExp.prototype.gen = function() {
+            return RandExp.randexp(this);
+        };
+    }
+};
+
+var RandExp = getDefaultExportFromCjs(randexp);
 
 const ALPHABETS = "abcdefghijklmnopqrstuvwxyz";