cariboujs 2.0.1 → 2.0.2

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

@@ -1,39 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Value Export/Import
-// Support for exporting/importing values from/to modules without global namespace pollution.
-// http://es6-features.org/#ValueExportImport
-//------------------------------------------------------------------------------
-
-//  lib/math.js
-export function sum (x, y) { return x + y }
-export var pi = 3.141593
-
-//  someApp.js
-import * as math from "lib/math"
-console.log("2π = " + math.sum(math.pi, math.pi))
-
-//  otherApp.js
-import { sum, pi } from "lib/math"
-console.log("2π = " + sum(pi, pi))
-
-//------------------------------------------------------------------------------
-// Default & Wildcard
-// Marking a value as the default exported value and mass-mixin of values.
-// http://es6-features.org/#DefaultWildcard
-//------------------------------------------------------------------------------
-
-//  lib/mathplusplus.js
-export * from "lib/math"
-export var e = 2.71828182846
-export default (x) => Math.exp(x)
-
-//  someApp.js
-import exp, { pi, e } from "lib/mathplusplus"
-console.log("e^{π} = " + exp(pi))
-
-export {};
-import a,{aaa as bbb} from 'ccc';
-import('runtime_import');
-
-import React from 'react';

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

@@ -1,104 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Object Property Assignment
-// New function for assigning enumerable properties of one or more source
-//   objects onto a destination object.
-// http://es6-features.org/#ObjectPropertyAssignment
-//------------------------------------------------------------------------------
-
-var dest = { quux: 0 }
-var src1 = { foo: 1, bar: 2 }
-var src2 = { foo: 3, baz: 4 }
-Object.assign(dest, src1, src2)
-dest.quux === 0
-dest.foo  === 3
-dest.bar  === 2
-dest.baz  === 4
-
-//------------------------------------------------------------------------------
-// Array Element Finding
-// New function for finding an element in an array.
-// http://es6-features.org/#ArrayElementFinding
-//------------------------------------------------------------------------------
-
-[ 1, 3, 4, 2 ].find(x => x > 3) // 4
-[ 1, 3, 4, 2 ].findIndex(x => x > 3) // 2
-
-//------------------------------------------------------------------------------
-// String Repeating
-// New string repeating functionality.
-// http://es6-features.org/#StringRepeating
-//------------------------------------------------------------------------------
-
-" ".repeat(4 * depth)
-"foo".repeat(3)
-
-//------------------------------------------------------------------------------
-// String Searching
-// New specific string functions to search for a sub-string.
-// http://es6-features.org/#StringSearching
-//------------------------------------------------------------------------------
-
-"hello".startsWith("ello", 1) // true
-"hello".endsWith("hell", 4)   // true
-"hello".includes("ell")       // true
-"hello".includes("ell", 1)    // true
-"hello".includes("ell", 2)    // false
-
-//------------------------------------------------------------------------------
-// Number Type Checking
-// New functions for checking for non-numbers and finite numbers.
-// http://es6-features.org/#NumberTypeChecking
-//------------------------------------------------------------------------------
-
-Number.isNaN(42) === false
-Number.isNaN(NaN) === true
-
-Number.isFinite(Infinity) === false
-Number.isFinite(-Infinity) === false
-Number.isFinite(NaN) === false
-Number.isFinite(123) === true
-
-//------------------------------------------------------------------------------
-// Number Safety Checking
-// Checking whether an integer number is in the safe range, i.e., it is correctly
-//   represented by JavaScript (where all numbers, including integer numbers,
-//   are technically floating point number).
-// http://es6-features.org/#NumberSafetyChecking
-//------------------------------------------------------------------------------
-
-Number.isSafeInteger(42) === true
-Number.isSafeInteger(9007199254740992) === false
-
-//------------------------------------------------------------------------------
-// Number Comparison
-// Availability of a standard Epsilon value for more precise comparison of
-//   floating point numbers.
-// http://es6-features.org/#NumberComparison
-//------------------------------------------------------------------------------
-
-console.log(0.1 + 0.2 === 0.3) // false
-console.log(Math.abs((0.1 + 0.2) - 0.3) < Number.EPSILON) // true
-
-//------------------------------------------------------------------------------
-// Number Truncation
-// Truncate a floating point number to its integral part, completely dropping
-//   the fractional part.
-// http://es6-features.org/#NumberTruncation
-//------------------------------------------------------------------------------
-
-console.log(Math.trunc(42.7)) // 42
-console.log(Math.trunc( 0.1)) // 0
-console.log(Math.trunc(-0.1)) // -0
-
-//------------------------------------------------------------------------------
-// Number Sign Determination
-// Determine the sign of a number, including special cases of signed zero and non-number.
-// http://es6-features.org/#NumberSignDetermination
-//------------------------------------------------------------------------------
-
-console.log(Math.sign(7))   // 1
-console.log(Math.sign(0))   // 0
-console.log(Math.sign(-0))  // -0
-console.log(Math.sign(-7))  // -1
-console.log(Math.sign(NaN)) // NaN

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

