cariboujs 2.0.1 → 2.0.2

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

@@ -1,70 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Array Matching
-// Intuitive and flexible destructuring of Arrays into individual variables during assignment.
-// http://es6-features.org/#ArrayMatching
-//------------------------------------------------------------------------------
-
-var list = [ 1, 2, 3 ]
-var [ a, , b ] = list
-[ b, a ] = [ a, b ]
-
-//------------------------------------------------------------------------------
-// Object Matching, Shorthand Notation
-// Intuitive and flexible destructuring of Objects into individual variables during assignment.
-// http://es6-features.org/#ObjectMatchingShorthandNotation
-//------------------------------------------------------------------------------
-
-var { op, lhs, rhs } = getASTNode()
-
-//------------------------------------------------------------------------------
-// Object Matching, Deep Matching
-// Intuitive and flexible destructuring of Objects into individual variables during assignment.
-// http://es6-features.org/#ObjectMatchingDeepMatching
-//------------------------------------------------------------------------------
-
-var { op: a, lhs: { op: b }, rhs: c } = getASTNode()
-
-//------------------------------------------------------------------------------
-// Object And Array Matching, Default Values
-// Simple and intuitive default values for destructuring of Objects and Arrays.
-// http://es6-features.org/#ObjectAndArrayMatchingDefaultValues
-//------------------------------------------------------------------------------
-
-var obj = { a: 1 }
-var list = [ 1 ]
-var { a, b = 2 } = obj
-var [ x, y = 2 ] = list
-
-//------------------------------------------------------------------------------
-// Parameter Context Matching
-// Intuitive and flexible destructuring of Arrays and Objects into individual
-//   parameters during function calls.
-// http://es6-features.org/#ParameterContextMatching
-//------------------------------------------------------------------------------
-
-function f ([ name, val ]) {
-    console.log(name, val)
-}
-function g ({ name: n, val: v }) {
-    console.log(n, v)
-}
-function h ({ name, val }) {
-    console.log(name, val)
-}
-f([ "bar", 42 ])
-g({ name: "foo", val:  7 })
-h({ name: "bar", val: 42 })
-
-//------------------------------------------------------------------------------
-// Fail-Soft Destructuring
-// Fail-soft destructuring, optionally with defaults.
-// http://es6-features.org/#FailSoftDestructuring
-//------------------------------------------------------------------------------
-
-var list = [ 7, 42 ]
-var [ a = 1, b = 2, c = 3, d ] = list
-a === 7
-b === 42
-c === 3
-d === undefined

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

@@ -1,38 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Property Shorthand
-// Shorter syntax for common object property definition idiom.
-// http://es6-features.org/#PropertyShorthand
-//------------------------------------------------------------------------------
-
-obj = { x, y }
-
-//------------------------------------------------------------------------------
-// Computed Property Names
-// Support for computed names in object property definitions.
-// http://es6-features.org/#ComputedPropertyNames
-//------------------------------------------------------------------------------
-
-let obj = {
-    foo: "bar",
-    [ "baz" + quux() ]: 42
-}
-
-var obj = {
-    foo: "bar"
-};
-obj[ "baz" + quux() ] = 42;
-
-//------------------------------------------------------------------------------
-// Method Properties
-// Support for method notation in object property definitions, for both regular
-//   functions and generator functions.
-// http://es6-features.org/#MethodProperties
-//------------------------------------------------------------------------------
-
-obj = {
-    foo (a, b) {
-    },
-    *quux (x, y) {
-    }
-}

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

@@ -1,32 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Regular Expression Sticky Matching
-// Keep the matching position sticky between matches and this way support
-//   efficient parsing of arbitrary long input strings, even with an arbitrary
-//   number of distinct regular expressions.
-// http://es6-features.org/#RegularExpressionStickyMatching
-//------------------------------------------------------------------------------
-
-let parser = (input, match) => {
-    for (let pos = 0, lastPos = input.length; pos < lastPos; ) {
-        for (let i = 0; i < match.length; i++) {
-            match[i].pattern.lastIndex = pos
-            let found
-            if ((found = match[i].pattern.exec(input)) !== null) {
-                match[i].action(found)
-                pos = match[i].pattern.lastIndex
-                break
-            }
-        }
-    }
-}
-
-let report = (match) => {
-    console.log(JSON.stringify(match))
-}
-parser("Foo 1 Bar 7 Baz 42", [
-    { pattern: /^Foo\s+(\d+)/y, action: (match) => report(match) },
-    { pattern: /^Bar\s+(\d+)/y, action: (match) => report(match) },
-    { pattern: /^Baz\s+(\d+)/y, action: (match) => report(match) },
-    { pattern: /^\s*/y,         action: (match) => {}            }
-])

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

