cariboujs 2.0.1 → 2.0.2

package/.build/grammars-v4/javascript/typescript/examples/JavaScriptClass.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/typescript/examples/NonNullAssertOp.js

@@ -1,20 +0,0 @@
-class O{
-    i = 1;
-}
-
-class Entity{
-    name = "test";
-    obj = new O();
-}
-
-function processEntity(e?: Entity) {
-  let s = e!.name;
-  let t = e.name;
-  let o = e!.obj!.i;
-  let p = e?.name;
-
-  let i = p!;
-}
-
-var e = null;
-processEntity(e);

package/.build/grammars-v4/javascript/typescript/examples/TemplateStrings.js

@@ -1,23 +0,0 @@
-var empty = ``;
-
-var simple = `foobar`;
-
-var lineBreak = `
-`;
-
-var nested = `aaa${`bbb`}ccc`;
-
-// https://stackoverflow.com/questions/67618203/antlr4-parsing-templateliteral-in-jsx/67632704?noredirect=1#comment119548351_67632704
-let str =
-    `${dsName}${parameterStr ? `( ${parameterStr} )` : ""}${returns ? `{
-${returns}}` : ""}`;
-
-// https://github.com/antlr/grammars-v4/issues/2978
-let templateStringWithEscapes = `\\ \` \n \$`;
-
-// https://github.com/antlr/grammars-v4/issues/2978
-let templateStringWithEscapedLineBreak = `\
-`;
-
-// https://github.com/antlr/grammars-v4/issues/3051
-let nestedBracesTest = `${[1, 2, 3].map(x => { return x * 2;}).join("")}`;

package/.build/grammars-v4/kirikiri-tjs/JavaScript/TJSBaseLexer.js

@@ -1,49 +0,0 @@
-const antlr4 = require("antlr4/index");
-const TJSLexer = require("./TJSLexer");
-
-function TJSBaseLexer(input) {
-    antlr4.Lexer.call(this, input);
-
-    this.lastToken = null;
-}
-
-TJSBaseLexer.prototype = Object.create(antlr4.Lexer.prototype);
-
-TJSBaseLexer.prototype.getCurrentToken = function () {
-    return antlr4.Lexer.prototype.nextToken.call(this);
-};
-
-TJSBaseLexer.prototype.nextToken = function () {
-    var next = antlr4.Lexer.prototype.nextToken.call(this);
-
-    if (next.channel === antlr4.Token.DEFAULT_CHANNEL) {
-        this.lastToken = next;
-    }
-    return next;
-};
-
-TJSBaseLexer.prototype.IsRegexPossible = function () {
-    if (this.lastToken === null) {
-        return true;
-    }
-
-    switch (this.lastToken.type) {
-        case TJSLexer.Identifier:
-        case TJSLexer.NullLiteral:
-        case TJSLexer.BooleanLiteral:
-        case TJSLexer.This:
-        case TJSLexer.CloseBracket:
-        case TJSLexer.CloseParen:
-        case TJSLexer.OctalIntegerLiteral:
-        case TJSLexer.DecimalLiteral:
-        case TJSLexer.HexIntegerLiteral:
-        case TJSLexer.StringLiteral:
-        case TJSLexer.PlusPlus:
-        case TJSLexer.MinusMinus:
-            return false;
-        default:
-            return true;
-    }
-};
-
-module.exports.TJSBaseLexer = TJSBaseLexer;

package/.build/grammars-v4/kirikiri-tjs/JavaScript/TJSBaseParser.js