@@ -1,18 +0,0 @@
-"use strict";
-
-//------------------------------------------------------------------------------
-// Object Literal
-// Initialization syntax for object literals
-// https://262.ecma-international.org/11.0/#prod-ObjectLiteral
-//------------------------------------------------------------------------------
-
-obj = { };
-obj = { item1: "item1", item2: "item2" };
-obj = { item1: "item1", item2: "item2", };
-obj = { item1: "item1",
-        item2: "item2",
-        item3: function(arg1) { return arg1; },
-        item4: function myFunction(arg1) { return arg1; },
-        item5: (arg1) => { return arg1; }
-      };
-

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

@@ -1,9 +0,0 @@
-"use strict";
-
-// Optional Chain
-//
-// https://262.ecma-international.org/11.0/#prod-OptionalChain
-
-var d = e?.f?.g;
-var h = i?.j();
-var k = l?.['m']?.n?.['o'];

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

@@ -1,11 +0,0 @@
-//------------------------------------------------------------------------------
-// Html Comment
-//------------------------------------------------------------------------------
-
-<!--//-->
-
-//------------------------------------------------------------------------------
-// CDATA Section
-//------------------------------------------------------------------------------
-
-<![CDATA[//><!--//--><!]]>

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

@@ -1,44 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Promise Usage
-//   First class representation of a value that may be made asynchronously and
-//   be available in the future.
-// http://es6-features.org/#PromiseUsage
-//------------------------------------------------------------------------------
-
-function msgAfterTimeout (msg, who, timeout) {
-    return new Promise((resolve, reject) => {
-        setTimeout(() => resolve(`${msg} Hello ${who}!`), timeout)
-    })
-}
-msgAfterTimeout("", "Foo", 100).then((msg) =>
-    msgAfterTimeout(msg, "Bar", 200)
-).then((msg) => {
-    console.log(`done after 300ms:${msg}`)
-})
-
-//------------------------------------------------------------------------------
-// Promise Combination
-// Combine one or more promises into new promises without having to take care
-//   of ordering of the underlying asynchronous operations yourself.
-// http://es6-features.org/#PromiseCombination
-//------------------------------------------------------------------------------
-
-function fetchAsync (url, timeout, onData, onError) {
-    // …
-}
-let fetchPromised = (url, timeout) => {
-    return new Promise((resolve, reject) => {
-        fetchAsync(url, timeout, resolve, reject)
-    })
-}
-Promise.all([
-    fetchPromised("http://backend/foo.txt", 500),
-    fetchPromised("http://backend/bar.txt", 500),
-    fetchPromised("http://backend/baz.txt", 500)
-]).then((data) => {
-    let [ foo, bar, baz ] = data
-    console.log(`success: foo=${foo} bar=${bar} baz=${baz}`)
-}, (err) => {
-    console.log(`error: ${err}`)
-})

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

@@ -1,34 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Block-Scoped Variables
-// Block-scoped variables (and constants) without hoisting.
-// http://es6-features.org/#BlockScopedVariables
-//------------------------------------------------------------------------------
-
-for (let i = 0; i < a.length; i++) {
-    let x = a[i]
-}
-for (let i = 0; i < b.length; i++) {
-    let y = b[i]
-}
-
-let callbacks = []
-for (let i = 0; i <= 2; i++) {
-    callbacks[i] = function () { return i * 2 }
-}
-callbacks[0]() === 0
-callbacks[1]() === 2
-callbacks[2]() === 4
-
-//------------------------------------------------------------------------------
-// Block-Scoped Functions
-// Block-scoped function definitions.
-// http://es6-features.org/#BlockScopedFunctions
-//------------------------------------------------------------------------------
-
-function foo () { return 1 }
-foo() === 1
-{
-    function foo () { return 2 }
-    foo() === 2
-}

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

@@ -1,7 +0,0 @@
-let as;
-let async;
-let from;
-let get;
-let of;
-let set;
-let yield;

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

@@ -1,15 +0,0 @@
-#! /usr/bin/env node
-// class field proposal, stage3 (2019/11/03)
-class CF {
-    #x = 12345;
-    y = id;
-    #priv_method(){
-        this.#x++;
-    }
-    async * #method() {
-    }
-    #priv_var = 9961;
-
-}
-
-var a = b??c;

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