@@ -1,22 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Binary & Octal Literal
-// Direct support for safe binary and octal literals.
-// http://es6-features.org/#BinaryOctalLiteral
-//------------------------------------------------------------------------------
-
-0b111110111 === 503
-0o767 === 503
-
-//------------------------------------------------------------------------------
-// Unicode String & RegExp Literal
-// Extended support using Unicode within strings and regular expressions.
-// http://es6-features.org/#UnicodeStringRegExpLiteral
-//------------------------------------------------------------------------------
-
-"𠮷".length === 2
-"𠮷".match(/./u)[0].length === 2
-"𠮷" === "\uD842\uDFB7"
-"𠮷" === "\u{20BB7}"
-"𠮷".codePointAt(0) == 0x20BB7
-for (let codepoint of "𠮷") console.log(codepoint)

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

@@ -1,40 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Default Parameter Values
-// Simple and intuitive default values for function parameters.
-// http://es6-features.org/#DefaultParameterValues
-//------------------------------------------------------------------------------
-
-function f (x, y = 7, z = 42) {
-    return x + y + z
-}
-f(1) === 50
-
-//------------------------------------------------------------------------------
-// Rest Parameter
-// Aggregation of remaining arguments into single parameter of variadic functions.
-// http://es6-features.org/#RestParameter
-//------------------------------------------------------------------------------
-
-function f (x, y, ...a) {
-    return (x + y) * a.length
-}
-f(1, 2, "hello", true, 7) === 9
-
-//------------------------------------------------------------------------------
-// Spread Operator
-// Spreading of elements of an iterable collection (like an array or even a string)
-//   into both literal elements and individual function parameters.
-// http://es6-features.org/#SpreadOperator
-//------------------------------------------------------------------------------
-
-var params = [ "hello", true, 7 ]
-var other = [ 1, 2, ...params ] // [ 1, 2, "hello", true, 7 ]
-
-function f (x, y, ...a) {
-    return (x + y) * a.length
-}
-f(1, 2, ...params) === 9
-
-var str = "foo"
-var chars = [ ...str ] // [ "f", "o", "o" ]

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

@@ -1,6 +0,0 @@
-f();
-f(a);
-f(...a);
-f(a,);
-f(1,2,...[3]);
-f(4,...a,...[b],);

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

@@ -1,141 +0,0 @@
-"use strict";
-
-//------------------------------------------------------------------------------
-// Generator Function, Iterator Protocol
-// Support for generators, a special case of Iterators containing a generator
-//   function, where the control flow can be paused and resumed, in order to
-//   produce sequence of values (either finite or infinite).
-// http://es6-features.org/#GeneratorFunctionIteratorProtocol
-//------------------------------------------------------------------------------
-
-let fibonacci = {
-    *[Symbol.iterator]() {
-        let pre = 0, cur = 1
-        for (;;) {
-            [ pre, cur ] = [ cur, pre + cur ]
-            yield cur
-        }
-    }
-}
-
-for (let n of fibonacci) {
-    if (n > 1000)
-        break
-    console.log(n)
-}
-
-//------------------------------------------------------------------------------
-// Generator Function, Direct Use
-// Support for generator functions, a special variant of functions where the
-//   control flow can be paused and resumed, in order to produce sequence of
-//   values (either finite or infinite).
-// http://es6-features.org/#GeneratorFunctionDirectUse
-//------------------------------------------------------------------------------
-
-function* range (start, end, step) {
-    while (start < end) {
-        yield start
-        start += step
-    }
-}
-
-for (let i of range(0, 10, 2)) {
-    console.log(i) // 0, 2, 4, 6, 8
-}
-
-//------------------------------------------------------------------------------
-// Generator Matching
-// Support for generator functions, i.e., functions where the control flow can 
-//   be paused and resumed, in order to produce and spread sequence of values
-//   (either finite or infinite).
-// http://es6-features.org/#GeneratorMatching
-//------------------------------------------------------------------------------
-
-let fibonacci = function* (numbers) {
-    let pre = 0, cur = 1
-    while (numbers-- > 0) {
-        [ pre, cur ] = [ cur, pre + cur ]
-        yield cur
-    }
-}
-
-for (let n of fibonacci(1000))
-    console.log(n)
-
-let numbers = [ ...fibonacci(1000) ]
-
-let [ n1, n2, n3, ...others ] = fibonacci(1000)
-
-//------------------------------------------------------------------------------
-// Generator Control-Flow
-//   Support for generators, a special case of Iterators where the control flow
-//   can be paused and resumed, in order to support asynchronous programming in
-//   the style of "co-routines" in combination with Promises (see below).
-//   [Notice: the generic async function usually is provided by a reusable
-//   library and given here just for better understanding. See co or Bluebird's
-//   coroutine in practice.]
-// http://es6-features.org/#GeneratorControlFlow
-//------------------------------------------------------------------------------
-
-// async is a keyword now...
-//  generic asynchronous control-flow driver
-function fasync (proc, ...params) {
-    var iterator = proc(...params)
-    return new Promise((resolve, reject) => {
-        let loop = (value) => {
-            let result
-            try {
-                result = iterator.next(value)
-            }
-            catch (err) {
-                reject(err)
-            }
-            if (result.done)
-                resolve(result.value)
-            else if (   typeof result.value      === "object"
-                     && typeof result.value.then === "function")
-                result.value.then((value) => {
-                    loop(value)
-                }, (err) => {
-                    reject(err)
-                })
-            else
-                loop(result.value)
-        }
-        loop()
-    })
-}
-
-//  application-specific asynchronous builder
-function makeAsync (text, after) {
-    return new Promise((resolve, reject) => {
-        setTimeout(() => resolve(text), after)
-    })
-}
-
-//  application-specific asynchronous procedure
-fasync(function* (greeting) {
-    let foo = yield makeAsync("foo", 300)
-    let bar = yield makeAsync("bar", 200)
-    let baz = yield makeAsync("baz", 100)
-    return `${greeting} ${foo} ${bar} ${baz}`
-}, "Hello").then((msg) => {
-    console.log("RESULT:", msg) // "Hello foo bar baz"
-})
-
-//------------------------------------------------------------------------------
-// Generator Methods
-// Support for generator methods, i.e., methods in classes and on objects, based on generator functions.
-// http://es6-features.org/#GeneratorMethods
-//------------------------------------------------------------------------------
-
-class Clz {
-    * bar () {
-        // …
-    }
-}
-let Obj = {
-    * foo () {
-        // …
-    }
-}