@@ -1,48 +0,0 @@
-const antlr4 = require("antlr4/index");
-const TJSParser = require("./TJSParser");
-
-function TJSBaseParser(input) {
-    antlr4.Parser.call(this, input);
-}
-
-TJSBaseParser.prototype = Object.create(antlr4.Parser.prototype);
-
-TJSBaseParser.prototype.notOpenBraceAndNotFunction = function () {
-    const nextTokenType = this._input.LT(1).type;
-    return (
-        nextTokenType !== TJSParser.OpenBrace &&
-        nextTokenType !== TJSParser.Function_
-    );
-};
-
-TJSBaseParser.prototype.closeBrace = function () {
-    return this._input.LT(1).type === TJSParser.CloseBrace;
-};
-
-TJSBaseParser.prototype.lineTerminatorAhead = function () {
-    let possibleIndexEosToken = this.getCurrentToken().tokenIndex - 1;
-    let ahead = this._input.get(possibleIndexEosToken);
-    if (ahead.channel !== antlr4.Lexer.HIDDEN) {
-        return false;
-    }
-
-    if (ahead.type === TJSParser.LineTerminator) {
-        return true;
-    }
-
-    if (ahead.type === TJSParser.WhiteSpaces) {
-        possibleIndexEosToken = this.getCurrentToken().getTokenIndex() - 2;
-        ahead = this._input.get(possibleIndexEosToken);
-    }
-
-    const text = ahead.type;
-    const type = ahead.type;
-
-    return (
-        (type === TJSParser.MultiLineComment &&
-            (text.includes("\r") || text.includes("\n"))) ||
-        type === TJSParser.LineTerminator
-    );
-};
-
-module.exports.TJSBaseParser = TJSBaseParser;

package/.build/grammars-v4/kirikiri-tjs/preprocess.js

