@woosh/meep-engine 2.49.6 → 2.49.8

package/src/core/parser/simple/SimpleParser.js

@@ -1,464 +0,0 @@
-import DataType from "./DataType.js";
-import ParserError from "./ParserError.js";
-import Token from "./Token.js";
-import TokenType from "./TokenType.js";
-import { readUnsignedInteger } from "./readUnsignedInteger.js";
-import { skipWhitespace } from "./skipWhitespace.js";
-
-
-const RX_IDENTIFIER_CHAR = /^[a-zA-Z0-9_]/;
-/**
- * @readonly
- * @type {RegExp}
- */
-export const RX_IDENTIFIER_FIRST_CHAR = /^[a-zA-Z_]/;
-
-/**
- * @readonly
- * @type {RegExp}
- */
-export const RX_DIGIT = /^[0-9]/i;
-
-/**
- *
- * @param {String} text
- * @param {number} cursor
- * @param {number} length
- * @returns {Token}
- */
-export function readReferenceToken(text, cursor, length) {
-    let i = cursor;
-
-    const identifiers = [];
-
-    let identifier;
-
-    identifier = readIdentifierToken(text, i, length);
-
-    identifiers.push(identifier);
-
-    i = identifier.end;
-
-    for (; ;) {
-
-        const firstChar = text.charAt(i);
-
-        if (firstChar !== '.') {
-            break;
-        }
-
-        //skip over the separator
-        i++;
-
-        identifier = readIdentifierToken(text, i, length);
-
-        identifiers.push(identifier);
-
-        i = identifier.end;
-    }
-
-    return new Token(identifiers, cursor, i, TokenType.Reference, DataType.String);
-}
-
-/**
- * Read C99 style IDENTIFIER token
- * @param {string} text
- * @param {number} cursor
- * @param {number} length
- * @returns {Token}
- */
-export function readIdentifierToken(text, cursor, length) {
-    let i = cursor;
-
-
-    const firstChar = text.charAt(i);
-
-    if (!RX_IDENTIFIER_FIRST_CHAR.test(firstChar)) {
-        throw new ParserError(i, `Expected first character to match /${RX_IDENTIFIER_FIRST_CHAR.toString()}/, instead got '${firstChar}'`, text);
-    }
-
-    i++;
-
-    for (; i < length; i++) {
-        const char = text.charAt(i);
-
-        if (!RX_IDENTIFIER_CHAR.test(char)) {
-            break;
-        }
-    }
-
-    const value = text.substring(cursor, i);
-
-    return new Token(value, cursor, i, TokenType.Identifier, DataType.String);
-}
-
-/**
- *
- * @param {string} text
- * @param {number} cursor
- * @returns {string}
- */
-function readQuote(text, cursor) {
-    const char = text.charAt(cursor);
-
-    if (char !== '"' && char !== '\'') {
-        throw new ParserError(cursor, "Expected \", found " + char + " instead", text);
-    }
-
-    return char;
-}
-
-/**
- *
- * @param {string} text
- * @param {number} cursor
- * @param {number} length
- * @returns {Token}
- */
-function readStringToken(text, cursor, length) {
-    let i = cursor;
-
-    const openingQuote = readQuote(text, i);
-
-    i++;
-
-    let char;
-
-    let value = '';
-    const lastPossibleChar = length - 1;
-
-    for (; i < lastPossibleChar; i++) {
-        char = text.charAt(i);
-
-        if (char === '\\') {
-            i++;
-            //read escape sequence
-            char = text.charAt(i);
-
-            switch (char) {
-                case 'n':
-                    value += '\n';
-                    break;
-                case 't':
-                    value += '\t';
-                    break;
-                case 'r':
-                    value += '\r';
-                    break;
-                case 'b':
-                    value += '\b';
-                    break;
-                case 'f':
-                    value += '\f';
-                    break;
-                case 'v':
-                    value += '\v';
-                    break;
-                case '0':
-                    value += '\0';
-                    break;
-                case '\\':
-                case "'":
-                case '"':
-                default:
-                    value += char;
-                    break;
-            }
-        } else if (char !== openingQuote) {
-            value += char;
-        } else {
-            break;
-        }
-    }
-
-    char = text.charAt(i);
-
-    if (char !== openingQuote) {
-        throw new ParserError(cursor, "Expected string terminator : " + openingQuote + ", but found '" + char + "' instead", text);
-    }
-
-    i++;
-
-    return new Token(value, cursor, i, TokenType.LiteralString, DataType.String);
-}
-
-/**
- *
- * @param {string} text
- * @param {number} cursor
- * @param {number} length
- * @returns {Token}
- */
-function readHex(text, cursor, length) {
-    const c0 = text.charAt(cursor);
-    const c1 = text.charAt(cursor + 1);
-
-    if (c0 !== '0' || !(c1 === 'x' || c1 === 'X')) {
-        throw new ParserError(cursor, 'Expected hex prefix 0x', text);
-    }
-
-    let i = cursor + 2;
-    let value = 0;
-
-    main_loop: for (; i < length;) {
-        const char = text.charAt(i);
-        let digit;
-        switch (char) {
-            case '0':
-                digit = 0;
-                break;
-            case '1':
-                digit = 1;
-                break;
-            case '2':
-                digit = 2;
-                break;
-            case '3':
-                digit = 3;
-                break;
-            case '4':
-                digit = 4;
-                break;
-            case '5':
-                digit = 5;
-                break;
-            case '6':
-                digit = 6;
-                break;
-            case '7':
-                digit = 7;
-                break;
-            case '8':
-                digit = 8;
-                break;
-            case '9':
-                digit = 9;
-                break;
-            case 'a':
-            case 'A':
-                digit = 10;
-                break;
-            case 'b':
-            case 'B':
-                digit = 11;
-                break;
-            case 'c':
-            case 'C':
-                digit = 12;
-                break;
-            case 'd':
-            case 'D':
-                digit = 13;
-                break;
-            case 'e':
-            case 'E':
-                digit = 14;
-                break;
-            case 'f':
-            case 'F':
-                digit = 15;
-                break;
-            default:
-                if (i === cursor) {
-                    //first character is not a digit
-                    throw new ParserError(i, `Expected a digit [0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F] but got '${char}' instead`, text);
-                }
-                //not a digit
-                break main_loop;
-        }
-        i++;
-        value = value * 16 + digit;
-    }
-
-
-    return new Token(value, cursor, i, null, DataType.Number);
-}
-
-
-/**
- *
- * @param {string} text
- * @param {number} cursor
- * @param {number} length
- * @returns {Token}
- */
-function readBoolean(text, cursor, length) {
-    const firstChar = text.charAt(cursor);
-
-    let value;
-    let end = cursor;
-
-    if (firstChar === 't' && length - cursor >= 4) {
-        if (text.substring(cursor + 1, cursor + 4) === 'rue') {
-            value = true;
-            end = cursor + 4;
-        } else {
-            throw new ParserError(cursor, `expected 'true', instead got '${text.substring(cursor, cursor + 4)}'`, text);
-        }
-    } else if (firstChar === 'f' && length - cursor >= 5) {
-        if (text.substring(cursor + 1, cursor + 5) === 'alse') {
-            value = false;
-            end = cursor + 5;
-        } else {
-            throw new ParserError(cursor, `expected 'false', instead got '${text.substring(cursor, cursor + 5)}'`, text);
-        }
-    } else {
-        throw new ParserError(cursor, `expected 't' or 'f', instead got '${firstChar}'`, text);
-    }
-
-    return new Token(value, cursor, end, TokenType.LiteralBoolean, DataType.Boolean);
-}
-
-/**
- *
- * @param {string} text
- * @param {number} cursor
- * @param {number} length
- * @returns {Token}
- */
-function readNumber(text, cursor, length) {
-    let i = cursor;
-
-    //read optional sign
-    function readSign(text) {
-        let sign = 1;
-        const firstChar = text.charAt(i);
-        if (firstChar === '-') {
-            sign = -1;
-        } else if (firstChar === '+') {
-            sign = 1;
-        } else {
-            return 1;
-        }
-
-        i = skipWhitespace(text, i + 1, length);
-
-        return sign;
-    }
-
-    const sign = readSign(text);
-
-    let value;
-
-    if (text.charAt(i) === '0' && (text.charAt(i + 1) === 'x' || text.charAt(i + 1) === 'x')) {
-        // hex number
-        const token = readHex(text, i, length);
-
-        i = token.end;
-
-        value = token.value;
-
-    } else {
-
-        const wholePart = readUnsignedInteger(text, i, length);
-
-        i = wholePart.end;
-
-        value = wholePart.value;
-
-        if (i < length) {
-            const dot = text.charAt(i);
-            if (dot === '.') {
-                i++;
-                const fraction = readUnsignedInteger(text, i, length);
-
-                const digits = (fraction.end - fraction.start);
-
-                value += fraction.value / Math.pow(10, digits);
-
-                i = fraction.end;
-            }
-        }
-    }
-
-    value *= sign;
-
-    return new Token(value, cursor, i, TokenType.LiteralNumber, DataType.Number);
-}
-
-function readArrayLiteral(text, cursor, length) {
-    let i = cursor;
-
-    const firstChar = text.charAt(i);
-    if (firstChar !== '[') {
-        throw new ParserError(cursor, `expected array start: '[', got '${firstChar}' instead`, text);
-    }
-
-    i++;
-
-    const values = [];
-    while (i < length) {
-        i = skipWhitespace(text, i, length);
-
-        const token = readLiteral(text, i, length);
-
-        i = token.end;
-
-        values.push(token);
-
-        //try find separator
-        i = skipWhitespace(text, i, length);
-        if (i < length) {
-            const char = text.charAt(i);
-            if (char === ',') {
-                //separator
-                i++;
-            } else if (char === ']') {
-                //end of sequence
-                i++;
-                break;
-            } else {
-                //unexpected input
-                throw new ParserError(i, `Unexpected input '${char}', expected either separator ',' or end of sequence ']'`, text);
-            }
-        } else {
-            throw new ParserError(i, `Unterminated array literal`, text);
-        }
-    }
-
-    return new Token(values, cursor, i, 'array', DataType.Array);
-}
-
-/**
- *
- * @param {string} text
- * @param {number} cursor
- * @param {number} length
- * @returns {Token}
- */
-function readLiteral(text, cursor, length) {
-    const firstChar = text.charAt(cursor);
-
-    switch (firstChar) {
-        case 't':
-        case 'f':
-            return readBoolean(text, cursor, length);
-        case '\"':
-        case "\'":
-            return readStringToken(text, cursor, length);
-        case '-':
-        case '+':
-        case '0':
-        case '1':
-        case '2':
-        case '3':
-        case '4':
-        case '5':
-        case '6':
-        case '7':
-        case '8':
-        case '9':
-            return readNumber(text, cursor, length);
-        case '[':
-            return readArrayLiteral(text, cursor, length);
-        default:
-            throw new ParserError(cursor, "Expected literal start, but found '" + firstChar + "'", text);
-    }
-}
-
-export {
-    readLiteral,
-    readNumber,
-    readStringToken,
-    readBoolean
-};