package/.build/grammars-v4/javascript/javascript/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";

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

@@ -1,52 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Collation
-// Sorting a set of strings and searching within a set of strings. Collation is
-//   parameterized by locale and aware of Unicode.
-// http://es6-features.org/#Collation
-//------------------------------------------------------------------------------
-
-// in German,  "ä" sorts with "a"
-// in Swedish, "ä" sorts after "z"
-var list = [ "ä", "a", "z" ]
-var l10nDE = new Intl.Collator("de")
-var l10nSV = new Intl.Collator("sv")
-l10nDE.compare("ä", "z") === -1
-l10nSV.compare("ä", "z") === +1
-console.log(list.sort(l10nDE.compare)) // [ "a", "ä", "z" ]
-console.log(list.sort(l10nSV.compare)) // [ "a", "z", "ä" ]
-
-//------------------------------------------------------------------------------
-// Number Formatting
-// Format numbers with digit grouping and localized separators.
-// http://es6-features.org/#NumberFormatting
-//------------------------------------------------------------------------------
-
-var l10nEN = new Intl.NumberFormat("en-US")
-var l10nDE = new Intl.NumberFormat("de-DE")
-l10nEN.format(1234567.89) === "1,234,567.89"
-l10nDE.format(1234567.89) === "1.234.567,89"
-
-//------------------------------------------------------------------------------
-// Currency Formatting
-// Format numbers with digit grouping, localized separators and attached currency symbol.
-// http://es6-features.org/#CurrencyFormatting
-//------------------------------------------------------------------------------
-
-var l10nUSD = new Intl.NumberFormat("en-US", { style: "currency", currency: "USD" })
-var l10nGBP = new Intl.NumberFormat("en-GB", { style: "currency", currency: "GBP" })
-var l10nEUR = new Intl.NumberFormat("de-DE", { style: "currency", currency: "EUR" })
-l10nUSD.format(100200300.40) === "$100,200,300.40"
-l10nGBP.format(100200300.40) === "£100,200,300.40"
-l10nEUR.format(100200300.40) === "100.200.300,40 €"
-
-//------------------------------------------------------------------------------
-// Date/Time Formatting
-// Format date/time with localized ordering and separators.
-// http://es6-features.org/#DateTimeFormatting
-//------------------------------------------------------------------------------
-
-var l10nEN = new Intl.DateTimeFormat("en-US")
-var l10nDE = new Intl.DateTimeFormat("de-DE")
-l10nEN.format(new Date("2015-01-02")) === "1/2/2015"
-l10nDE.format(new Date("2015-01-02")) === "2.1.2015"

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

@@ -1,3 +0,0 @@
-new Date
-new Date()
-Date()

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

@@ -1 +0,0 @@
-new Date().getTime()

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

