@chaoswise/intl 1.0.0 → 1.2.0

package/bin/scripts/util/FormPath/parser.js

@@ -0,0 +1,302 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+var tokenizer_1 = require("./tokenizer");
+var tokens_1 = require("./tokens");
+var contexts_1 = require("./contexts");
+var destructor_1 = require("./destructor");
+var Parser = (function (_super) {
+    __extends(Parser, _super);
+    function Parser() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    Parser.prototype.parse = function () {
+        var node;
+        this.data = {
+            segments: []
+        };
+        if (!this.eat(tokens_1.eofTok)) {
+            this.next();
+            node = this.parseAtom(this.state.type);
+        }
+        this.data.tree = node;
+        return node;
+    };
+    Parser.prototype.append = function (parent, node) {
+        if (parent && node) {
+            parent.after = node;
+        }
+    };
+    Parser.prototype.parseAtom = function (type) {
+        switch (type) {
+            case tokens_1.braceLTok:
+            case tokens_1.bracketLTok:
+                if (this.includesContext(contexts_1.destructorContext)) {
+                    if (type === tokens_1.braceLTok) {
+                        return this.parseObjectPattern();
+                    }
+                    else {
+                        return this.parseArrayPattern();
+                    }
+                }
+                return this.parseDestructorExpression();
+            case tokens_1.nameTok:
+                return this.parseIdentifier();
+            case tokens_1.expandTok:
+                return this.parseExpandOperator();
+            case tokens_1.starTok:
+                return this.parseWildcardOperator();
+            case tokens_1.bracketDLTok:
+                return this.parseIgnoreExpression();
+            case tokens_1.dotTok:
+                return this.parseDotOperator();
+        }
+    };
+    Parser.prototype.pushSegments = function (key) {
+        this.data.segments.push(key);
+    };
+    Parser.prototype.parseIdentifier = function () {
+        var node = {
+            type: 'Identifier',
+            value: this.state.value
+        };
+        var hasNotInDestructor = !this.includesContext(contexts_1.destructorContext) &&
+            !this.isMatchPattern &&
+            !this.isWildMatchPattern;
+        this.next();
+        if (this.includesContext(contexts_1.bracketArrayContext)) {
+            if (this.state.type !== tokens_1.bracketRTok) {
+                throw this.unexpect();
+            }
+            else {
+                this.state.context.pop();
+                this.next();
+            }
+        }
+        else if (hasNotInDestructor) {
+            this.pushSegments(node.value);
+        }
+        if (this.state.type === tokens_1.bracketLTok) {
+            this.next();
+            if (this.state.type !== tokens_1.nameTok) {
+                throw this.unexpect();
+            }
+            this.state.context.push(contexts_1.bracketArrayContext);
+            var isNumberKey = false;
+            if (/^\d+$/.test(this.state.value)) {
+                isNumberKey = true;
+            }
+            var value = this.state.value;
+            this.pushSegments(isNumberKey ? Number(value) : value);
+            var after = this.parseAtom(this.state.type);
+            if (isNumberKey) {
+                after.arrayIndex = true;
+            }
+            this.append(node, after);
+        }
+        else {
+            this.append(node, this.parseAtom(this.state.type));
+        }
+        return node;
+    };
+    Parser.prototype.parseExpandOperator = function () {
+        var node = {
+            type: 'ExpandOperator'
+        };
+        this.isMatchPattern = true;
+        this.isWildMatchPattern = true;
+        this.data.segments = [];
+        this.next();
+        this.append(node, this.parseAtom(this.state.type));
+        return node;
+    };
+    Parser.prototype.parseWildcardOperator = function () {
+        var node = {
+            type: 'WildcardOperator'
+        };
+        this.isMatchPattern = true;
+        this.isWildMatchPattern = true;
+        this.data.segments = [];
+        this.next();
+        if (this.state.type === tokens_1.parenLTok) {
+            node.filter = this.parseGroupExpression(node);
+        }
+        else if (this.state.type === tokens_1.bracketLTok) {
+            node.filter = this.parseRangeExpression(node);
+        }
+        this.append(node, this.parseAtom(this.state.type));
+        return node;
+    };
+    Parser.prototype.parseDestructorExpression = function () {
+        var node = {
+            type: 'DestructorExpression'
+        };
+        this.state.context.push(contexts_1.destructorContext);
+        var startPos = this.state.pos - 1;
+        node.value =
+            this.state.type === tokens_1.braceLTok
+                ? this.parseObjectPattern()
+                : this.parseArrayPattern();
+        var endPos = this.state.pos;
+        this.state.context.pop();
+        this.next();
+        this.append(node, this.parseAtom(this.state.type));
+        node.source = this.input.substring(startPos, endPos).replace(/\s*/g, '');
+        destructor_1.setDestructor(node.source, destructor_1.parseDestructorRules(node));
+        this.pushSegments(node.source);
+        return node;
+    };
+    Parser.prototype.parseArrayPattern = function () {
+        var node = {
+            type: 'ArrayPattern',
+            elements: []
+        };
+        this.next();
+        node.elements = this.parseArrayPatternElements();
+        return node;
+    };
+    Parser.prototype.parseArrayPatternElements = function () {
+        var nodes = [];
+        while (this.state.type !== tokens_1.bracketRTok && this.state.type !== tokens_1.eofTok) {
+            nodes.push(this.parseAtom(this.state.type));
+            if (this.state.type === tokens_1.bracketRTok) {
+                this.next();
+                break;
+            }
+            this.next();
+        }
+        return nodes;
+    };
+    Parser.prototype.parseObjectPattern = function () {
+        var node = {
+            type: 'ObjectPattern',
+            properties: []
+        };
+        this.next();
+        node.properties = this.parseObjectProperties();
+        return node;
+    };
+    Parser.prototype.parseObjectProperties = function () {
+        var nodes = [];
+        while (this.state.type !== tokens_1.braceRTok && this.state.type !== tokens_1.eofTok) {
+            var node = {
+                type: 'ObjectPatternProperty',
+                key: this.parseAtom(this.state.type)
+            };
+            nodes.push(node);
+            if (this.state.type === tokens_1.colonTok) {
+                this.next();
+                node.value = this.parseAtom(this.state.type);
+            }
+            if (this.state.type === tokens_1.braceRTok) {
+                this.next();
+                break;
+            }
+            this.next();
+        }
+        return nodes;
+    };
+    Parser.prototype.parseDotOperator = function () {
+        var node = {
+            type: 'DotOperator'
+        };
+        this.next();
+        this.append(node, this.parseAtom(this.state.type));
+        return node;
+    };
+    Parser.prototype.parseIgnoreExpression = function () {
+        this.next();
+        var value = String(this.state.value).replace(/\s*/g, '');
+        var node = {
+            type: 'IgnoreExpression',
+            value: value
+        };
+        this.pushSegments(value);
+        this.next();
+        this.append(node, this.parseAtom(this.state.type));
+        this.next();
+        return node;
+    };
+    Parser.prototype.parseGroupExpression = function (parent) {
+        var node = {
+            type: 'GroupExpression',
+            value: []
+        };
+        this.isMatchPattern = true;
+        this.data.segments = [];
+        this.next();
+        loop: while (true) {
+            switch (this.state.type) {
+                case tokens_1.commaTok:
+                    this.next();
+                    break;
+                case tokens_1.bangTok:
+                    node.isExclude = true;
+                    this.haveExcludePattern = true;
+                    this.next();
+                    break;
+                case tokens_1.eofTok:
+                    break loop;
+                case tokens_1.parenRTok:
+                    break loop;
+                default:
+                    node.value.push(this.parseAtom(this.state.type));
+            }
+        }
+        this.next();
+        this.append(parent, this.parseAtom(this.state.type));
+        return node;
+    };
+    Parser.prototype.parseRangeExpression = function (parent) {
+        var node = {
+            type: 'RangeExpression'
+        };
+        this.next();
+        this.isMatchPattern = true;
+        this.data.segments = [];
+        var start = false, hasColon = false;
+        loop: while (true) {
+            switch (this.state.type) {
+                case tokens_1.colonTok:
+                    hasColon = true;
+                    start = true;
+                    this.next();
+                    break;
+                case tokens_1.bracketRTok:
+                    if (!hasColon && !node.end) {
+                        node.end = node.start;
+                    }
+                    break loop;
+                case tokens_1.commaTok:
+                    throw this.unexpect();
+                case tokens_1.eofTok:
+                    break loop;
+                default:
+                    if (!start) {
+                        node.start = this.parseAtom(this.state.type);
+                    }
+                    else {
+                        node.end = this.parseAtom(this.state.type);
+                    }
+            }
+        }
+        this.next();
+        this.append(parent, this.parseAtom(this.state.type));
+        return node;
+    };
+    return Parser;
+}(tokenizer_1.Tokenizer));
+exports.Parser = Parser;