@@ -1,17 +0,0 @@
-function strict() {
-   /* comment */
-   // comment
-   // comment
-  'use strict';
-  function nested()
-  {
-    let a = 4; // strict, "let" is not an identifier.
-    return 'And so am I!';
-  }
-  return "Hi!  I'm a strict mode function!  " + nested();
-}
-
-function notStrict() {
-  var let = 0; // not strict, no error.
-  return "I'm not strict.";
-}

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

@@ -1,3 +0,0 @@
-// comment before use strict
-"use strict";
-let a = 42;

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

@@ -1,42 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Symbol Type
-// Unique and immutable data type to be used as an identifier for object
-//   properties. Symbol can have an optional description, but for debugging
-//   purposes only.
-// http://es6-features.org/#SymbolType
-//------------------------------------------------------------------------------
-
-Symbol("foo") !== Symbol("foo")
-const foo = Symbol()
-const bar = Symbol()
-typeof foo === "symbol"
-typeof bar === "symbol"
-let obj = {}
-obj[foo] = "foo"
-obj[bar] = "bar"
-JSON.stringify(obj) // {}
-Object.keys(obj) // []
-Object.getOwnPropertyNames(obj) // []
-Object.getOwnPropertySymbols(obj) // [ foo, bar ]
-
-//------------------------------------------------------------------------------
-// Global Symbols
-// Global symbols, indexed through unique keys.
-// http://es6-features.org/#GlobalSymbols
-//------------------------------------------------------------------------------
-
-Symbol.for("app.foo") === Symbol.for("app.foo")
-const foo = Symbol.for("app.foo")
-const bar = Symbol.for("app.bar")
-Symbol.keyFor(foo) === "app.foo"
-Symbol.keyFor(bar) === "app.bar"
-typeof foo === "symbol"
-typeof bar === "symbol"
-let obj = {}
-obj[foo] = "foo"
-obj[bar] = "bar"
-JSON.stringify(obj) // {}
-Object.keys(obj) // []
-Object.getOwnPropertyNames(obj) // []
-Object.getOwnPropertySymbols(obj) // [ foo, bar ]

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

@@ -1,41 +0,0 @@
-"use strict";
-// TODO: implement interpolation expressions parsing.
-//------------------------------------------------------------------------------
-// String Interpolation
-// Intuitive expression interpolation for single-line and multi-line strings.
-//   (Notice: don't be confused, Template Literals were originally named
-//   "Template Strings" in the drafts of the ECMAScript 6 language specification)
-// http://es6-features.org/#StringInterpolation
-//------------------------------------------------------------------------------
-
-var customer = { name: "Foo" }
-var card = { amount: 7, product: "Bar", unitprice: 42 }
-var message = `Hello ${customer.name},
-want to buy ${card.amount} ${card.product} for
-a total of ${card.amount * card.unitprice} bucks?`
-var nested = `Object in template literal ${JSON.stringify({ key: 'value' })}`
-
-//------------------------------------------------------------------------------
-// Custom Interpolation
-// Flexible expression interpolation for arbitrary methods.
-// http://es6-features.org/#CustomInterpolation
-//------------------------------------------------------------------------------
-
-get`http://example.com/foo?bar=${bar + baz}&quux=${quux}`
-
-//------------------------------------------------------------------------------
-// Raw String Access
-// Access the raw template string content (backslashes are not interpreted).
-// http://es6-features.org/#RawStringAccess
-//------------------------------------------------------------------------------
-
-function quux (strings, ...values) {
-    strings[0] === "foo\n"
-    strings[1] === "bar"
-    strings.raw[0] === "foo\\n"
-    strings.raw[1] === "bar"
-    values[0] === 42
-}
-quux `foo\n${ 42 }bar`
-
-String.raw `foo\n${ 42 }bar` === "foo\\n42bar"

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