@@ -1,25 +0,0 @@
-"use strict";
-
-//------------------------------------------------------------------------------
-// Iterator & For-Of Operator
-// http://es6-features.org/#IteratorForOfOperator
-// http://es6-features.org/#IteratorForOfOperator
-//------------------------------------------------------------------------------
-
-let fibonacci = {
-    [Symbol.iterator]() {
-        let pre = 0, cur = 1
-        return {
-           next () {
-               [ pre, cur ] = [ cur, pre + cur ]
-               return { done: false, value: cur }
-           }
-        }
-    }
-}
-
-for (let n of fibonacci) {
-    if (n > 1000)
-        break
-    console.log(n)
-}

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

@@ -1,7 +0,0 @@
-let foo = 123;
-var let = 123;
-
-var async = 456;
-
-"use strict";
-var let = 123;

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

@@ -1,3 +0,0 @@
-var sql = "line 1 \
-	some other line \
-the last line"

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

@@ -1,60 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Map/Set & WeakMap/WeakSet
-// Cleaner data-structure for common algorithms based on sets.
-// http://es6-features.org/#SetDataStructure
-//------------------------------------------------------------------------------
-
-let s = new Set()
-s.add("hello").add("goodbye").add("hello")
-s.size === 2
-s.has("hello") === true
-for (let key of s.values()) // insertion order
-    console.log(key)
-
-//------------------------------------------------------------------------------
-// Map Data-Structure
-// Cleaner data-structure for common algorithms based on maps.
-// http://es6-features.org/#MapDataStructure
-//------------------------------------------------------------------------------
-
-let m = new Map()
-let s = Symbol()
-m.set("hello", 42)
-m.set(s, 34)
-m.get(s) === 34
-m.size === 2
-for (let [ key, val ] of m.entries())
-    console.log(key + " = " + val)
-
-//------------------------------------------------------------------------------
-// Weak-Link Data-Structures
-// Memory-leak-free Object-key’d side-by-side data-structures.
-// http://es6-features.org/#WeakLinkDataStructures
-//------------------------------------------------------------------------------
-
-let isMarked     = new WeakSet()
-let attachedData = new WeakMap()
-
-export class Node {
-    constructor (id)   { this.id = id                  }
-    mark        ()     { isMarked.add(this)            }
-    unmark      ()     { isMarked.delete(this)         }
-    marked      ()     { return isMarked.has(this)     }
-    set data    (data) { attachedData.set(this, data)  }
-    get data    ()     { return attachedData.get(this) }
-}
-
-let foo = new Node("foo")
-
-JSON.stringify(foo) === '{"id":"foo"}'
-foo.mark()
-foo.data = "bar"
-foo.data === "bar"
-JSON.stringify(foo) === '{"id":"foo"}'
-
-isMarked.has(foo)     === true
-attachedData.has(foo) === true
-foo = null  /* remove only reference to foo */
-attachedData.has(foo) === false
-isMarked.has(foo)     === false

package/.build/grammars-v4/javascript/javascript/examples/Meta-Programming.js

@@ -1,28 +0,0 @@
-"use strict";
-//------------------------------------------------------------------------------
-// Proxying
-// Hooking into runtime-level object meta-operations.
-// http://es6-features.org/#Proxying
-//------------------------------------------------------------------------------
-
-let target = {
-    foo: "Welcome, foo"
-}
-let proxy = new Proxy(target, {
-    get (receiver, name) {
-        return name in receiver ? receiver[name] : `Hello, ${name}`
-    }
-})
-proxy.foo   === "Welcome, foo"
-proxy.world === "Hello, world"
-
-//------------------------------------------------------------------------------
-// Reflection
-// Make calls corresponding to the object meta-operations.
-// http://es6-features.org/#Reflection
-//------------------------------------------------------------------------------
-
-let obj = { a: 1 }
-Object.defineProperty(obj, "b", { value: 2 })
-obj[Symbol("c")] = 3
-Reflect.ownKeys(obj) // [ "a", "b", Symbol(c) ]

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

@@ -1,43 +0,0 @@
-var e\u0065e;
-var e\u{0065}e; // var eee;
-
-var Π;
-// var 全世界无产者联合起来; //UTF8
-var \u4e00;
-
-0b0n;
-12345n;
-0x1234n;
-12_123;
-1.123_3456e-7_8
-0b0_1n;
-
-try {}
-catch{}
-finally{}
-
-try {}
-finally{}
-
-2**3*5;
-
-async function process(array) {
-  for await (let i of array) {
-    doSomething(i);
-  }
-}
-
-const {a, ...c} = obj;
-const obj2 = { ...obj1, z: 26 ,...obj2};
-const [aa,b,...ca] = aarr;
-const v = [asdf,...gh,jk];
-var f = [,,c,...a,b,,];
-var g = [,,]; // [undefined,undefined]
-
-function f([asdfg]=12345){}
-/* TODO:
-function async (proc, ...params) {}
-var async = 1;*/
-
-const a = { duration: 50 };
-a.duration ??= 10;