package/src/core/parser/simple/SimpleParser.spec.js

@@ -1,105 +0,0 @@
-import { readIdentifierToken, readReferenceToken, readStringToken } from "./SimpleParser.js";
-import TokenType from "./TokenType.js";
-
-test('parse empty string literal', () => {
-    const token = readStringToken('""', 0, 2);
-
-    expect(token.value).toBe("");
-    expect(token.start).toBe(0);
-    expect(token.end).toBe(2);
-});
-
-test('parse short string literal', () => {
-    const token = readStringToken('"1"', 0, 3);
-
-    expect(token.value).toBe("1");
-    expect(token.start).toBe(0);
-    expect(token.end).toBe(3);
-});
-
-test('parse short string literal from longer input', () => {
-    const token = readStringToken('"1"  ', 0, 5);
-
-    expect(token.value).toBe("1");
-    expect(token.start).toBe(0);
-    expect(token.end).toBe(3);
-});
-
-test('parse long string literal', () => {
-    const token = readStringToken('"hello world"', 0, 13);
-
-    expect(token.value).toBe("hello world");
-    expect(token.start).toBe(0);
-    expect(token.end).toBe(13);
-});
-
-test('parse a single escaped quote string literal', () => {
-    const token = readStringToken('"\\""', 0, 4);
-
-    expect(token.value).toBe('\"');
-    expect(token.start).toBe(0);
-    expect(token.end).toBe(4);
-});
-
-test('parse string literal with escaped quotes', () => {
-    const token = readStringToken('"what is \\"?"', 0, 13);
-
-    expect(token.value).toBe('what is "?');
-    expect(token.start).toBe(0);
-    expect(token.end).toBe(13);
-});
-
-test('parse string literal sequential escape sequences', () => {
-    const token = readStringToken('"\\n\\t"', 0, 6);
-
-    expect(token.value).toBe('\n\t');
-    expect(token.start).toBe(0);
-    expect(token.end).toBe(6);
-});
-
-test('parse identifier token starting with a number', () => {
-    expect(() => readIdentifierToken('0', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('1', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('2', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('3', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('4', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('5', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('6', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('7', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('8', 0, 1)).toThrow();
-    expect(() => readIdentifierToken('9', 0, 1)).toThrow();
-
-
-    expect(() => readIdentifierToken('9a', 0, 2)).toThrow();
-});
-
-test('parse identifier token with length 1', () => {
-    expect(readIdentifierToken('a', 0, 1).value).toBe('a');
-    expect(readIdentifierToken('A', 0, 1).value).toBe('A');
-    expect(readIdentifierToken('z', 0, 1).value).toBe('z');
-    expect(readIdentifierToken('Z', 0, 1).value).toBe('Z');
-    expect(readIdentifierToken('_', 0, 1).value).toBe('_');
-});
-
-test('parse identifier valid tokens', () => {
-    expect(readIdentifierToken('aa', 0, 2).value).toBe('aa');
-    expect(readIdentifierToken('a1', 0, 2).value).toBe('a1');
-    expect(readIdentifierToken('z ', 0, 2).value).toBe('z');
-    expect(readIdentifierToken('___ ', 0, 4).value).toBe('___');
-});
-
-test('parse reference a.b', () => {
-    const token = readReferenceToken('a.b', 0, 3);
-
-    expect(token.end).toBe(3);
-    expect(token.start).toBe(0);
-    expect(token.name).toBe(TokenType.Reference);
-
-    const identifiers = token.value;
-
-    expect(Array.isArray(identifiers)).toBe(true);
-    expect(identifiers.length).toBe(2);
-
-    expect(identifiers[0].value).toBe('a');
-    expect(identifiers[1].value).toBe('b');
-});