@@ -1,65 +0,0 @@
-// Node.js v10
-
-// Minimal preprocessor for TJS2
-// See https://krkrz.github.io/krkr2doc/tjs2doc/contents/pp.html
-const fs = require('fs');
-const vm = require('vm');
-
-const fstr = fs.readFileSync(0).toString(); // STDIN=0
-const lines = fstr.split(/\r?\n/);
-
-// You may need modify this
-let sandbox = {
-    version: 0x02040009,
-    kirikiriz: 1,
-    environment: 0,
-
-    KAGHOOK_EVENTACTION: 0,
-    APPEND_EXTENTION: 0,
-    DEBUG: 0,
-    PACKED: 0,
-    SYSVOICE_USE_CLEARTYPEVOICE: 0,
-};
-vm.createContext(sandbox);
-const exec = (code) => {
-    try {
-        return vm.runInContext(code, sandbox);
-    } catch(e){
-        console.error(`// Preprocessor: ${e.toString()}`)
-    }
-}
-
-let canOutput = true;
-const mapped = lines.map((l, i) => {
-    const line = l.trim()
-    let writeback = l;
-    if (!canOutput) writeback = '//' + l;
-    if (line[0] === '@' && (line[1] !== '"' && line[1] !== "'")) {
-        const match = line.match(/\@([^(]*)(\(.*\))?/);
-        writeback = '// ' + l;
-        switch (match[1].trim()) {
-            case "if":
-                if (!canOutput) break;
-                const cond = match[2];
-                const result = exec(cond);
-                if (!result) {
-                    canOutput = false;
-                }
-                break;
-            case "endif":
-                canOutput = true;
-                break;
-            case "set":
-                if (!canOutput) break;
-                exec(match[2]);
-                break;
-            default:
-                // console.error(` Preprocessor unknown command at ${i}: '${line}', '${match[1]}'`);
-                writeback = l;
-                break;
-        }
-    }
-    return writeback;
-});
-
-console.log(mapped.join('\n'));

package/.build/grammars-v4/lua/JavaScript/LuaLexerBase.js

@@ -1,70 +0,0 @@
-import { Lexer } from "antlr4";
-export default class LuaLexerBase extends Lexer {
-    constructor(input) {
-        super(input);
-    }
-    HandleComment() {
-        this.start_line = this.line;
-        this.start_col = this.column - 2;
-        let cs = this._input;
-        if (cs.LA(1) === 91) { /* '[' */
-            let sep = this.skip_sep(cs);
-            if (sep >= 2) {
-                this.read_long_string(cs, sep);
-                return;
-            }
-        }
-        while (cs.LA(1) !== 10 /* '\n' */ && cs.LA(1) !== -1) {
-            this._interp.consume(cs);
-        }
-    }
-    read_long_string(cs, sep) {
-        let done = false;
-        this._interp.consume(cs);
-        for (;;) {
-            let c = cs.LA(1);
-            switch (c) {
-                case -1:
-                    done = true;
-                    //                    let listener = this.getErrorListenerDispatch();
-                    //                    listener.syntaxError(this, null, this.start_line, this.start_col, "unfinished long comment", null);
-                    break;
-                case 93: /* ']' */
-                    if (this.skip_sep(cs) === sep) {
-                        this._interp.consume(cs);
-                        done = true;
-                    }
-                    break;
-                default:
-                    if (cs.LA(1) === -1) {
-                        done = true;
-                        break;
-                    }
-                    this._interp.consume(cs);
-                    break;
-            }
-            if (done)
-                break;
-        }
-    }
-    skip_sep(cs) {
-        let count = 0;
-        let s = cs.LA(1);
-        this._interp.consume(cs);
-        while (cs.LA(1) === 61 /* '=' */) {
-            this._interp.consume(cs);
-            count++;
-        }
-        if (cs.LA(1) === s)
-            count += 2;
-        else if (count === 0)
-            count = 1;
-        else
-            count = 0;
-        return count;
-    }
-    IsLine1Col0() {
-        let cs = this._input;
-        return cs.index === 1;
-    }
-}

package/.build/grammars-v4/lua/JavaScript/LuaParserBase.js

@@ -1,17 +0,0 @@
-import { Parser } from "antlr4";
-import LuaParser from './LuaParser.js';
-export default class LuaParserBase extends Parser {
-    constructor(input) {
-        super(input);
-    }
-    IsFunctionCall() {
-        const stream = this._input;
-        var la = stream.LT(1);
-        if (la.type !== LuaParser.NAME)
-            return false;
-        la = stream.LT(2);
-        if (la.type === LuaParser.OP)
-            return false;
-        return true;
-    }
-}

package/.build/grammars-v4/php/JavaScript/PhpLexerBase.js

@@ -1,164 +0,0 @@
-/*
- PHP grammar.
-
- The MIT License (MIT).
- Copyright (c) 2015-2017, Ivan Kochurkin (kvanttt@gmail.com), Positive
- Technologies.
- Copyright (c) 2019, Thierry Marianne (thierry.marianne@weaving-the-web.org)
-
- Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
- associated documentation files (the "Software"), to deal in the Software without restriction,
- including without limitation the rights to use, copy, modify, merge, publish, distribute,
- sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
- furnished to do so, subject to the following conditions:
-
- The above copyright notice and this permission notice shall be included in all copies or
- substantial portions of the Software.
-
- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
- NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
- DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT
- OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-const antlr4 = require("antlr4/index");
-const CommonToken = require('antlr4/Token').CommonToken;
-
-function PhpLexerBase(input) {
-    antlr4.Lexer.call(this, input);
-    this.AspTags = true;
-    this._scriptTag = false;
-    this._styleTag = false;
-    this._heredocIdentifier = undefined;
-    this._prevTokenType = 0;
-    this._htmlNameText = undefined;
-    this._phpScript = false;
-    this._insideString = false;
-}
-
-PhpLexerBase.prototype = Object.create(antlr4.Lexer.prototype);
-PhpLexerBase.prototype.constructor = antlr4.Lexer;
-
-PhpLexerBase.prototype.nextToken = function() {
-    let token = antlr4.Lexer.prototype.nextToken.call(this);
-
-    if (token.type === this.PHPEnd || token.type === this.PHPEndSingleLineComment) {
-        if (this._mode === this.SingleLineCommentMode) {
-            // SingleLineCommentMode for such allowed syntax:
-            // // <?php echo "Hello world"; // comment ?>
-            this.popMode();
-        }
-        this.popMode();
-
-        if (token.text === "</script>") {
-            this._phpScript = false;
-            token.type = this.HtmlScriptClose;
-        } else {
-            // Add semicolon to the end of statement if it is absent.
-            // For example: <?php echo "Hello world" ?>
-            if (this._prevTokenType === this.SemiColon || this._prevTokenType === this.Colon || this._prevTokenType === this.OpenCurlyBracket || this._prevTokenType === this.CloseCurlyBracket) {
-                token = antlr4.Lexer.prototype.nextToken.call(this);
-            } else {
-                token = CommonToken(type=this.SemiColon);
-                token.text = ';';
-            }
-        }
-    }
-
-    else if (token.type === this.HtmlName) {
-        this._htmlNameText = token.text
-    }
-
-    else if (token.type === this.HtmlDoubleQuoteString) {
-        if (token.text === "php" && this._htmlNameText === "language") {
-            this._phpScript = true;
-        }
-    }
-
-    else if (this._mode === this.HereDoc) {
-        // Heredoc and Nowdoc syntax support: http://php.net/manual/en/language.types.string.php#language.types.string.syntax.heredoc
-        if (token.type === this.StartHereDoc || token.type === this.StartNowDoc) {
-            this._heredocIdentifier = token.text.slice(3).trim().replace(/\'$/, '');
-        }
-
-        if (token.type === this.HereDocText) {
-            if (this.CheckHeredocEnd(token.text)) {
-                this.popMode()
-                const heredocIdentifier = this.GetHeredocEnd(token.text)
-                if (token.text.trim().endsWith(';')) {
-                    token = new CommonToken(CommonToken.EMPTY_SOURCE, type=this.SemiColon);
-                    token.text = `${heredocIdentifier};\n`;
-                } else {
-                    token = antlr4.Lexer.prototype.nextToken.call(this);
-                    token.text = `${heredocIdentifier}\n;`;
-                }
-            }
-        }
-    }
-
-    else if (this._mode === this.PHP) {
-        if (this._channel === this.HIDDEN) {
-            this._prevTokenType = token.type;
-        }
-    }
-
-    return token;
-};
-
-PhpLexerBase.prototype.GetHeredocEnd = function(text) {
-    return text.trim().replace(/\;$/, "");
-};
-
-PhpLexerBase.prototype.CheckHeredocEnd = function(text) {
-    return this.GetHeredocEnd(text) === this._heredocIdentifier;
-};
-
-PhpLexerBase.prototype.IsNewLineOrStart = function (pos) {
-    return this._input.LA(pos) <= 0 || this._input.LA(pos) == '\r'.charCodeAt(0) ||
-        this._input.LA(pos) == '\n'.charCodeAt(0)
-};
-
-PhpLexerBase.prototype.PushModeOnHtmlClose = function () {
-    this.popMode();
-    if (this._scriptTag) {
-        if (!this._phpScript) {
-            this.pushMode(this.SCRIPT);
-        } else {
-            this.pushMode(this.PHP);
-        }
-        this._scriptTag = false;
-    } else if (this._styleTag) {
-        this.pushMode(this.STYLE);
-        this._styleTag = false;
-    }
-};
-PhpLexerBase.prototype.HasAspTags = function () {
-    return this.AspTags;
-};
-
-PhpLexerBase.prototype.HasPhpScriptTag = function () {
-    return this._phpScript;
-};
-
-PhpLexerBase.prototype.PopModeOnCurlyBracketClose = function () {
-    if (this._insideString) {
-        this._insideString = false;
-        this.skip;
-        this.popMode();
-    }
-};
-
-PhpLexerBase.prototype.ShouldPushHereDocMode = function (pos) {
-    return this._input.LA(pos) === '\r'.charCodeAt(0) || this._input.LA(pos) === '\n'.charCodeAt(0);
-};
-
-PhpLexerBase.prototype.IsCurlyDollar = function (pos) {
-    return this._input.LA(pos) === '$'.charCodeAt(0);
-};
-
-PhpLexerBase.prototype.SetInsideString = function () {
-    this._insideString = true
-};
-
-exports.PhpLexerBase = PhpLexerBase;