@@ -1,13 +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}}` : ""}`;

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

@@ -1,33 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Typed Arrays
-// Support for arbitrary byte-based data structures to implement network protocols,
-//   cryptography algorithms, file format manipulations, etc.
-// http://es6-features.org/#TypedArrays
-//------------------------------------------------------------------------------
-
-//  ES6 class equivalent to the following C structure:
-//  struct Example { unsigned long id; char username[16]; float amountDue }
-class Example {
-    constructor (buffer = new ArrayBuffer(24)) {
-        this.buffer = buffer
-    }
-    set buffer (buffer) {
-        this._buffer    = buffer
-        this._id        = new Uint32Array (this._buffer,  0,  1)
-        this._username  = new Uint8Array  (this._buffer,  4, 16)
-        this._amountDue = new Float32Array(this._buffer, 20,  1)
-    }
-    get buffer ()     { return this._buffer       }
-    set id (v)        { this._id[0] = v           }
-    get id ()         { return this._id[0]        }
-    set username (v)  { this._username[0] = v     }
-    get username ()   { return this._username[0]  }
-    set amountDue (v) { this._amountDue[0] = v    }
-    get amountDue ()  { return this._amountDue[0] }
-}
-
-let example = new Example()
-example.id = 7
-example.username = "John Doe"
-example.amountDue = 42.0

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

@@ -1 +0,0 @@
-var as = "test";

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

@@ -1,13 +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}}` : ""}`;

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

@@ -1,33 +0,0 @@
-// https://github.com/antlr/grammars-v4/issues/3484
-
-// Exporting declarations
-export let name1, name2/*, … */; // also var
-export const name1 = 1, name2 = 2/*, … */; // also var, let
-export function functionName() { /* … */ }
-export class ClassName { /* … */ }
-export function* generatorFunctionName() { /* … */ }
-export const { name1, name2: bar } = o;
-export const [ name1, name2 ] = array;
-
-// Export list
-export { name1, /* …, */ nameN };
-export { variable1 as name1, variable2 as name2, /* …, */ nameN };
-export { variable1 as "string name" };
-export { name1 as default /*, … */ };
-
-// Default exports
-export default expression;
-export default function functionName() { /* … */ }
-export default class ClassName { /* … */ }
-export default function* generatorFunctionName() { /* … */ }
-export default function () { /* … */ }
-export default class { /* … */ }
-export default function* () { /* … */ }
-
-// Aggregating modules
-export * from "module-name";
-export * as name1 from "module-name";
-export { name1, /* …, */ nameN } from "module-name";
-export { import1 as name1, import2 as name2, /* …, */ nameN } from "module-name";
-export { default, /* …, */ } from "module-name";
-export { default as name1 } from "module-name";

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

@@ -1,16 +0,0 @@
-// https://github.com/antlr/grammars-v4/issues/3484
-
-import defaultExport from "module-name";
-import * as name from "module-name";
-import { export1 } from "module-name";
-import { export1 as alias1 } from "module-name";
-import { default as alias } from "module-name";
-import { export1, export2 } from "module-name";
-import { export1, export2 as alias2, /* … */ } from "module-name";
-import { "string name" as alias } from "module-name";
-import defaultExport, { export1, /* … */ } from "module-name";
-import defaultExport, * as name from "module-name";
-import "module-name";
-
-import { "a-b" as yield } from "/modules/my-module.js";
-import { "a-b" as await } from "/modules/my-module.js";