package/bin/scripts/util/FormPath/tokenizer.d.ts

@@ -0,0 +1,26 @@
+import { Token } from './tokens';
+import { Context } from './contexts';
+export declare class Tokenizer {
+    input: string;
+    state: {
+        context: Context[];
+        type: Token;
+        pos: number;
+        value?: any;
+    };
+    constructor(input: string);
+    curContext(): Context;
+    includesContext(context: Context): boolean;
+    unexpect(type?: Token): Error;
+    expectNext(type?: Token, next?: Token): void;
+    expectPrev(type?: Token, prev?: Token): void;
+    match(type?: Token): boolean;
+    skipSpace(): void;
+    next(): void;
+    getCode(pos?: number): number;
+    eat(type: any): boolean;
+    readKeyWord(): void;
+    readIngoreString(): void;
+    finishToken(type: Token, value?: any): void;
+    readToken(code: number, prevCode: number): void;
+}

package/bin/scripts/util/FormPath/tokenizer.js

@@ -0,0 +1,280 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tokenizer = void 0;
+var tokens_1 = require("./tokens");
+var contexts_1 = require("./contexts");
+var nonASCIIwhitespace = /[\u1680\u180e\u2000-\u200a\u202f\u205f\u3000\ufeff]/;
+var fullCharCodeAtPos = function (input, pos) {
+    var code = input.charCodeAt(pos);
+    if (code <= 0xd7ff || code >= 0xe000)
+        return code;
+    var next = input.charCodeAt(pos + 1);
+    return (code << 10) + next - 0x35fdc00;
+};
+var isRewordCode = function (code) {
+    return code === 42 ||
+        code === 46 ||
+        code === 33 ||
+        code === 91 ||
+        code === 93 ||
+        code === 40 ||
+        code === 41 ||
+        code === 44 ||
+        code === 58 ||
+        code === 126 ||
+        code === 123 ||
+        code === 125;
+};
+var getError = function (message, props) {
+    var err = new Error(message);
+    Object.assign(err, props);
+    return err;
+};
+var slice = function (string, start, end) {
+    var str = '';
+    for (var i = start; i < end; i++) {
+        var ch = string.charAt(i);
+        if (ch !== '\\') {
+            str += ch;
+        }
+    }
+    return str;
+};
+var Tokenizer = (function () {
+    function Tokenizer(input) {
+        this.input = input;
+        this.state = {
+            context: [],
+            type: null,
+            pos: 0
+        };
+    }
+    Tokenizer.prototype.curContext = function () {
+        return this.state.context[this.state.context.length - 1];
+    };
+    Tokenizer.prototype.includesContext = function (context) {
+        for (var len = this.state.context.length - 1; len >= 0; len--) {
+            if (this.state.context[len] === context) {
+                return true;
+            }
+        }
+        return false;
+    };
+    Tokenizer.prototype.unexpect = function (type) {
+        type = type || this.state.type;
+        return getError("Unexpect token \"" + type.flag + "\" in " + this.state.pos + " char.", {
+            pos: this.state.pos
+        });
+    };
+    Tokenizer.prototype.expectNext = function (type, next) {
+        if (type && type.expectNext) {
+            if (next && !type.expectNext.call(this, next)) {
+                throw getError("Unexpect token \"" + next.flag + "\" token should not be behind \"" + type.flag + "\" token.(" + this.state.pos + "th char)", {
+                    pos: this.state.pos
+                });
+            }
+        }
+    };
+    Tokenizer.prototype.expectPrev = function (type, prev) {
+        if (type && type.expectPrev) {
+            if (prev && !type.expectPrev.call(this, prev)) {
+                throw getError("Unexpect token \"" + type.flag + "\" should not be behind \"" + prev.flag + "\"(" + this.state.pos + "th char).", {
+                    pos: this.state.pos
+                });
+            }
+        }
+    };
+    Tokenizer.prototype.match = function (type) {
+        return this.state.type === type;
+    };
+    Tokenizer.prototype.skipSpace = function () {
+        if (this.curContext() === contexts_1.bracketDContext)
+            return;
+        loop: while (this.state.pos < this.input.length) {
+            var ch = this.input.charCodeAt(this.state.pos);
+            switch (ch) {
+                case 32:
+                case 160:
+                    ++this.state.pos;
+                    break;
+                case 13:
+                    if (this.input.charCodeAt(this.state.pos + 1) === 10) {
+                        ++this.state.pos;
+                    }
+                case 10:
+                case 8232:
+                case 8233:
+                    ++this.state.pos;
+                    break;
+                default:
+                    if ((ch > 8 && ch < 14) ||
+                        (ch >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(ch)))) {
+                        ++this.state.pos;
+                    }
+                    else {
+                        break loop;
+                    }
+            }
+        }
+    };
+    Tokenizer.prototype.next = function () {
+        if (this.input.length <= this.state.pos) {
+            return this.finishToken(tokens_1.eofTok);
+        }
+        this.skipSpace();
+        this.readToken(this.getCode(), this.state.pos > 0 ? this.getCode(this.state.pos - 1) : -Infinity);
+    };
+    Tokenizer.prototype.getCode = function (pos) {
+        if (pos === void 0) { pos = this.state.pos; }
+        return fullCharCodeAtPos(this.input, pos);
+    };
+    Tokenizer.prototype.eat = function (type) {
+        if (this.match(type)) {
+            this.next();
+            return true;
+        }
+        else {
+            return false;
+        }
+    };
+    Tokenizer.prototype.readKeyWord = function () {
+        var startPos = this.state.pos, string = '';
+        while (true) {
+            var code = this.getCode();
+            var prevCode = this.getCode(this.state.pos - 1);
+            if (this.input.length === this.state.pos) {
+                string = slice(this.input, startPos, this.state.pos + 1);
+                break;
+            }
+            if (!isRewordCode(code) || prevCode === 92) {
+                if (code === 32 ||
+                    code === 160 ||
+                    code === 10 ||
+                    code === 8232 ||
+                    code === 8233) {
+                    string = slice(this.input, startPos, this.state.pos);
+                    break;
+                }
+                if (code === 13 && this.input.charCodeAt(this.state.pos + 1) === 10) {
+                    string = slice(this.input, startPos, this.state.pos);
+                    break;
+                }
+                if ((code > 8 && code < 14) ||
+                    (code >= 5760 && nonASCIIwhitespace.test(String.fromCharCode(code)))) {
+                    string = slice(this.input, startPos, this.state.pos);
+                    break;
+                }
+                this.state.pos++;
+            }
+            else {
+                string = slice(this.input, startPos, this.state.pos);
+                break;
+            }
+        }
+        this.finishToken(tokens_1.nameTok, string);
+    };
+    Tokenizer.prototype.readIngoreString = function () {
+        var startPos = this.state.pos, prevCode, string = '';
+        while (true) {
+            var code = this.getCode();
+            if (this.state.pos >= this.input.length)
+                break;
+            if ((code === 91 || code === 93) && prevCode === 92) {
+                this.state.pos++;
+                prevCode = '';
+            }
+            else if (code == 93 && prevCode === 93) {
+                string = this.input
+                    .slice(startPos, this.state.pos - 1)
+                    .replace(/\\([\[\]])/g, '$1');
+                this.state.pos++;
+                break;
+            }
+            else {
+                this.state.pos++;
+                prevCode = code;
+            }
+        }
+        this.finishToken(tokens_1.ignoreTok, string);
+        this.finishToken(tokens_1.bracketDRTok);
+    };
+    Tokenizer.prototype.finishToken = function (type, value) {
+        var preType = this.state.type;
+        this.state.type = type;
+        if (value !== undefined)
+            this.state.value = value;
+        this.expectNext(preType, type);
+        this.expectPrev(type, preType);
+        if (type.updateContext) {
+            type.updateContext.call(this, preType);
+        }
+    };
+    Tokenizer.prototype.readToken = function (code, prevCode) {
+        if (prevCode === 92) {
+            return this.readKeyWord();
+        }
+        if (this.input.length <= this.state.pos) {
+            this.finishToken(tokens_1.eofTok);
+        }
+        else if (this.curContext() === contexts_1.bracketDContext) {
+            this.readIngoreString();
+        }
+        else if (code === 123) {
+            this.state.pos++;
+            this.finishToken(tokens_1.braceLTok);
+        }
+        else if (code === 125) {
+            this.state.pos++;
+            this.finishToken(tokens_1.braceRTok);
+        }
+        else if (code === 42) {
+            this.state.pos++;
+            this.finishToken(tokens_1.starTok);
+        }
+        else if (code === 33) {
+            this.state.pos++;
+            this.finishToken(tokens_1.bangTok);
+        }
+        else if (code === 46) {
+            this.state.pos++;
+            this.finishToken(tokens_1.dotTok);
+        }
+        else if (code === 91) {
+            this.state.pos++;
+            if (this.getCode() === 91) {
+                this.state.pos++;
+                return this.finishToken(tokens_1.bracketDLTok);
+            }
+            this.finishToken(tokens_1.bracketLTok);
+        }
+        else if (code === 126) {
+            this.state.pos++;
+            this.finishToken(tokens_1.expandTok);
+        }
+        else if (code === 93) {
+            this.state.pos++;
+            this.finishToken(tokens_1.bracketRTok);
+        }
+        else if (code === 40) {
+            this.state.pos++;
+            this.finishToken(tokens_1.parenLTok);
+        }
+        else if (code === 41) {
+            this.state.pos++;
+            this.finishToken(tokens_1.parenRTok);
+        }
+        else if (code === 44) {
+            this.state.pos++;
+            this.finishToken(tokens_1.commaTok);
+        }
+        else if (code === 58) {
+            this.state.pos++;
+            this.finishToken(tokens_1.colonTok);
+        }
+        else {
+            this.readKeyWord();
+        }
+    };
+    return Tokenizer;
+}());
+exports.Tokenizer = Tokenizer;

package/bin/scripts/util/FormPath/tokens.d.ts

@@ -0,0 +1,26 @@
+interface ITokenProps {
+    expectNext?: (next?: Token) => boolean;
+    expectPrev?: (prev?: Token) => boolean;
+    updateContext?: (prev?: Token) => void;
+}
+export declare type Token = ITokenProps & {
+    flag: string;
+};
+export declare const nameTok: Token;
+export declare const starTok: Token;
+export declare const dotTok: Token;
+export declare const bangTok: Token;
+export declare const colonTok: Token;
+export declare const braceLTok: Token;
+export declare const braceRTok: Token;
+export declare const bracketLTok: Token;
+export declare const bracketRTok: Token;
+export declare const bracketDLTok: Token;
+export declare const bracketDRTok: Token;
+export declare const parenLTok: Token;
+export declare const parenRTok: Token;
+export declare const commaTok: Token;
+export declare const ignoreTok: Token;
+export declare const expandTok: Token;
+export declare const eofTok: Token;
+export {};