cariboujs 2.0.1 → 2.0.2

package/.build/grammars-v4/gvpr/JavaScript/GvprLexerBase.js

@@ -1,13 +0,0 @@
-import antlr4 from 'antlr4';
-import gvprLexer from './gvprLexer.js';
-
-export default class GvprLexerBase extends antlr4.Lexer {
-    constructor(input) {
-        super(input);
-    }
-
-	IsColumnZero() {
-		return this.column == 1;
-	}
-}
-

package/.build/grammars-v4/gvpr/JavaScript/GvprParserBase.js

@@ -1,20 +0,0 @@
-import antlr4 from 'antlr4';
-import gvprParser from './gvprParser.js';
-
-export default class GvprParserBase extends antlr4.Parser {
-    constructor(input) {
-        super(input);
-    }
-
-    IsSemiRequired() {
-		var c = this._input.LT(-1);
-		var d = this._input.LT(1);
-		return c.type !== gvprParser.CCBC;
-    }
-
-	IsSemiNotRequired() {
-		var c = this._input.LT(-1);
-		var d = this._input.LT(1);
-		return c.type === gvprParser.CCBC;
-	}
-}

package/.build/grammars-v4/javascript/ecmascript/examples/3728.js

@@ -1 +0,0 @@
-(||

package/.build/grammars-v4/javascript/ecmascript/examples/helloworld.js

@@ -1,11 +0,0 @@
-function factorial(n)
-{   if (n == 0)
-        return 1;
-    else
-        return n * factorial(n-1);
-}
-var i;
-document.clear();
-for (i = 0; i <= 16; i++)
-    document.write(i + "! = " + factorial(i) + "<br />");
-    

package/.build/grammars-v4/javascript/ecmascript/examples/nn.js

@@ -1,12 +0,0 @@
-var antlr4 = require('antlr4/index');
-var ECMAScriptLexer = require('./ECMAScriptLexer').ECMAScriptLexer;
-var ECMAScriptParser = require('./ECMAScriptParser').ECMAScriptParser;
-
-var inputStream = new antlr4.InputStream("a=x(10)");
-var lexer = new ECMAScriptLexer(inputStream);
-var tokens = new antlr4.CommonTokenStream(lexer);
-var parser = new ECMAScriptParser(tokens);
-parser.buildParseTrees = true;
-var tree = parser.program();
-console.log(tree.toStringTree(parser));
-

package/.build/grammars-v4/javascript/javascript/JavaScript/JavaScriptLexerBase.js

@@ -1,123 +0,0 @@
-import antlr4 from 'antlr4';
-import JavaScriptLexer from './JavaScriptLexer.js';
-
-export default class JavaScriptLexerBase extends antlr4.Lexer {
-
-    constructor(input) {
-        super(input);
-        this.scopeStrictModes = new Array();
-        this.lastToken = null;
-        this.useStrictDefault = false;
-        this.useStrictCurrent = false;
-        this.currentDepth = 0;
-        this.templateDepthStack = new Array();
-    }
-
-    getStrictDefault() {
-        return this.useStrictDefault;
-    }
-
-    setUseStrictDefault(value) {
-        this.useStrictDefault = value;
-        this.useStrictCurrent = value;
-    }
-
-    IsStrictMode() {
-        return this.useStrictCurrent;
-    }
-
-    IsInTemplateString() {
-        return this.templateDepthStack.length > 0 && this.templateDepthStack[this.templateDepthStack.length - 1] === this.currentDepth;
-    }
-
-    getCurrentToken() {
-        return this.nextToken();
-    }
-
-    nextToken() {
-        var next = super.nextToken();
-
-        if (next.channel === antlr4.Token.DEFAULT_CHANNEL) {
-            this.lastToken = next;
-        }
-        return next;
-    }
-
-    ProcessOpenBrace() {
-        this.currentDepth++;
-        this.useStrictCurrent =
-            this.scopeStrictModes.length > 0 && this.scopeStrictModes[this.scopeStrictModes.length - 1]
-                ? true
-                : this.useStrictDefault;
-        this.scopeStrictModes.push(this.useStrictCurrent);
-    }
-
-    ProcessCloseBrace() {
-        this.useStrictCurrent =
-            this.scopeStrictModes.length > 0
-                ? this.scopeStrictModes.pop()
-                : this.useStrictDefault;
-        this.currentDepth--;
-    }
-
-    ProcessStringLiteral() {
-        if (this.lastToken === null ||
-                this.lastToken.type === JavaScriptLexer.OpenBrace) {
-            if (super.text === '"use strict"' || super.text === "'use strict'") {
-                if (this.scopeStrictModes.length > 0) {
-                    this.scopeStrictModes.pop();
-                }
-                this.useStrictCurrent = true;
-                this.scopeStrictModes.push(this.useStrictCurrent);
-            }
-        }
-    }
-
-    ProcessTemplateOpenBrace() {
-        this.currentDepth++;
-        this.templateDepthStack.push(this.currentDepth);
-    }
-
-    ProcessTemplateCloseBrace() {
-        this.templateDepthStack.pop();
-        this.currentDepth--;
-    }
-
-    IsRegexPossible() {
-        if (this.lastToken === null) {
-            return true;
-        }
-
-        switch (this.lastToken.type) {
-            case JavaScriptLexer.Identifier:
-            case JavaScriptLexer.NullLiteral:
-            case JavaScriptLexer.BooleanLiteral:
-            case JavaScriptLexer.This:
-            case JavaScriptLexer.CloseBracket:
-            case JavaScriptLexer.CloseParen:
-            case JavaScriptLexer.OctalIntegerLiteral:
-            case JavaScriptLexer.DecimalLiteral:
-            case JavaScriptLexer.HexIntegerLiteral:
-            case JavaScriptLexer.StringLiteral:
-            case JavaScriptLexer.PlusPlus:
-            case JavaScriptLexer.MinusMinus:
-                return false;
-            default:
-                return true;
-        }
-    }
-
-    IsStartOfFile() {
-        return this.lastToken === null;
-    }
-
-    reset() {
-        this.scopeStrictModes = new Array();
-        this.lastToken = null;
-        this.useStrictDefault = false;
-        this.useStrictCurrent = false;
-        this.currentDepth = 0;
-        this.templateDepthStack = new Array();
-        super.reset();
-    }
-}

package/.build/grammars-v4/javascript/javascript/JavaScript/JavaScriptParserBase.js

@@ -1,69 +0,0 @@
-import antlr4 from 'antlr4';
-import JavaScriptParser from './JavaScriptParser.js';
-
-export default class JavaScriptParserBase extends antlr4.Parser {
-
-    constructor(input) {
-        super(input);
-    }
-
-    p(str) {
-        return this.prev(str);
-    }
-
-    prev(str) {
-        return  this._input.LT(-1).text === str;
-    }
-
-    // Short form for next(String str)
-    n(str)
-    {
-        return this.next(str);
-    }
-
-    // Whether the next token value equals to @param str
-    next(str)
-    {
-        return  this._input.LT(1).text === str;
-    }
-
-    notLineTerminator() {
-        return !this.lineTerminatorAhead();
-    }
-
-    notOpenBraceAndNotFunction() {
-        const nextTokenType = this._input.LT(1).type;
-        return (
-                nextTokenType !== JavaScriptParser.OpenBrace &&
-                nextTokenType !== JavaScriptParser.Function_
-               );
-    }
-
-    closeBrace() {
-        return this._input.LT(1).type === JavaScriptParser.CloseBrace;
-    }
-
-    lineTerminatorAhead() {
-        let possibleIndexEosToken = this.getCurrentToken().tokenIndex - 1;
-        if (possibleIndexEosToken < 0) return false;
-        let ahead = this._input.get(possibleIndexEosToken);
-        if (ahead.channel !== antlr4.Lexer.HIDDEN) {
-            return false;
-        }
-        if (ahead.type === JavaScriptParser.LineTerminator) {
-            return true;
-        }
-        if (ahead.type === JavaScriptParser.WhiteSpaces) {
-            possibleIndexEosToken = this.getCurrentToken().tokenIndex - 2;
-            if (possibleIndexEosToken < 0) return false;
-            ahead = this._input.get(possibleIndexEosToken);
-        }
-        const text = ahead.text;
-        const type = ahead.type;
-        return (
-                (type === JavaScriptParser.MultiLineComment &&
-                 (text.includes("\r") || text.includes("\n"))) ||
-                type === JavaScriptParser.LineTerminator
-               );
-    }
-}

package/.build/grammars-v4/javascript/javascript/_scripts/wrapper.js

@@ -1,33 +0,0 @@
-// eslump fuzz test warpper. we haven't pass it yet...
-var cp = require("child_process");
-var fs = require("fs");
-var os = require("os");
-module.exports = ({
-    code,
-    sourceType,
-    reproductionData = {}
-}) => {
-    fs.writeFileSync("gen/temp.js", code);
-    var posixcmd = "cd gen && grun JavaScript program temp.js 2>&1 1>/dev/null";
-    var cmd = {
-        aix: posixcmd,
-        // android: posixcmd
-        darwin: posixcmd,
-        freebsd: posixcmd,
-        linux: posixcmd,
-        openbsd: posixcmd,
-        // sunos: posixcmd,
-        win32: "cd gen && grun JavaScript program temp.js 2>&1 1>NUL",
-
-    }
-    var child = cp.execSync(cmd[os.platform()]).toString()
-    
-    if (child.length > 0) {
-        console.log('')
-        console.log(child)
-        return {
-            child,
-            reproductionData
-        };
-    }
-};

package/.build/grammars-v4/javascript/javascript/examples/3728.js

@@ -1 +0,0 @@
-(||

package/.build/grammars-v4/javascript/javascript/examples/ArrowFunctions.js

@@ -1,32 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Expression Bodies
-// More expressive closure syntax.
-// http://es6-features.org/#ExpressionBodies
-//------------------------------------------------------------------------------
-
-odds  = evens.map(v => v + 1)
-pairs = evens.map(v => ({ even: v, odd: v + 1 }))
-nums  = evens.map((v, i) => v + i)
-
-//------------------------------------------------------------------------------
-// Statement Bodies
-// More expressive closure syntax.
-// http://es6-features.org/#StatementBodies
-//------------------------------------------------------------------------------
-
-nums.forEach(v => {
-   if (v % 5 === 0)
-       fives.push(v)
-})
-
-//------------------------------------------------------------------------------
-// Lexical this
-// More intuitive handling of current object context.
-// http://es6-features.org/#Lexicalthis
-//------------------------------------------------------------------------------
-
-this.nums.forEach((v) => {
-    if (v % 5 === 0)
-        this.fives.push(v)
-})

package/.build/grammars-v4/javascript/javascript/examples/AsyncAwait.js

@@ -1,15 +0,0 @@
-async function f(){}
-
-class C {
-    async method(){}
-    static async method1(){}
-    static async #method2(){}
-    async *gen(){}
-}
-async ()=>{};
-
-async ()=>{await f();}
-async ()=>{await promise;}
-async ()=>{await 1;}
-
-async function* gen(){}

package/.build/grammars-v4/javascript/javascript/examples/ClassInNonGlobalStrict.js

@@ -1,5 +0,0 @@
-// Check whether static members are parsed inside a class
-// without explicit strict mode.
-class ClassWithoutExplicitStrictMode {
-    static myStaticMethod() {}
-}

package/.build/grammars-v4/javascript/javascript/examples/Classes.js

@@ -1,237 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Class Definition
-// More intuitive, OOP-style and boilerplate-free classes.
-// http://es6-features.org/#ClassDefinition
-//------------------------------------------------------------------------------
-
-class Shape {
-    constructor (id, x, y) {
-        this.id = id
-        this.move(x, y)
-    }
-    move (x, y) {
-        this.x = x
-        this.y = y
-    }
-}
-
-//------------------------------------------------------------------------------
-// Class Inheritance
-// More intuitive, OOP-style and boilerplate-free inheritance.
-// http://es6-features.org/#ClassInheritance
-//------------------------------------------------------------------------------
-
-class Rectangle extends Shape {
-    constructor (id, x, y, width, height) {
-        super(id, x, y)
-        this.width  = width
-        this.height = height
-    }
-}
-class Circle extends Shape {
-    constructor (id, x, y, radius) {
-        super(id, x, y)
-        this.radius = radius
-    }
-}
-
-//------------------------------------------------------------------------------
-// Class Inheritance, From Expressions
-// Support for mixin-style inheritance by extending from expressions yielding
-//   function objects. [Notice: the generic aggregation function is usually
-//   provided by a library like this one, of course]
-// http://es6-features.org/#ClassInheritanceFromExpressions
-//------------------------------------------------------------------------------
-
-var aggregation = (baseClass, ...mixins) => {
-    let base = class _Combined extends baseClass {
-        constructor (...args) {
-            super(...args)
-            mixins.forEach((mixin) => {
-                mixin.prototype.initializer.call(this)
-            })
-        }
-    }
-    let copyProps = (target, source) => {
-        Object.getOwnPropertyNames(source)
-            .concat(Object.getOwnPropertySymbols(source))
-            .forEach((prop) => {
-            if (prop.match(/^(?:constructor|prototype|arguments|caller|name|bind|call|apply|toString|length)$/))
-                return
-            Object.defineProperty(target, prop, Object.getOwnPropertyDescriptor(source, prop))
-        })
-    }
-    mixins.forEach((mixin) => {
-        copyProps(base.prototype, mixin.prototype)
-        copyProps(base, mixin)
-    })
-    return base
-}
-
-class Colored {
-    initializer ()     { this._color = "white" }
-    get color ()       { return this._color }
-    set color (v)      { this._color = v }
-}
-
-class ZCoord {
-    initializer ()     { this._z = 0 }
-    get z ()           { return this._z }
-    set z (v)          { this._z = v }
-}
-
-class Shape {
-    constructor (x, y) { this._x = x; this._y = y }
-    get x ()           { return this._x }
-    set x (v)          { this._x = v }
-    get y ()           { return this._y }
-    set y (v)          { this._y = v }
-}
-
-class Rectangle extends aggregation(Shape, Colored, ZCoord) {}
-
-var rect = new Rectangle(7, 42)
-rect.z     = 1000
-rect.color = "red"
-console.log(rect.x, rect.y, rect.z, rect.color)
-
-//------------------------------------------------------------------------------
-// Base Class Access
-// Intuitive access to base class constructor and methods.
-// http://es6-features.org/#BaseClassAccess
-//------------------------------------------------------------------------------
-
-class Shape {
-    // …
-    toString () {
-        return `Shape(${this.id})`
-    }
-}
-class Rectangle extends Shape {
-    constructor (id, x, y, width, height) {
-        super(id, x, y)
-        // …
-    }
-
-    toString () {
-        return "Rectangle > " + super.toString()
-    }
-}
-class Circle extends Shape {
-    constructor (id, x, y, radius) {
-        super(id, x, y)
-        // …
-    }
-    toString () {
-        return "Circle > " + super.toString()
-    }
-}
-
-//------------------------------------------------------------------------------
-// Static Members
-// Simple support for static class members.
-// http://es6-features.org/#StaticMembers
-//------------------------------------------------------------------------------
-
-class Rectangle extends Shape {
-    // …
-    static contextTypes = {
-        router: PropTypes.object,
-    };
-
-    static defaultRectangle () {
-        return new Rectangle("default", 0, 0, 100, 100)
-    }
-}
-class Circle extends Shape {
-    // …
-    static defaultCircle () {
-        return new Circle("default", 0, 0, 100)
-    }
-}
-var defRectangle = Rectangle.defaultRectangle()
-var defCircle    = Circle.defaultCircle()
-
-//------------------------------------------------------------------------------
-// Getter/Setter
-// Getter/Setter also directly within classes (and not just within object
-//   initializers, as it is possible since ECMAScript 5.1).
-// http://es6-features.org/#GetterSetter
-//------------------------------------------------------------------------------
-
-class Rectangle {
-    constructor (width, height) {
-        this._width  = width
-        this._height = height
-    }
-    set width  (width)  { this._width = width               }
-    get width  ()       { return this._width                }
-    set height (height) { this._height = height             }
-    get height ()       { return this._height               }
-    get area   ()       { return this._width * this._height }
-}
-var r = new Rectangle(50, 20)
-r.area === 1000
-
-//------------------------------------------------------------------------------
-// Class definition with empty statement
-//------------------------------------------------------------------------------
-class A {
-    ;
-}
-
-////
-class B {
-    get [runtimeCalc]() {return 1};
-    set [runtimeCalc](p) {};
-    get 'string as key'() {};
-}
-// extended object
-let Obj = {
-  [asdfg](a){},
-  * foo () {},
-  f(){},
-  get a(){},
-  set a([aa]=123){},
-  ...anotherObj,
-  ...{
-    speradObjectLiteral
-  },
-  ...functionResult()
-}
-
-//------------------------------------------------------------------------------
-// Public class fields
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/Public_class_fields
-//------------------------------------------------------------------------------
-const PREFIX = "prefix";
-
-class ClassWithField {
-  field;
-  fieldWithInitializer = "instance field";
-  [`${PREFIX}Field`] = "prefixed field";
-}
-
-const instance = new ClassWithField();
-console.log(Object.hasOwn(instance, "field")); // true
-console.log(instance.field); // undefined
-console.log(instance.fieldWithInitializer); // "instance field"
-console.log(instance.prefixField); // "prefixed field"
-
-//------------------------------------------------------------------------------
-// Static initialization blocks
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/Static_initialization_blocks
-//------------------------------------------------------------------------------
-class ClassWithStaticInitializationBlock {
-  static staticProperty1 = 'Property 1';
-  static staticProperty2;
-  static {
-    this.staticProperty2 = 'Property 2';
-  }
-}
-
-console.log(ClassWithStaticInitializationBlock.staticProperty1);
-// Expected output: "Property 1"
-console.log(ClassWithStaticInitializationBlock.staticProperty2);
-// Expected output: "Property 2"

package/.build/grammars-v4/javascript/javascript/examples/Constants.js

@@ -1,20 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Support for constants (also known as "immutable variables"), i.e.,
-//   variables which cannot be re-assigned new content.
-//   Notice: this only makes the variable itself immutable,
-//   not its assigned content (for instance, in case the content is an object,
-//   this means the object itself can still be altered).
-//------------------------------------------------------------------------------
-
-const PI = 3.141593
-PI > 3.0
-
-var c = 10;
-{
-    const c = 2; // At this point, c = 2.
-} // At this point, c = 10.
-
-const name = "Thomas Jefferson";
-const answer = 42, numpages = 10;
-const myarray = new Array();

package/.build/grammars-v4/javascript/javascript/examples/Continue.js

@@ -1,30 +0,0 @@
-// https://github.com/antlr/grammars-v4/issues/3772
-for (var i = 0; i < [].length; i++) {
-    var o = {}
-    if (false) continue
-    o[test]
-    
-    if (false) continue// comment
-    o[test]
-    
-    if (false) continue // comment
-    o[test]
-    
-    if (false) continue // comment
-    
-    o[test]
-    
-    if (false) continue/*
-         				* multiline comment
-         				*/
-    o[test]
-    
-    if (false) continue /*
-         				 * multiline comment
-         				*/
-    o[test]
-}
-
-mylabel: for (var i = 0; i < [].length; i++) {	
-    if (true) continue mylabel;
-}